Remove PS3 linux-2.6.27 kernel support

Signed-off-by: Geoff Levand <geoffrey.levand@am.sony.com>

SVN-Revision: 14857

2 files changed, 0 insertions, 32090 deletions

diff --git a/target/linux/ps3/config-2.6.27 b/target/linux/ps3/config-2.6.27
deleted file mode 100644
index a3fe801554..0000000000
--- a/target/linux/ps3/config-2.6.27
+++ /dev/null
@@ -1,438 +0,0 @@
-CONFIG_64BIT=y
-CONFIG_ALTIVEC=y
-CONFIG_ARCH_ENABLE_MEMORY_HOTPLUG=y
-CONFIG_ARCH_ENABLE_MEMORY_HOTREMOVE=y
-CONFIG_ARCH_HAS_ILOG2_U32=y
-CONFIG_ARCH_HAS_ILOG2_U64=y
-CONFIG_ARCH_HAS_WALK_MEMORY=y
-CONFIG_ARCH_MAY_HAVE_PC_FDC=y
-CONFIG_ARCH_MEMORY_PROBE=y
-CONFIG_ARCH_NO_VIRT_TO_BUS=y
-CONFIG_ARCH_POPULATES_NODE_MAP=y
-CONFIG_ARCH_SELECT_MEMORY_MODEL=y
-CONFIG_ARCH_SPARSEMEM_DEFAULT=y
-CONFIG_ARCH_SPARSEMEM_ENABLE=y
-# CONFIG_ARCH_SUPPORTS_MSI is not set
-CONFIG_ARCH_WANT_OPTIONAL_GPIOLIB=y
-# CONFIG_ARPD is not set
-# CONFIG_ATM is not set
-CONFIG_AUDIT_ARCH=y
-CONFIG_BASE_SMALL=0
-CONFIG_BITREVERSE=y
-CONFIG_BLK_DEV_LOOP=y
-CONFIG_BLK_DEV_RAM=y
-CONFIG_BLK_DEV_RAM_COUNT=16
-CONFIG_BLK_DEV_RAM_SIZE=65535
-CONFIG_BLK_DEV_SD=y
-CONFIG_BLK_DEV_SR=y
-# CONFIG_BLK_DEV_SR_VENDOR is not set
-# CONFIG_BLK_DEV_XIP is not set
-CONFIG_BLOCK_COMPAT=y
-# CONFIG_BONDING is not set
-# CONFIG_BOOTX_TEXT is not set
-CONFIG_BOUNCE=y
-# CONFIG_BRIDGE is not set
-# CONFIG_BSD_PROCESS_ACCT is not set
-# CONFIG_BT is not set
-# CONFIG_CGROUP_SCHED is not set
-# CONFIG_CIFS is not set
-CONFIG_CLASSIC_RCU=y
-# CONFIG_CMDLINE_BOOL is not set
-CONFIG_COMPAT=y
-CONFIG_COMPAT_BINFMT_ELF=y
-CONFIG_COMPAT_BRK=y
-# CONFIG_CONFIGFS_FS is not set
-CONFIG_CONSOLE_TRANSLATIONS=y
-# CONFIG_CPU_FREQ is not set
-# CONFIG_CRASH_DUMP is not set
-# CONFIG_CRC16 is not set
-# CONFIG_CRC_CCITT is not set
-# CONFIG_CRC_ITU_T is not set
-# CONFIG_CRYPTO_AES is not set
-CONFIG_CRYPTO_ALGAPI=y
-# CONFIG_CRYPTO_ANUBIS is not set
-# CONFIG_CRYPTO_ARC4 is not set
-# CONFIG_CRYPTO_AUTHENC is not set
-CONFIG_CRYPTO_BLKCIPHER=y
-# CONFIG_CRYPTO_BLOWFISH is not set
-# CONFIG_CRYPTO_CAMELLIA is not set
-# CONFIG_CRYPTO_CAST5 is not set
-# CONFIG_CRYPTO_CAST6 is not set
-CONFIG_CRYPTO_CBC=y
-# CONFIG_CRYPTO_CRC32C is not set
-# CONFIG_CRYPTO_DEFLATE is not set
-CONFIG_CRYPTO_DES=y
-# CONFIG_CRYPTO_ECB is not set
-# CONFIG_CRYPTO_HMAC is not set
-# CONFIG_CRYPTO_KHAZAD is not set
-CONFIG_CRYPTO_MANAGER=y
-# CONFIG_CRYPTO_MD4 is not set
-CONFIG_CRYPTO_MD5=y
-# CONFIG_CRYPTO_MICHAEL_MIC is not set
-# CONFIG_CRYPTO_NULL is not set
-# CONFIG_CRYPTO_SERPENT is not set
-# CONFIG_CRYPTO_SHA1 is not set
-# CONFIG_CRYPTO_SHA256 is not set
-# CONFIG_CRYPTO_SHA512 is not set
-# CONFIG_CRYPTO_TEA is not set
-# CONFIG_CRYPTO_TEST is not set
-# CONFIG_CRYPTO_TGR192 is not set
-# CONFIG_CRYPTO_TWOFISH is not set
-# CONFIG_CRYPTO_WP512 is not set
-# CONFIG_DEBUG_BUGVERBOSE is not set
-# CONFIG_DEBUG_FS is not set
-CONFIG_DEFAULT_AS=y
-# CONFIG_DEFAULT_DEADLINE is not set
-CONFIG_DEFAULT_IOSCHED="anticipatory"
-CONFIG_DEFAULT_TCP_CONG="cubic"
-# CONFIG_DEFAULT_UIMAGE is not set
-CONFIG_DEVKMEM=y
-CONFIG_DNOTIFY=y
-CONFIG_DUMMY_CONSOLE=y
-CONFIG_EARLY_PRINTK=y
-# CONFIG_EDAC is not set
-CONFIG_ELF_CORE=y
-# CONFIG_ENABLE_WARN_DEPRECATED is not set
-CONFIG_EXT2_FS=y
-CONFIG_EXT3_FS=y
-# CONFIG_EXT3_FS_POSIX_ACL is not set
-# CONFIG_EXT3_FS_SECURITY is not set
-CONFIG_EXT3_FS_XATTR=y
-CONFIG_FAIR_GROUP_SCHED=y
-CONFIG_FAT_FS=y
-CONFIG_FB=y
-# CONFIG_FB_BACKLIGHT is not set
-# CONFIG_FB_CFB_COPYAREA is not set
-# CONFIG_FB_CFB_FILLRECT is not set
-# CONFIG_FB_CFB_IMAGEBLIT is not set
-# CONFIG_FB_CFB_REV_PIXELS_IN_BYTE is not set
-# CONFIG_FB_DDC is not set
-# CONFIG_FB_FOREIGN_ENDIAN is not set
-# CONFIG_FB_MACMODES is not set
-# CONFIG_FB_MODE_HELPERS is not set
-# CONFIG_FB_OF is not set
-CONFIG_FB_PS3=y
-CONFIG_FB_PS3_DEFAULT_SIZE_M=9
-# CONFIG_FB_S1D13XXX is not set
-# CONFIG_FB_SVGALIB is not set
-CONFIG_FB_SYS_COPYAREA=y
-CONFIG_FB_SYS_FILLRECT=y
-CONFIG_FB_SYS_FOPS=y
-CONFIG_FB_SYS_IMAGEBLIT=y
-# CONFIG_FB_TILEBLITTING is not set
-# CONFIG_FB_VGA16 is not set
-# CONFIG_FB_VIRTUAL is not set
-# CONFIG_FIRMWARE_EDID is not set
-# CONFIG_FLATMEM_MANUAL is not set
-# CONFIG_FONTS is not set
-CONFIG_FONT_8x16=y
-CONFIG_FONT_8x8=y
-CONFIG_FORCE_MAX_ZONEORDER=13
-CONFIG_FRAMEBUFFER_CONSOLE=y
-CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y
-CONFIG_FRAMEBUFFER_CONSOLE_ROTATION=y
-CONFIG_FRAME_WARN=2048
-# CONFIG_FSL_ULI1575 is not set
-CONFIG_FS_MBCACHE=y
-CONFIG_GELIC_NET=y
-# CONFIG_GELIC_WIRELESS is not set
-CONFIG_GENERIC_BUG=y
-CONFIG_GENERIC_CLOCKEVENTS=y
-CONFIG_GENERIC_CLOCKEVENTS_BUILD=y
-CONFIG_GENERIC_CMOS_UPDATE=y
-# CONFIG_GENERIC_FIND_FIRST_BIT is not set
-CONFIG_GENERIC_FIND_NEXT_BIT=y
-# CONFIG_GENERIC_IOMAP is not set
-CONFIG_GENERIC_ISA_DMA=y
-# CONFIG_GENERIC_TBSYNC is not set
-CONFIG_GENERIC_TIME_VSYSCALL=y
-# CONFIG_GEN_RTC is not set
-CONFIG_GROUP_SCHED=y
-# CONFIG_HAMRADIO is not set
-# CONFIG_HANGCHECK_TIMER is not set
-CONFIG_HAS_DMA=y
-CONFIG_HAS_IOMEM=y
-CONFIG_HAS_IOPORT=y
-# CONFIG_HAS_RAPIDIO is not set
-CONFIG_HAVE_ARCH_KGDB=y
-CONFIG_HAVE_ARCH_TRACEHOOK=y
-# CONFIG_HAVE_CLK is not set
-CONFIG_HAVE_DMA_ATTRS=y
-CONFIG_HAVE_DYNAMIC_FTRACE=y
-CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS=y
-CONFIG_HAVE_FTRACE=y
-# CONFIG_HAVE_GENERIC_DMA_COHERENT is not set
-CONFIG_HAVE_IDE=y
-CONFIG_HAVE_IOREMAP_PROT=y
-CONFIG_HAVE_KPROBES=y
-CONFIG_HAVE_KRETPROBES=y
-CONFIG_HAVE_LATENCYTOP_SUPPORT=y
-CONFIG_HAVE_LMB=y
-CONFIG_HAVE_MEMORY_PRESENT=y
-CONFIG_HAVE_OPROFILE=y
-CONFIG_HAVE_SETUP_PER_CPU_AREA=y
-# CONFIG_HFSPLUS_FS is not set
-# CONFIG_HFS_FS is not set
-CONFIG_HID=y
-CONFIG_HID_SUPPORT=y
-# CONFIG_HIGH_RES_TIMERS is not set
-# CONFIG_HUGETLBFS is not set
-CONFIG_HW_CONSOLE=y
-# CONFIG_HW_RANDOM is not set
-CONFIG_HZ=250
-# CONFIG_HZ_100 is not set
-CONFIG_HZ_250=y
-# CONFIG_I2C is not set
-# CONFIG_IDE is not set
-# CONFIG_IEEE80211 is not set
-# CONFIG_INET_AH is not set
-# CONFIG_INET_DIAG is not set
-# CONFIG_INET_ESP is not set
-# CONFIG_INET_IPCOMP is not set
-# CONFIG_INET_TUNNEL is not set
-# CONFIG_INET_XFRM_MODE_BEET is not set
-# CONFIG_INET_XFRM_MODE_TRANSPORT is not set
-# CONFIG_INET_XFRM_MODE_TUNNEL is not set
-# CONFIG_INET_XFRM_TUNNEL is not set
-CONFIG_INITRAMFS_SOURCE=""
-CONFIG_INOTIFY=y
-CONFIG_INOTIFY_USER=y
-CONFIG_INPUT=y
-# CONFIG_INPUT_EVDEV is not set
-CONFIG_INPUT_JOYSTICK=y
-CONFIG_INPUT_MOUSEDEV=y
-# CONFIG_INPUT_MOUSEDEV_PSAUX is not set
-CONFIG_INPUT_MOUSEDEV_SCREEN_X=1024
-CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768
-CONFIG_IOMMU_HELPER=y
-# CONFIG_IOMMU_VMERGE is not set
-CONFIG_IOSCHED_AS=y
-CONFIG_IOSCHED_CFQ=y
-# CONFIG_IPIC is not set
-# CONFIG_IPV6 is not set
-# CONFIG_IP_ADVANCED_ROUTER is not set
-# CONFIG_IP_MULTICAST is not set
-# CONFIG_IRQSTACKS is not set
-# CONFIG_IRQ_ALL_CPUS is not set
-CONFIG_IRQ_PER_CPU=y
-CONFIG_ISA_DMA_API=y
-# CONFIG_ISDN is not set
-CONFIG_ISO9660_FS=y
-CONFIG_JBD=y
-# CONFIG_JOYSTICK_A3D is not set
-# CONFIG_JOYSTICK_ADI is not set
-# CONFIG_JOYSTICK_ANALOG is not set
-# CONFIG_JOYSTICK_COBRA is not set
-# CONFIG_JOYSTICK_GF2K is not set
-# CONFIG_JOYSTICK_GRIP is not set
-# CONFIG_JOYSTICK_GRIP_MP is not set
-# CONFIG_JOYSTICK_GUILLEMOT is not set
-# CONFIG_JOYSTICK_IFORCE is not set
-# CONFIG_JOYSTICK_INTERACT is not set
-# CONFIG_JOYSTICK_JOYDUMP is not set
-# CONFIG_JOYSTICK_MAGELLAN is not set
-# CONFIG_JOYSTICK_SIDEWINDER is not set
-# CONFIG_JOYSTICK_SPACEBALL is not set
-# CONFIG_JOYSTICK_SPACEORB is not set
-# CONFIG_JOYSTICK_STINGER is not set
-# CONFIG_JOYSTICK_TMDC is not set
-# CONFIG_JOYSTICK_TWIDJOY is not set
-# CONFIG_JOYSTICK_WARRIOR is not set
-# CONFIG_JOYSTICK_XPAD is not set
-# CONFIG_JOYSTICK_ZHENHUA is not set
-CONFIG_KERNEL_START=0xc000000000000000
-CONFIG_KEXEC=y
-CONFIG_KMOD=y
-CONFIG_LEGACY_PTYS=y
-CONFIG_LEGACY_PTY_COUNT=16
-# CONFIG_LIBCRC32C is not set
-# CONFIG_LLC2 is not set
-CONFIG_LOCALVERSION_AUTO=y
-CONFIG_LOCKD=y
-CONFIG_LOCK_KERNEL=y
-CONFIG_LOGO=y
-CONFIG_LOGO_LINUX_CLUT224=y
-# CONFIG_LOGO_LINUX_MONO is not set
-# CONFIG_LOGO_LINUX_VGA16 is not set
-CONFIG_LOG_BUF_SHIFT=15
-# CONFIG_MACINTOSH_DRIVERS is not set
-CONFIG_MEMORY_HOTPLUG=y
-CONFIG_MEMORY_HOTPLUG_SPARSE=y
-# CONFIG_MEMORY_HOTREMOVE is not set
-# CONFIG_MFD_CORE is not set
-# CONFIG_MFD_TMIO is not set
-CONFIG_MIGRATION=y
-# CONFIG_MINIX_FS is not set
-# CONFIG_MISC_DEVICES is not set
-# CONFIG_MMIO_NVRAM is not set
-# CONFIG_MODULE_UNLOAD is not set
-# CONFIG_MPIC is not set
-# CONFIG_MPIC_WEIRD is not set
-CONFIG_MSDOS_FS=y
-# CONFIG_MTD is not set
-# CONFIG_NETFILTER is not set
-# CONFIG_NET_ETHERNET is not set
-# CONFIG_NET_IPGRE is not set
-# CONFIG_NET_KEY is not set
-# CONFIG_NET_PKTGEN is not set
-# CONFIG_NET_SCHED is not set
-# CONFIG_NEW_LEDS is not set
-# CONFIG_NFSD is not set
-CONFIG_NFS_FS=y
-CONFIG_NLS=y
-# CONFIG_NLS_CODEPAGE_1250 is not set
-CONFIG_NLS_CODEPAGE_437=y
-# CONFIG_NLS_CODEPAGE_850 is not set
-CONFIG_NLS_ISO8859_1=y
-# CONFIG_NLS_ISO8859_15 is not set
-# CONFIG_NLS_KOI8_R is not set
-# CONFIG_NLS_UTF8 is not set
-CONFIG_NR_CPUS=2
-# CONFIG_NUMA is not set
-CONFIG_OF=y
-CONFIG_OF_DEVICE=y
-# CONFIG_PACKET_MMAP is not set
-CONFIG_PAGEFLAGS_EXTENDED=y
-CONFIG_PAGE_OFFSET=0xc000000000000000
-# CONFIG_PARTITION_ADVANCED is not set
-# CONFIG_PCI_DOMAINS is not set
-# CONFIG_PCI_SYSCALL is not set
-CONFIG_PHYSICAL_START=0x00000000
-CONFIG_POWER3=y
-CONFIG_POWER4=y
-# CONFIG_POWER4_ONLY is not set
-CONFIG_PPC=y
-CONFIG_PPC64=y
-# CONFIG_PPC_64K_PAGES is not set
-# CONFIG_PPC_970_NAP is not set
-CONFIG_PPC_CELL=y
-# CONFIG_PPC_CELLEB is not set
-# CONFIG_PPC_CELL_NATIVE is not set
-# CONFIG_PPC_CLOCK is not set
-# CONFIG_PPC_DCR_MMIO is not set
-# CONFIG_PPC_DCR_NATIVE is not set
-# CONFIG_PPC_EARLY_DEBUG is not set
-CONFIG_PPC_FPU=y
-# CONFIG_PPC_HAS_HASH_64K is not set
-# CONFIG_PPC_I8259 is not set
-# CONFIG_PPC_IBM_CELL_BLADE is not set
-# CONFIG_PPC_INDIRECT_IO is not set
-# CONFIG_PPC_ISERIES is not set
-# CONFIG_PPC_MAPLE is not set
-CONFIG_PPC_MERGE=y
-# CONFIG_PPC_MM_SLICES is not set
-# CONFIG_PPC_MPC106 is not set
-CONFIG_PPC_MULTIPLATFORM=y
-CONFIG_PPC_OF=y
-# CONFIG_PPC_PASEMI is not set
-CONFIG_PPC_PCI_CHOICE=y
-# CONFIG_PPC_PMAC is not set
-CONFIG_PPC_PS3=y
-# CONFIG_PPC_PSERIES is not set
-# CONFIG_PPC_RTAS is not set
-CONFIG_PPC_STD_MMU=y
-# CONFIG_PPC_UDBG_16550 is not set
-# CONFIG_PPP is not set
-# CONFIG_PQ2ADS is not set
-CONFIG_PROC_DEVICETREE=y
-CONFIG_PROC_PAGE_MONITOR=y
-# CONFIG_PS3_ADVANCED is not set
-CONFIG_PS3_DISK=y
-# CONFIG_PS3_DYNAMIC_DMA is not set
-CONFIG_PS3_FLASH=y
-CONFIG_PS3_HTAB_SIZE=20
-# CONFIG_PS3_LPM is not set
-CONFIG_PS3_PS3AV=y
-CONFIG_PS3_ROM=y
-CONFIG_PS3_STORAGE=y
-CONFIG_PS3_SYS_MANAGER=y
-CONFIG_PS3_VUART=y
-CONFIG_RESOURCES_64BIT=y
-# CONFIG_RFKILL is not set
-CONFIG_RPCSEC_GSS_KRB5=y
-# CONFIG_RT_GROUP_SCHED is not set
-CONFIG_RWSEM_XCHGADD_ALGORITHM=y
-# CONFIG_SCHED_HRTICK is not set
-CONFIG_SCHED_NO_NO_OMIT_FRAME_POINTER=y
-# CONFIG_SCHED_SMT is not set
-CONFIG_SCSI=y
-# CONFIG_SCSI_LOWLEVEL is not set
-# CONFIG_SCSI_PROC_FS is not set
-# CONFIG_SCSI_WAIT_SCAN is not set
-# CONFIG_SERIAL_8250 is not set
-# CONFIG_SHMEM is not set
-CONFIG_SMP=y
-# CONFIG_SOUND is not set
-CONFIG_SPARSEMEM=y
-CONFIG_SPARSEMEM_EXTREME=y
-CONFIG_SPARSEMEM_MANUAL=y
-# CONFIG_SPARSEMEM_STATIC is not set
-CONFIG_SPARSEMEM_VMEMMAP=y
-CONFIG_SPARSEMEM_VMEMMAP_ENABLE=y
-# CONFIG_SPU_BASE is not set
-# CONFIG_SPU_FS is not set
-CONFIG_SSB_POSSIBLE=y
-CONFIG_SUNRPC=y
-CONFIG_SUNRPC_GSS=y
-# CONFIG_SYN_COOKIES is not set
-# CONFIG_SYSCTL_SYSCALL_CHECK is not set
-CONFIG_SYSFS_DEPRECATED=y
-CONFIG_SYSFS_DEPRECATED_V2=y
-# CONFIG_SYSVIPC is not set
-# CONFIG_TCP_CONG_ADVANCED is not set
-CONFIG_TCP_CONG_CUBIC=y
-# CONFIG_TICK_ONESHOT is not set
-CONFIG_TINY_SHMEM=y
-# CONFIG_TUN is not set
-CONFIG_TUNE_CELL=y
-# CONFIG_U3_DART is not set
-# CONFIG_UDF_FS is not set
-CONFIG_USB=y
-# CONFIG_USB_ACM is not set
-# CONFIG_USB_CATC is not set
-# CONFIG_USB_DEVICEFS is not set
-CONFIG_USB_EHCI_BIG_ENDIAN_MMIO=y
-CONFIG_USB_EHCI_HCD=y
-CONFIG_USB_EHCI_HCD_PPC_OF=y
-# CONFIG_USB_EHCI_ROOT_HUB_TT is not set
-CONFIG_USB_HID=y
-# CONFIG_USB_KAWETH is not set
-# CONFIG_USB_OHCI_BIG_ENDIAN_DESC is not set
-CONFIG_USB_OHCI_BIG_ENDIAN_MMIO=y
-CONFIG_USB_OHCI_HCD=y
-# CONFIG_USB_OHCI_HCD_PPC_OF is not set
-# CONFIG_USB_PEGASUS is not set
-# CONFIG_USB_PRINTER is not set
-# CONFIG_USB_SERIAL is not set
-CONFIG_USB_STORAGE=y
-# CONFIG_USB_STORAGE_ALAUDA is not set
-# CONFIG_USB_STORAGE_DATAFAB is not set
-# CONFIG_USB_STORAGE_DPCM is not set
-# CONFIG_USB_STORAGE_FREECOM is not set
-# CONFIG_USB_STORAGE_JUMPSHOT is not set
-# CONFIG_USB_STORAGE_KARMA is not set
-# CONFIG_USB_STORAGE_SDDR09 is not set
-# CONFIG_USB_STORAGE_SDDR55 is not set
-# CONFIG_USB_STORAGE_USBAT is not set
-CONFIG_USB_SUPPORT=y
-# CONFIG_USB_USBNET is not set
-CONFIG_USER_SCHED=y
-CONFIG_USE_GENERIC_SMP_HELPERS=y
-CONFIG_VFAT_FS=y
-# CONFIG_VGASTATE is not set
-# CONFIG_VGA_CONSOLE is not set
-# CONFIG_VIDEO_DEV is not set
-CONFIG_VIDEO_OUTPUT_CONTROL=y
-CONFIG_VIRT_CPU_ACCOUNTING=y
-# CONFIG_VLAN_8021Q is not set
-CONFIG_VM_EVENT_COUNTERS=y
-# CONFIG_VSX is not set
-CONFIG_VT=y
-CONFIG_VT_CONSOLE=y
-CONFIG_VT_HW_CONSOLE_BINDING=y
-# CONFIG_W1 is not set
-# CONFIG_WATCHDOG is not set
-# CONFIG_WIRELESS_EXT_SYSFS is not set
-# CONFIG_WLAN_80211 is not set
-CONFIG_WORD_SIZE=64
-# CONFIG_ZISOFS is not set
diff --git a/target/linux/ps3/patches-2.6.27/001-perfmon-2.6.27.patch b/target/linux/ps3/patches-2.6.27/001-perfmon-2.6.27.patch
deleted file mode 100644
index 958416aab6..0000000000
--- a/target/linux/ps3/patches-2.6.27/001-perfmon-2.6.27.patch
+++ /dev/null
@@ -1,31652 +0,0 @@
-diff --git a/Documentation/ABI/testing/sysfs-perfmon b/Documentation/ABI/testing/sysfs-perfmon
-new file mode 100644
-index 0000000..bde434c
---- /dev/null
-+++ b/Documentation/ABI/testing/sysfs-perfmon
-@@ -0,0 +1,87 @@
-+What:		/sys/kernel/perfmon
-+Date:		Nov 2007
-+KernelVersion:	2.6.24
-+Contact:	eranian@gmail.com
-+
-+Description:	provide the configuration interface for the perfmon2 subsystems.
-+	        The tree contains information about the detected hardware, current
-+		state of the subsystem as well as some configuration parameters.
-+	
-+		The tree consists of the following entries:
-+
-+	/sys/kernel/perfmon/debug (read-write):
-+
-+		Enable perfmon2 debugging output via klogd. Debug messages produced during
-+		PMU interrupt handling are not controlled by this entry. The traces a rate-limited
-+		to avoid flooding of the console. It is possible to change the throttling
-+	        via /proc/sys/kernel/printk_ratelimit. The value is interpreted as a bitmask.
-+		Each bit enables a particular type of debug messages. Refer to the file
-+		include/linux/perfmon_kern.h for more information
-+
-+	/sys/kernel/perfmon/pmc_max_fast_arg (read-only):
-+
-+		Number of perfmon2 syscall arguments copied directly onto the
-+   		stack (copy_from_user) for pfm_write_pmcs(). Copying to the stack avoids
-+		having to allocate a buffer. The unit is the number of pfarg_pmc_t
-+		structures.
-+
-+	/sys/kernel/perfmon/pmd_max_fast_arg (read-only):
-+
-+		Number of perfmon2 syscall arguments copied directly onto the
-+   		stack (copy_from_user) for pfm_write_pmds()/pfm_read_pmds(). Copying
-+		to the stack avoids having to allocate a buffer. The unit is the number
-+		of pfarg_pmd_t structures.
-+
-+
-+	/sys/kernel/perfmon/reset_stats (write-only):
-+
-+		Reset the statistics collected by perfmon2. Stats are available
-+		per-cpu via debugfs.
-+  	
-+	/sys/kernel/perfmon/smpl_buffer_mem_cur (read-only):
-+
-+		Reports the amount of memory currently dedicated to sampling
-+   		buffers by the kernel. The unit is byte.
-+
-+   	/sys/kernel/perfmon/smpl_buffer_mem_max (read-write):
-+
-+		Maximum amount of kernel memory usable for sampling buffers. -1 means
-+		everything that is available. Unit is byte.
-+
-+   	/sys/kernel/perfmon/smpl_buffer_mem_cur (read-only):
-+
-+		Current utilization of kernel memory in bytes.
-+
-+   	/sys/kernel/perfmon/sys_group (read-write):
-+
-+		Users group allowed to create a system-wide perfmon2 context (session).
-+   		-1 means any group. This control will be kept until we find a package
-+		able to control capabilities via PAM.
-+
-+	/sys/kernel/perfmon/task_group (read-write):
-+
-+		Users group allowed to create a per-thread context (session).
-+   		-1 means any group. This control will be kept until we find a
-+		package able to control capabilities via PAM.
-+
-+	/sys/kernel/perfmon/sys_sessions_count (read-only):
-+
-+		Number of system-wide contexts currently attached to CPUs.
-+
-+	/sys/kernel/perfmon/task_sessions_count (read-only):
-+
-+		Number of per-thread contexts currently attached to threads.
-+
-+   	/sys/kernel/perfmon/version (read-only):
-+
-+		Perfmon2 interface revision number.
-+
-+	/sys/kernel/perfmon/arg_mem_max(read-write):
-+
-+		Maximum size of vector arguments expressed in bytes. Can be modified
-+
-+	/sys/kernel/perfmon/mode(read-write):
-+
-+		Bitmask to enable/disable certain perfmon2 features.
-+		Currently defined:
-+		- bit 0: if set, then reserved bitfield are ignored on PMC writes
-diff --git a/Documentation/ABI/testing/sysfs-perfmon-fmt b/Documentation/ABI/testing/sysfs-perfmon-fmt
-new file mode 100644
-index 0000000..1b45270
---- /dev/null
-+++ b/Documentation/ABI/testing/sysfs-perfmon-fmt
-@@ -0,0 +1,18 @@
-+What:		/sys/kernel/perfmon/formats
-+Date:		2007
-+KernelVersion:	2.6.24
-+Contact:	eranian@gmail.com
-+
-+Description:	provide description of available perfmon2 custom sampling buffer formats
-+		which are implemented as independent kernel modules. Each formats gets
-+		a subdir which a few entries.
-+
-+		The name of the subdir is the name of the sampling format. The same name
-+		must be passed to pfm_create_context() to use the format.
-+
-+		Each subdir XX contains the following entries:
-+
-+	/sys/kernel/perfmon/formats/XX/version (read-only):
-+
-+		Version number of the format in clear text and null terminated.
-+
-diff --git a/Documentation/ABI/testing/sysfs-perfmon-pmu b/Documentation/ABI/testing/sysfs-perfmon-pmu
-new file mode 100644
-index 0000000..a1afc7e
---- /dev/null
-+++ b/Documentation/ABI/testing/sysfs-perfmon-pmu
-@@ -0,0 +1,46 @@
-+What:		/sys/kernel/perfmon/pmu
-+Date:		Nov 2007
-+KernelVersion:	2.6.24
-+Contact:	eranian@gmail.com
-+
-+Description:	provide information about the currently loaded PMU description module.
-+		The module contains the mapping of the actual performance counter registers
-+		onto the logical PMU exposed by perfmon.  There is at most one PMU description
-+		module loaded at any time.
-+
-+		The sysfs PMU tree provides a description of the mapping for each register.
-+		There is one subdir per config and data registers along an entry for the
-+		name of the PMU model.
-+
-+		The model entry is as follows:
-+
-+	/sys/kernel/perfmon/pmu_desc/model (read-only):
-+
-+		Name of the PMU model is clear text and zero terminated.
-+   	
-+		Then for each logical PMU register, XX, gets a subtree with the following entries:
-+
-+	/sys/kernel/perfmon/pmu_desc/pm*XX/addr (read-only):
-+
-+		The physical address or index of the actual underlying hardware register.
-+		On Itanium, it corresponds to the index. But on X86 processor, this is
-+		the actual MSR address.
-+
-+	/sys/kernel/perfmon/pmu_desc/pm*XX/dfl_val (read-only):
-+
-+		The default value of the register in hexadecimal.
-+
-+	/sys/kernel/perfmon/pmu_desc/pm*XX/name (read-only):
-+
-+		The name of the hardware register.
-+
-+	/sys/kernel/perfmon/pmu_desc/pm*XX/rsvd_msk (read-only):
-+
-+		The bitmask of reserved bits, i.e., bits which cannot be changed by
-+		applications. When a bit is set, it means the corresponding bit in the
-+		actual register is reserved.
-+
-+	/sys/kernel/perfmon/pmu_desc/pm*XX/width (read-only):
-+
-+		the width in bits of the registers. This field is only relevant for counter
-+		registers.
-diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt
-index 1150444..2652b6c 100644
---- a/Documentation/kernel-parameters.txt
-+++ b/Documentation/kernel-parameters.txt
-@@ -1643,6 +1643,9 @@ and is between 256 and 4096 characters. It is defined in the file
- 			Format: { 0 | 1 }
- 			See arch/parisc/kernel/pdc_chassis.c
- 
-+	perfmon_debug	[PERFMON] Enables Perfmon debug messages. Needed
-+			to see traces of the early startup startup phase.
-+
- 	pf.		[PARIDE]
- 			See Documentation/paride.txt.
- 
-diff --git a/Documentation/perfmon2-debugfs.txt b/Documentation/perfmon2-debugfs.txt
-new file mode 100644
-index 0000000..b30cae8
---- /dev/null
-+++ b/Documentation/perfmon2-debugfs.txt
-@@ -0,0 +1,126 @@
-+		The perfmon2 debug and statistics interface
-+                ------------------------------------------
-+		           Stephane Eranian
-+			  <eranian@gmail.com>
-+
-+The perfmon2 interfaces exports a set of statistics which are used to tune and
-+debug the implementation. The data is composed of a set of very simple metrics
-+mostly aggregated counts and durations. They instruments key points in the
-+perfmon2 code, such as context switch and interrupt handling.
-+
-+The data is accessible via the debug filesystem (debugfs). Thus you need to
-+have the filesystem support enabled in your kernel. Furthermore since, 2.6.25,
-+the perfmon2 statistics interface is an optional component. It needs to be
-+explicitely enabled in the kernel config file (CONFIG_PERFMON_DEBUG_FS).
-+
-+To access the data, the debugs filesystem must be mounted. Supposing the mount
-+point is /debugfs, you would need to do:
-+	$ mount -t debugs none /debugfs
-+
-+The data is located under the perfmon subdirectory and is organized per CPU.
-+For each CPU, the same set of metrics is available, one metric per file in
-+clear ASCII text.
-+
-+The metrics are as follows:
-+
-+	ctxswin_count (read-only):
-+	
-+		Number of PMU context switch in.
-+
-+	ctxswin_ns (read-only):
-+
-+		Number of nanoseconds spent in the PMU context switch in
-+		routine.  Dividing this number by the value of ctxswin_count,
-+		yields average cost of the PMU context switch in.
-+
-+	ctxswout_count (read-only):
-+
-+		Number of PMU context switch out.
-+
-+	ctxswout_ns (read-only):
-+
-+		Number of nanoseconds spent in the PMU context switch in
-+		routine. Dividing this number by the value of ctxswout_count,
-+		yields average cost of the PMU context switch out.
-+
-+	fmt_handler_calls (read-only):
-+
-+		Number of calls to the sampling format routine that handles
-+		PMU interrupts, i.e., typically the routine that records a
-+		sample.
-+
-+	fmt_handler_ns (read-only):
-+
-+		Number of nanoseconds spent in the routine that handle PMU
-+		interrupt in the sampling format. Dividing this number by
-+		the number of calls provided by fmt_handler_calls, yields
-+		average time spent in this routine.
-+
-+	ovfl_intr_all_count (read-only):
-+
-+		Number of PMU interrupts received by the kernel.
-+
-+
-+	ovfl_intr_nmi_count (read-only):
-+
-+		Number of Non Maskeable Interrupts (NMI) received by the kernel
-+		for perfmon. This is relevant only on X86 hardware.
-+	
-+	ovfl_intr_ns (read-only):
-+
-+		Number of nanoseconds spent in the perfmon2 PMU interrupt
-+		handler routine. Dividing this number of ovfl_intr_all_count
-+		yields the average time to handle one PMU interrupt.
-+
-+	ovfl_intr_regular_count (read-only):
-+
-+		Number of PMU interrupts which are actually processed by 
-+		the perfmon interrupt handler. There may be spurious or replay
-+		interrupts.
-+
-+	ovfl_intr_replay_count (read-only):
-+
-+		Number of PMU interrupts which were replayed on context switch	
-+		in or on event set switching. Interrupts get replayed when they
-+		were in flight at the time monitoring had to be stopped.
-+
-+	perfmon/ovfl_intr_spurious_count (read-only):
-+
-+		Number of PMU interrupts which were dropped because there was
-+		no active context (session).
-+
-+	ovfl_notify_count (read-only):
-+
-+		Number of user level notifications sent. Notifications are
-+		appended as messages to the context queue. Notifications may
-+		be sent on PMU interrupts.
-+
-+	pfm_restart_count (read-only):
-+
-+		Number of times pfm_restart() is called.
-+
-+	reset_pmds_count (read-only):
-+
-+		Number of times pfm_reset_pmds() is called.
-+
-+	set_switch_count (read-only):
-+
-+		Number of event set switches.
-+
-+	set_switch_ns (read-only):
-+
-+		Number of nanoseconds spent in the set switching routine.
-+		Dividing this number by set_switch_count yields the average
-+		cost of switching sets.
-+
-+	handle_timeout_count (read-only):
-+
-+		Number of times the pfm_handle_timeout() routine is called.
-+		It is used for timeout-based set switching.
-+
-+	handle_work_count (read-only):
-+
-+		Number of times pfm_handle_work() is called. The routine
-+		handles asynchronous perfmon2 work for per-thread contexts
-+		(sessions).
-+
-diff --git a/Documentation/perfmon2.txt b/Documentation/perfmon2.txt
-new file mode 100644
-index 0000000..4a8fada
---- /dev/null
-+++ b/Documentation/perfmon2.txt
-@@ -0,0 +1,213 @@
-+              The perfmon2 hardware monitoring interface
-+              ------------------------------------------
-+		           Stephane Eranian
-+			  <eranian@gmail.com>
-+
-+I/ Introduction
-+
-+   The perfmon2 interface provides access to the hardware performance counters of
-+   major processors. Nowadays, all processors implement some flavors of performance
-+   counters which capture micro-architectural level information such as the number
-+   of elapsed cycles, number of cache misses, and so on.
-+
-+   The interface is implemented as a set of new system calls and a set of config files
-+   in /sys.
-+
-+   It is possible to monitoring a single thread or a CPU. In either mode, applications
-+   can count or collect samples. System-wide monitoring is supported by running a
-+   monitoring session on each CPU. The interface support event-based sampling where the
-+   sampling period is expressed as the number of occurrences of event, instead of just a
-+   timeout.  This approach provides a much better granularity and flexibility.
-+
-+   For performance reason, it is possible to use a kernel-level sampling buffer to minimize
-+   the overhead incurred by sampling. The format of the buffer, i.e., what is recorded, how
-+   it is recorded, and how it is exported to user-land is controlled by a kernel module called
-+   a custom sampling format. The current implementation comes with a default format but
-+   it is possible to create additional formats. There is an in-kernel registration
-+   interface for formats. Each format is identified by a simple string which a tool
-+   can pass when a monitoring session is created.
-+
-+   The interface also provides support for event set and multiplexing to work around
-+   hardware limitations in the number of available counters or in how events can be 
-+   combined. Each set defines as many counters as the hardware can support. The kernel
-+   then multiplexes the sets. The interface supports time-base switching but also
-+   overflow based switching, i.e., after n overflows of designated counters.
-+
-+   Applications never manipulates the actual performance counter registers. Instead they see
-+   a logical Performance Monitoring Unit (PMU) composed of a set of config register (PMC)
-+   and a set of data registers (PMD). Note that PMD are not necessarily counters, they
-+   can be buffers. The logical PMU is then mapped onto the actual PMU using a mapping
-+   table which is implemented as a kernel module. The mapping is chosen once for each
-+   new processor. It is visible in /sys/kernel/perfmon/pmu_desc. The kernel module
-+   is automatically loaded on first use.
-+
-+   A monitoring session, or context, is uniquely identified by a file descriptor
-+   obtained when the context is created. File sharing semantics apply to access
-+   the context inside a process. A context is never inherited across fork. The file
-+   descriptor can be used to received counter overflow notifications or when the
-+   sampling buffer is full. It is possible to use poll/select on the descriptor 
-+   to wait for notifications from multiplex contexts. Similarly, the descriptor
-+   supports asynchronous notification via SIGIO.
-+
-+   Counters are always exported as being 64-bit wide regardless of what the underlying
-+   hardware implements.
-+
-+II/ Kernel compilation
-+
-+    To enable perfmon2, you need to enable CONFIG_PERFMON
-+
-+III/ OProfile interactions
-+
-+    The set of features offered by perfmon2 is rich enough to support migrating
-+    Oprofile on top of it. That means that PMU programming and low-level interrupt
-+    handling could be done by perfmon2. The Oprofile sampling buffer management code
-+    in the kernel as well as how samples are exported to users could remain through
-+    the use of a custom sampling buffer format. This is how Oprofile work on Itanium.
-+
-+    The current interactions with Oprofile are:
-+	- on X86: Both subsystems can be compiled into the same kernel. There is enforced
-+	          mutual exclusion between the two subsystems. When there is an Oprofile
-+		  session, no perfmon2 session can exist and vice-versa. Perfmon2 session
-+		  encapsulates both per-thread and system-wide sessions here.
-+
-+	- On IA-64: Oprofile works on top of perfmon2. Oprofile being a system-wide monitoring
-+		    tool, the regular per-thread vs. system-wide session restrictions apply.
-+
-+	- on PPC: no integration yet. You need to enable/disble one of the two subsystems
-+	- on MIPS: no integration yet. You need to enable/disble one of the two subsystems
-+
-+IV/ User tools
-+
-+    We have released a simple monitoring tool to demonstrate the feature of the
-+    interface. The tool is called pfmon and it comes with a simple helper library
-+    called libpfm. The library comes with a set of examples to show how to use the
-+    kernel perfmon2 interface. Visit http://perfmon2.sf.net for details.
-+
-+    There maybe other tools available for perfmon2.
-+
-+V/ How to program?
-+
-+   The best way to learn how to program perfmon2, is to take a look at the source
-+   code for the examples in libpfm. The source code is available from:
-+		http://perfmon2.sf.net
-+
-+VI/ System calls overview
-+
-+   The interface is implemented by the following system calls:
-+
-+   * int pfm_create_context(pfarg_ctx_t *ctx, char *fmt, void *arg, size_t arg_size)
-+
-+      This function create a perfmon2 context. The type of context is per-thread by
-+      default unless PFM_FL_SYSTEM_WIDE is passed in ctx. The sampling format name
-+      is passed in fmt. Arguments to the format are passed in arg which is of size
-+      arg_size. Upon successful return, the file descriptor identifying the context
-+      is returned.
-+
-+   * int pfm_write_pmds(int fd, pfarg_pmd_t *pmds, int n)
-+   
-+      This function is used to program the PMD registers. It is possible to pass
-+      vectors of PMDs.
-+
-+   * int pfm_write_pmcs(int fd, pfarg_pmc_t *pmds, int n)
-+   
-+      This function is used to program the PMC registers. It is possible to pass
-+      vectors of PMDs.
-+
-+   * int pfm_read_pmds(int fd, pfarg_pmd_t *pmds, int n)
-+   
-+      This function is used to read the PMD registers. It is possible to pass
-+      vectors of PMDs.
-+
-+   * int pfm_load_context(int fd, pfarg_load_t *load)
-+   
-+      This function is used to attach the context to a thread or CPU.
-+      Thread means kernel-visible thread (NPTL). The thread identification
-+      as obtained by gettid must be passed to load->load_target.
-+
-+      To operate on another thread (not self), it is mandatory that the thread
-+      be stopped via ptrace().
-+
-+      To attach to a CPU, the CPU number must be specified in load->load_target
-+      AND the call must be issued on that CPU. To monitor a CPU, a thread MUST
-+      be pinned on that CPU.
-+
-+      Until the context is attached, the actual counters are not accessed.
-+
-+   * int pfm_unload_context(int fd)
-+
-+     The context is detached for the thread or CPU is was attached to.
-+     As a consequence monitoring is stopped.
-+
-+     When monitoring another thread, the thread MUST be stopped via ptrace()
-+     for this function to succeed.
-+
-+   * int pfm_start(int fd, pfarg_start_t *st)
-+
-+     Start monitoring. The context must be attached for this function to succeed.
-+     Optionally, it is possible to specify the event set on which to start using the
-+     st argument, otherwise just pass NULL.
-+
-+     When monitoring another thread, the thread MUST be stopped via ptrace()
-+     for this function to succeed.
-+
-+   * int pfm_stop(int fd)
-+
-+     Stop monitoring. The context must be attached for this function to succeed.
-+
-+     When monitoring another thread, the thread MUST be stopped via ptrace()
-+     for this function to succeed.
-+
-+
-+   * int pfm_create_evtsets(int fd, pfarg_setdesc_t *sets, int n)
-+
-+     This function is used to create or change event sets. By default set 0 exists.
-+     It is possible to create/change multiple sets in one call.
-+
-+     The context must be detached for this call to succeed.
-+
-+     Sets are identified by a 16-bit integer. They are sorted based on this
-+     set and switching occurs in a round-robin fashion.
-+
-+   * int pfm_delete_evtsets(int fd, pfarg_setdesc_t *sets, int n)
-+   
-+     Delete event sets. The context must be detached for this call to succeed.
-+
-+
-+   * int pfm_getinfo_evtsets(int fd, pfarg_setinfo_t *sets, int n)
-+
-+     Retrieve information about event sets. In particular it is possible
-+     to get the number of activation of a set. It is possible to retrieve
-+     information about multiple sets in one call.
-+
-+
-+   * int pfm_restart(int fd)
-+
-+     Indicate to the kernel that the application is done processing an overflow
-+     notification. A consequence of this call could be that monitoring resumes.
-+
-+   * int read(fd, pfm_msg_t *msg, sizeof(pfm_msg_t))
-+
-+   the regular read() system call can be used with the context file descriptor to
-+   receive overflow notification messages. Non-blocking read() is supported.
-+
-+   Each message carry information about the overflow such as which counter overflowed
-+   and where the program was (interrupted instruction pointer).
-+
-+   * int close(int fd)
-+
-+   To destroy a context, the regular close() system call is used.
-+
-+
-+VII/ /sys interface overview
-+
-+   Refer to Documentation/ABI/testing/sysfs-perfmon-* for a detailed description
-+   of the sysfs interface of perfmon2.
-+
-+VIII/ debugfs interface overview
-+
-+  Refer to Documentation/perfmon2-debugfs.txt for a detailed description of the
-+  debug and statistics interface of perfmon2.
-+
-+IX/ Documentation
-+
-+   Visit http://perfmon2.sf.net
-diff --git a/MAINTAINERS b/MAINTAINERS
-index 8dae455..fb38c2a 100644
---- a/MAINTAINERS
-+++ b/MAINTAINERS
-@@ -3239,6 +3239,14 @@ M:	balbir@linux.vnet.ibm.com
- L:	linux-kernel@vger.kernel.org
- S:	Maintained
- 
-+PERFMON SUBSYSTEM
-+P:	Stephane Eranian
-+M:	eranian@gmail.com
-+L:	perfmon2-devel@lists.sf.net
-+W:	http://perfmon2.sf.net
-+T:	git kernel.org:/pub/scm/linux/kernel/git/eranian/linux-2.6
-+S:	Maintained
-+
- PERSONALITY HANDLING
- P:	Christoph Hellwig
- M:	hch@infradead.org
-diff --git a/Makefile b/Makefile
-index 16e3fbb..7bb1320 100644
---- a/Makefile
-+++ b/Makefile
-@@ -620,6 +620,7 @@ export mod_strip_cmd
- 
- ifeq ($(KBUILD_EXTMOD),)
- core-y		+= kernel/ mm/ fs/ ipc/ security/ crypto/ block/
-+core-$(CONFIG_PERFMON) += perfmon/
- 
- vmlinux-dirs	:= $(patsubst %/,%,$(filter %/, $(init-y) $(init-m) \
- 		     $(core-y) $(core-m) $(drivers-y) $(drivers-m) \
-diff --git a/arch/ia64/Kconfig b/arch/ia64/Kconfig
-index 48e496f..1d79b01 100644
---- a/arch/ia64/Kconfig
-+++ b/arch/ia64/Kconfig
-@@ -470,14 +470,6 @@ config COMPAT_FOR_U64_ALIGNMENT
- config IA64_MCA_RECOVERY
- 	tristate "MCA recovery from errors other than TLB."
- 
--config PERFMON
--	bool "Performance monitor support"
--	help
--	  Selects whether support for the IA-64 performance monitor hardware
--	  is included in the kernel.  This makes some kernel data-structures a
--	  little bigger and slows down execution a bit, but it is generally
--	  a good idea to turn this on.  If you're unsure, say Y.
--
- config IA64_PALINFO
- 	tristate "/proc/pal support"
- 	help
-@@ -549,6 +541,8 @@ source "drivers/firmware/Kconfig"
- 
- source "fs/Kconfig.binfmt"
- 
-+source "arch/ia64/perfmon/Kconfig"
-+
- endmenu
- 
- menu "Power management and ACPI"
-diff --git a/arch/ia64/Makefile b/arch/ia64/Makefile
-index 905d25b..9aa622d 100644
---- a/arch/ia64/Makefile
-+++ b/arch/ia64/Makefile
-@@ -57,6 +57,7 @@ core-$(CONFIG_IA64_GENERIC) 	+= arch/ia64/dig/
- core-$(CONFIG_IA64_HP_ZX1)	+= arch/ia64/dig/
- core-$(CONFIG_IA64_HP_ZX1_SWIOTLB) += arch/ia64/dig/
- core-$(CONFIG_IA64_SGI_SN2)	+= arch/ia64/sn/
-+core-$(CONFIG_PERFMON)		+= arch/ia64/perfmon/
- core-$(CONFIG_IA64_SGI_UV)	+= arch/ia64/uv/
- core-$(CONFIG_KVM) 		+= arch/ia64/kvm/
- 
-diff --git a/arch/ia64/configs/generic_defconfig b/arch/ia64/configs/generic_defconfig
-index 9f48397..ff9572a 100644
---- a/arch/ia64/configs/generic_defconfig
-+++ b/arch/ia64/configs/generic_defconfig
-@@ -209,7 +209,6 @@ CONFIG_IA32_SUPPORT=y
- CONFIG_COMPAT=y
- CONFIG_COMPAT_FOR_U64_ALIGNMENT=y
- CONFIG_IA64_MCA_RECOVERY=y
--CONFIG_PERFMON=y
- CONFIG_IA64_PALINFO=y
- # CONFIG_IA64_MC_ERR_INJECT is not set
- CONFIG_SGI_SN=y
-@@ -234,6 +233,16 @@ CONFIG_BINFMT_ELF=y
- CONFIG_BINFMT_MISC=m
- 
- #
-+# Hardware Performance Monitoring support
-+#
-+CONFIG_PERFMON=y
-+CONFIG_IA64_PERFMON_COMPAT=y
-+CONFIG_IA64_PERFMON_GENERIC=m
-+CONFIG_IA64_PERFMON_ITANIUM=y
-+CONFIG_IA64_PERFMON_MCKINLEY=y
-+CONFIG_IA64_PERFMON_MONTECITO=y
-+
-+#
- # Power management and ACPI
- #
- CONFIG_PM=y
-diff --git a/arch/ia64/include/asm/Kbuild b/arch/ia64/include/asm/Kbuild
-index ccbe8ae..cf64b3b 100644
---- a/arch/ia64/include/asm/Kbuild
-+++ b/arch/ia64/include/asm/Kbuild
-@@ -5,10 +5,12 @@ header-y += fpu.h
- header-y += fpswa.h
- header-y += ia64regs.h
- header-y += intel_intrin.h
--header-y += perfmon_default_smpl.h
- header-y += ptrace_offsets.h
- header-y += rse.h
- header-y += ucontext.h
-+header-y += perfmon.h
-+header-y += perfmon_compat.h
-+header-y += perfmon_default_smpl.h
- 
- unifdef-y += gcc_intrin.h
- unifdef-y += intrinsics.h
-diff --git a/arch/ia64/include/asm/hw_irq.h b/arch/ia64/include/asm/hw_irq.h
-index 5c99cbc..4a45cb0 100644
---- a/arch/ia64/include/asm/hw_irq.h
-+++ b/arch/ia64/include/asm/hw_irq.h
-@@ -67,9 +67,9 @@ extern int ia64_last_device_vector;
- #define IA64_NUM_DEVICE_VECTORS		(IA64_LAST_DEVICE_VECTOR - IA64_FIRST_DEVICE_VECTOR + 1)
- 
- #define IA64_MCA_RENDEZ_VECTOR		0xe8	/* MCA rendez interrupt */
--#define IA64_PERFMON_VECTOR		0xee	/* performance monitor interrupt vector */
- #define IA64_TIMER_VECTOR		0xef	/* use highest-prio group 15 interrupt for timer */
- #define	IA64_MCA_WAKEUP_VECTOR		0xf0	/* MCA wakeup (must be >MCA_RENDEZ_VECTOR) */
-+#define IA64_PERFMON_VECTOR		0xf1	/* performance monitor interrupt vector */
- #define IA64_IPI_LOCAL_TLB_FLUSH	0xfc	/* SMP flush local TLB */
- #define IA64_IPI_RESCHEDULE		0xfd	/* SMP reschedule */
- #define IA64_IPI_VECTOR			0xfe	/* inter-processor interrupt vector */
-diff --git a/arch/ia64/include/asm/perfmon.h b/arch/ia64/include/asm/perfmon.h
-index 7f3333d..150c4b4 100644
---- a/arch/ia64/include/asm/perfmon.h
-+++ b/arch/ia64/include/asm/perfmon.h
-@@ -1,279 +1,59 @@
- /*
-- * Copyright (C) 2001-2003 Hewlett-Packard Co
-- *               Stephane Eranian <eranian@hpl.hp.com>
-- */
--
--#ifndef _ASM_IA64_PERFMON_H
--#define _ASM_IA64_PERFMON_H
--
--/*
-- * perfmon comamnds supported on all CPU models
-- */
--#define PFM_WRITE_PMCS		0x01
--#define PFM_WRITE_PMDS		0x02
--#define PFM_READ_PMDS		0x03
--#define PFM_STOP		0x04
--#define PFM_START		0x05
--#define PFM_ENABLE		0x06 /* obsolete */
--#define PFM_DISABLE		0x07 /* obsolete */
--#define PFM_CREATE_CONTEXT	0x08
--#define PFM_DESTROY_CONTEXT	0x09 /* obsolete use close() */
--#define PFM_RESTART		0x0a
--#define PFM_PROTECT_CONTEXT	0x0b /* obsolete */
--#define PFM_GET_FEATURES	0x0c
--#define PFM_DEBUG		0x0d
--#define PFM_UNPROTECT_CONTEXT	0x0e /* obsolete */
--#define PFM_GET_PMC_RESET_VAL	0x0f
--#define PFM_LOAD_CONTEXT	0x10
--#define PFM_UNLOAD_CONTEXT	0x11
--
--/*
-- * PMU model specific commands (may not be supported on all PMU models)
-- */
--#define PFM_WRITE_IBRS		0x20
--#define PFM_WRITE_DBRS		0x21
--
--/*
-- * context flags
-- */
--#define PFM_FL_NOTIFY_BLOCK    	 0x01	/* block task on user level notifications */
--#define PFM_FL_SYSTEM_WIDE	 0x02	/* create a system wide context */
--#define PFM_FL_OVFL_NO_MSG	 0x80   /* do not post overflow/end messages for notification */
--
--/*
-- * event set flags
-- */
--#define PFM_SETFL_EXCL_IDLE      0x01   /* exclude idle task (syswide only) XXX: DO NOT USE YET */
--
--/*
-- * PMC flags
-- */
--#define PFM_REGFL_OVFL_NOTIFY	0x1	/* send notification on overflow */
--#define PFM_REGFL_RANDOM	0x2	/* randomize sampling interval   */
--
--/*
-- * PMD/PMC/IBR/DBR return flags (ignored on input)
-+ * Copyright (c) 2001-2007 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-  *
-- * Those flags are used on output and must be checked in case EAGAIN is returned
-- * by any of the calls using a pfarg_reg_t or pfarg_dbreg_t structure.
-- */
--#define PFM_REG_RETFL_NOTAVAIL	(1UL<<31) /* set if register is implemented but not available */
--#define PFM_REG_RETFL_EINVAL	(1UL<<30) /* set if register entry is invalid */
--#define PFM_REG_RETFL_MASK	(PFM_REG_RETFL_NOTAVAIL|PFM_REG_RETFL_EINVAL)
--
--#define PFM_REG_HAS_ERROR(flag)	(((flag) & PFM_REG_RETFL_MASK) != 0)
--
--typedef unsigned char pfm_uuid_t[16];	/* custom sampling buffer identifier type */
--
--/*
-- * Request structure used to define a context
-- */
--typedef struct {
--	pfm_uuid_t     ctx_smpl_buf_id;	 /* which buffer format to use (if needed) */
--	unsigned long  ctx_flags;	 /* noblock/block */
--	unsigned short ctx_nextra_sets;	 /* number of extra event sets (you always get 1) */
--	unsigned short ctx_reserved1;	 /* for future use */
--	int	       ctx_fd;		 /* return arg: unique identification for context */
--	void	       *ctx_smpl_vaddr;	 /* return arg: virtual address of sampling buffer, is used */
--	unsigned long  ctx_reserved2[11];/* for future use */
--} pfarg_context_t;
--
--/*
-- * Request structure used to write/read a PMC or PMD
-- */
--typedef struct {
--	unsigned int	reg_num;	   /* which register */
--	unsigned short	reg_set;	   /* event set for this register */
--	unsigned short	reg_reserved1;	   /* for future use */
--
--	unsigned long	reg_value;	   /* initial pmc/pmd value */
--	unsigned long	reg_flags;	   /* input: pmc/pmd flags, return: reg error */
--
--	unsigned long	reg_long_reset;	   /* reset after buffer overflow notification */
--	unsigned long	reg_short_reset;   /* reset after counter overflow */
--
--	unsigned long	reg_reset_pmds[4]; /* which other counters to reset on overflow */
--	unsigned long	reg_random_seed;   /* seed value when randomization is used */
--	unsigned long	reg_random_mask;   /* bitmask used to limit random value */
--	unsigned long   reg_last_reset_val;/* return: PMD last reset value */
--
--	unsigned long	reg_smpl_pmds[4];  /* which pmds are accessed when PMC overflows */
--	unsigned long	reg_smpl_eventid;  /* opaque sampling event identifier */
--
--	unsigned long   reg_reserved2[3];   /* for future use */
--} pfarg_reg_t;
--
--typedef struct {
--	unsigned int	dbreg_num;		/* which debug register */
--	unsigned short	dbreg_set;		/* event set for this register */
--	unsigned short	dbreg_reserved1;	/* for future use */
--	unsigned long	dbreg_value;		/* value for debug register */
--	unsigned long	dbreg_flags;		/* return: dbreg error */
--	unsigned long	dbreg_reserved2[1];	/* for future use */
--} pfarg_dbreg_t;
--
--typedef struct {
--	unsigned int	ft_version;	/* perfmon: major [16-31], minor [0-15] */
--	unsigned int	ft_reserved;	/* reserved for future use */
--	unsigned long	reserved[4];	/* for future use */
--} pfarg_features_t;
--
--typedef struct {
--	pid_t		load_pid;	   /* process to load the context into */
--	unsigned short	load_set;	   /* first event set to load */
--	unsigned short	load_reserved1;	   /* for future use */
--	unsigned long	load_reserved2[3]; /* for future use */
--} pfarg_load_t;
--
--typedef struct {
--	int		msg_type;		/* generic message header */
--	int		msg_ctx_fd;		/* generic message header */
--	unsigned long	msg_ovfl_pmds[4];	/* which PMDs overflowed */
--	unsigned short  msg_active_set;		/* active set at the time of overflow */
--	unsigned short  msg_reserved1;		/* for future use */
--	unsigned int    msg_reserved2;		/* for future use */
--	unsigned long	msg_tstamp;		/* for perf tuning/debug */
--} pfm_ovfl_msg_t;
--
--typedef struct {
--	int		msg_type;		/* generic message header */
--	int		msg_ctx_fd;		/* generic message header */
--	unsigned long	msg_tstamp;		/* for perf tuning */
--} pfm_end_msg_t;
--
--typedef struct {
--	int		msg_type;		/* type of the message */
--	int		msg_ctx_fd;		/* unique identifier for the context */
--	unsigned long	msg_tstamp;		/* for perf tuning */
--} pfm_gen_msg_t;
--
--#define PFM_MSG_OVFL	1	/* an overflow happened */
--#define PFM_MSG_END	2	/* task to which context was attached ended */
--
--typedef union {
--	pfm_ovfl_msg_t	pfm_ovfl_msg;
--	pfm_end_msg_t	pfm_end_msg;
--	pfm_gen_msg_t	pfm_gen_msg;
--} pfm_msg_t;
--
--/*
-- * Define the version numbers for both perfmon as a whole and the sampling buffer format.
-+ * This file contains Itanium Processor Family specific definitions
-+ * for the perfmon interface.
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-  */
--#define PFM_VERSION_MAJ		 2U
--#define PFM_VERSION_MIN		 0U
--#define PFM_VERSION		 (((PFM_VERSION_MAJ&0xffff)<<16)|(PFM_VERSION_MIN & 0xffff))
--#define PFM_VERSION_MAJOR(x)	 (((x)>>16) & 0xffff)
--#define PFM_VERSION_MINOR(x)	 ((x) & 0xffff)
--
-+#ifndef _ASM_IA64_PERFMON_H_
-+#define _ASM_IA64_PERFMON_H_
- 
- /*
-- * miscellaneous architected definitions
-+ * arch-specific user visible interface definitions
-  */
--#define PMU_FIRST_COUNTER	4	/* first counting monitor (PMC/PMD) */
--#define PMU_MAX_PMCS		256	/* maximum architected number of PMC registers */
--#define PMU_MAX_PMDS		256	/* maximum architected number of PMD registers */
--
--#ifdef __KERNEL__
--
--extern long perfmonctl(int fd, int cmd, void *arg, int narg);
--
--typedef struct {
--	void (*handler)(int irq, void *arg, struct pt_regs *regs);
--} pfm_intr_handler_desc_t;
--
--extern void pfm_save_regs (struct task_struct *);
--extern void pfm_load_regs (struct task_struct *);
- 
--extern void pfm_exit_thread(struct task_struct *);
--extern int  pfm_use_debug_registers(struct task_struct *);
--extern int  pfm_release_debug_registers(struct task_struct *);
--extern void pfm_syst_wide_update_task(struct task_struct *, unsigned long info, int is_ctxswin);
--extern void pfm_inherit(struct task_struct *task, struct pt_regs *regs);
--extern void pfm_init_percpu(void);
--extern void pfm_handle_work(void);
--extern int  pfm_install_alt_pmu_interrupt(pfm_intr_handler_desc_t *h);
--extern int  pfm_remove_alt_pmu_interrupt(pfm_intr_handler_desc_t *h);
-+#define PFM_ARCH_MAX_PMCS	(256+64)
-+#define PFM_ARCH_MAX_PMDS	(256+64)
- 
--
--
--/*
-- * Reset PMD register flags
-- */
--#define PFM_PMD_SHORT_RESET	0
--#define PFM_PMD_LONG_RESET	1
--
--typedef union {
--	unsigned int val;
--	struct {
--		unsigned int notify_user:1;	/* notify user program of overflow */
--		unsigned int reset_ovfl_pmds:1;	/* reset overflowed PMDs */
--		unsigned int block_task:1;	/* block monitored task on kernel exit */
--		unsigned int mask_monitoring:1; /* mask monitors via PMCx.plm */
--		unsigned int reserved:28;	/* for future use */
--	} bits;
--} pfm_ovfl_ctrl_t;
--
--typedef struct {
--	unsigned char	ovfl_pmd;			/* index of overflowed PMD  */
--	unsigned char   ovfl_notify;			/* =1 if monitor requested overflow notification */
--	unsigned short  active_set;			/* event set active at the time of the overflow */
--	pfm_ovfl_ctrl_t ovfl_ctrl;			/* return: perfmon controls to set by handler */
--
--	unsigned long   pmd_last_reset;			/* last reset value of of the PMD */
--	unsigned long	smpl_pmds[4];			/* bitmask of other PMD of interest on overflow */
--	unsigned long   smpl_pmds_values[PMU_MAX_PMDS]; /* values for the other PMDs of interest */
--	unsigned long   pmd_value;			/* current 64-bit value of the PMD */
--	unsigned long	pmd_eventid;			/* eventid associated with PMD */
--} pfm_ovfl_arg_t;
--
--
--typedef struct {
--	char		*fmt_name;
--	pfm_uuid_t	fmt_uuid;
--	size_t		fmt_arg_size;
--	unsigned long	fmt_flags;
--
--	int		(*fmt_validate)(struct task_struct *task, unsigned int flags, int cpu, void *arg);
--	int		(*fmt_getsize)(struct task_struct *task, unsigned int flags, int cpu, void *arg, unsigned long *size);
--	int 		(*fmt_init)(struct task_struct *task, void *buf, unsigned int flags, int cpu, void *arg);
--	int		(*fmt_handler)(struct task_struct *task, void *buf, pfm_ovfl_arg_t *arg, struct pt_regs *regs, unsigned long stamp);
--	int		(*fmt_restart)(struct task_struct *task, pfm_ovfl_ctrl_t *ctrl, void *buf, struct pt_regs *regs);
--	int		(*fmt_restart_active)(struct task_struct *task, pfm_ovfl_ctrl_t *ctrl, void *buf, struct pt_regs *regs);
--	int		(*fmt_exit)(struct task_struct *task, void *buf, struct pt_regs *regs);
--
--	struct list_head fmt_list;
--} pfm_buffer_fmt_t;
--
--extern int pfm_register_buffer_fmt(pfm_buffer_fmt_t *fmt);
--extern int pfm_unregister_buffer_fmt(pfm_uuid_t uuid);
-+#define PFM_ARCH_PMD_STK_ARG	8
-+#define PFM_ARCH_PMC_STK_ARG	8
- 
- /*
-- * perfmon interface exported to modules
-+ * Itanium specific context flags
-+ *
-+ * bits[00-15]: generic flags (see asm/perfmon.h)
-+ * bits[16-31]: arch-specific flags
-  */
--extern int pfm_mod_read_pmds(struct task_struct *, void *req, unsigned int nreq, struct pt_regs *regs);
--extern int pfm_mod_write_pmcs(struct task_struct *, void *req, unsigned int nreq, struct pt_regs *regs);
--extern int pfm_mod_write_ibrs(struct task_struct *task, void *req, unsigned int nreq, struct pt_regs *regs);
--extern int pfm_mod_write_dbrs(struct task_struct *task, void *req, unsigned int nreq, struct pt_regs *regs);
-+#define PFM_ITA_FL_INSECURE 0x10000 /* clear psr.sp on non system, non self */
- 
- /*
-- * describe the content of the local_cpu_date->pfm_syst_info field
-+ * Itanium specific public event set flags (set_flags)
-+ *
-+ * event set flags layout:
-+ * bits[00-15] : generic flags
-+ * bits[16-31] : arch-specific flags
-  */
--#define PFM_CPUINFO_SYST_WIDE	0x1	/* if set a system wide session exists */
--#define PFM_CPUINFO_DCR_PP	0x2	/* if set the system wide session has started */
--#define PFM_CPUINFO_EXCL_IDLE	0x4	/* the system wide session excludes the idle task */
-+#define PFM_ITA_SETFL_EXCL_INTR	0x10000	 /* exclude interrupt execution */
-+#define PFM_ITA_SETFL_INTR_ONLY	0x20000	 /* include only interrupt execution */
-+#define PFM_ITA_SETFL_IDLE_EXCL 0x40000  /* stop monitoring in idle loop */
- 
- /*
-- * sysctl control structure. visible to sampling formats
-+ * compatibility for version v2.0 of the interface
-  */
--typedef struct {
--	int	debug;		/* turn on/off debugging via syslog */
--	int	debug_ovfl;	/* turn on/off debug printk in overflow handler */
--	int	fastctxsw;	/* turn on/off fast (unsecure) ctxsw */
--	int	expert_mode;	/* turn on/off value checking */
--} pfm_sysctl_t;
--extern pfm_sysctl_t pfm_sysctl;
--
--
--#endif /* __KERNEL__ */
-+#include <asm/perfmon_compat.h>
- 
--#endif /* _ASM_IA64_PERFMON_H */
-+#endif /* _ASM_IA64_PERFMON_H_ */
-diff --git a/arch/ia64/include/asm/perfmon_compat.h b/arch/ia64/include/asm/perfmon_compat.h
-new file mode 100644
-index 0000000..5c14514
---- /dev/null
-+++ b/arch/ia64/include/asm/perfmon_compat.h
-@@ -0,0 +1,167 @@
-+/*
-+ * Copyright (c) 2001-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This header file contains perfmon interface definition
-+ * that are now obsolete and should be dropped in favor
-+ * of their equivalent functions as explained below.
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+  */
-+
-+#ifndef _ASM_IA64_PERFMON_COMPAT_H_
-+#define _ASM_IA64_PERFMON_COMPAT_H_
-+
-+/*
-+ * custom sampling buffer identifier type
-+ */
-+typedef __u8 pfm_uuid_t[16];
-+
-+/*
-+ * obsolete perfmon commands. Supported only on IA-64 for
-+ * backward compatiblity reasons with perfmon v2.0.
-+ */
-+#define PFM_WRITE_PMCS		0x01 /* use pfm_write_pmcs */
-+#define PFM_WRITE_PMDS		0x02 /* use pfm_write_pmds */
-+#define PFM_READ_PMDS		0x03 /* use pfm_read_pmds */
-+#define PFM_STOP		0x04 /* use pfm_stop */
-+#define PFM_START		0x05 /* use pfm_start */
-+#define PFM_ENABLE		0x06 /* obsolete */
-+#define PFM_DISABLE		0x07 /* obsolete */
-+#define PFM_CREATE_CONTEXT	0x08 /* use pfm_create_context */
-+#define PFM_DESTROY_CONTEXT	0x09 /* use close() */
-+#define PFM_RESTART		0x0a /* use pfm_restart */
-+#define PFM_PROTECT_CONTEXT	0x0b /* obsolete */
-+#define PFM_GET_FEATURES	0x0c /* use /proc/sys/perfmon */
-+#define PFM_DEBUG		0x0d /* /proc/sys/kernel/perfmon/debug */
-+#define PFM_UNPROTECT_CONTEXT	0x0e /* obsolete */
-+#define PFM_GET_PMC_RESET_VAL	0x0f /* use /proc/perfmon_map */
-+#define PFM_LOAD_CONTEXT	0x10 /* use pfm_load_context */
-+#define PFM_UNLOAD_CONTEXT	0x11 /* use pfm_unload_context */
-+
-+/*
-+ * PMU model specific commands (may not be supported on all PMU models)
-+ */
-+#define PFM_WRITE_IBRS		0x20 /* obsolete: use PFM_WRITE_PMCS[256-263]*/
-+#define PFM_WRITE_DBRS		0x21 /* obsolete: use PFM_WRITE_PMCS[264-271]*/
-+
-+/*
-+ * argument to PFM_CREATE_CONTEXT
-+ */
-+struct pfarg_context {
-+	pfm_uuid_t     ctx_smpl_buf_id;	 /* buffer format to use */
-+	unsigned long  ctx_flags;	 /* noblock/block */
-+	unsigned int   ctx_reserved1;	 /* for future use */
-+	int	       ctx_fd;		 /* return: fildesc */
-+	void	       *ctx_smpl_vaddr;	 /* return: vaddr of buffer */
-+	unsigned long  ctx_reserved3[11];/* for future use */
-+};
-+
-+/*
-+ * argument structure for PFM_WRITE_PMCS/PFM_WRITE_PMDS/PFM_WRITE_PMDS
-+ */
-+struct pfarg_reg {
-+	unsigned int	reg_num;	   /* which register */
-+	unsigned short	reg_set;	   /* event set for this register */
-+	unsigned short	reg_reserved1;	   /* for future use */
-+
-+	unsigned long	reg_value;	   /* initial pmc/pmd value */
-+	unsigned long	reg_flags;	   /* input: flags, ret: error */
-+
-+	unsigned long	reg_long_reset;	   /* reset value after notification */
-+	unsigned long	reg_short_reset;   /* reset after counter overflow */
-+
-+	unsigned long	reg_reset_pmds[4]; /* registers to reset on overflow */
-+	unsigned long	reg_random_seed;   /* seed for randomization */
-+	unsigned long	reg_random_mask;   /* random range limit */
-+	unsigned long   reg_last_reset_val;/* return: PMD last reset value */
-+
-+	unsigned long	reg_smpl_pmds[4];  /* pmds to be saved on overflow */
-+	unsigned long	reg_smpl_eventid;  /* opaque sampling event id */
-+	unsigned long   reg_ovfl_switch_cnt;/* #overflows to switch */
-+
-+	unsigned long   reg_reserved2[2];   /* for future use */
-+};
-+
-+/*
-+ * argument to PFM_WRITE_IBRS/PFM_WRITE_DBRS
-+ */
-+struct pfarg_dbreg {
-+	unsigned int	dbreg_num;		/* which debug register */
-+	unsigned short	dbreg_set;		/* event set */
-+	unsigned short	dbreg_reserved1;	/* for future use */
-+	unsigned long	dbreg_value;		/* value for debug register */
-+	unsigned long	dbreg_flags;		/* return: dbreg error */
-+	unsigned long	dbreg_reserved2[1];	/* for future use */
-+};
-+
-+/*
-+ * argument to PFM_GET_FEATURES
-+ */
-+struct pfarg_features {
-+	unsigned int	ft_version;	/* major [16-31], minor [0-15] */
-+	unsigned int	ft_reserved;	/* reserved for future use */
-+	unsigned long	reserved[4];	/* for future use */
-+};
-+
-+typedef struct {
-+	int		msg_type;		/* generic message header */
-+	int		msg_ctx_fd;		/* generic message header */
-+	unsigned long	msg_ovfl_pmds[4];	/* which PMDs overflowed */
-+	unsigned short  msg_active_set;		/* active set on overflow */
-+	unsigned short  msg_reserved1;		/* for future use */
-+	unsigned int    msg_reserved2;		/* for future use */
-+	unsigned long	msg_tstamp;		/* for perf tuning/debug */
-+} pfm_ovfl_msg_t;
-+
-+typedef struct {
-+	int		msg_type;		/* generic message header */
-+	int		msg_ctx_fd;		/* generic message header */
-+	unsigned long	msg_tstamp;		/* for perf tuning */
-+} pfm_end_msg_t;
-+
-+typedef struct {
-+	int		msg_type;		/* type of the message */
-+	int		msg_ctx_fd;		/* context file descriptor */
-+	unsigned long	msg_tstamp;		/* for perf tuning */
-+} pfm_gen_msg_t;
-+
-+typedef union {
-+	int type;
-+	pfm_ovfl_msg_t	pfm_ovfl_msg;
-+	pfm_end_msg_t	pfm_end_msg;
-+	pfm_gen_msg_t	pfm_gen_msg;
-+} pfm_msg_t;
-+
-+/*
-+ * PMD/PMC return flags in case of error (ignored on input)
-+ *
-+ * reg_flags layout:
-+ * bit 00-15 : generic flags
-+ * bits[16-23] : arch-specific flags (see asm/perfmon.h)
-+ * bit 24-31 : error codes
-+ *
-+ * Those flags are used on output and must be checked in case EINVAL is
-+ * returned by a command accepting a vector of values and each has a flag
-+ * field, such as pfarg_reg or pfarg_reg
-+ */
-+#define PFM_REG_RETFL_NOTAVAIL	(1<<31) /* not implemented or unaccessible */
-+#define PFM_REG_RETFL_EINVAL	(1<<30) /* entry is invalid */
-+#define PFM_REG_RETFL_MASK	(PFM_REG_RETFL_NOTAVAIL|\
-+				 PFM_REG_RETFL_EINVAL)
-+
-+#define PFM_REG_HAS_ERROR(flag)	(((flag) & PFM_REG_RETFL_MASK) != 0)
-+
-+#endif /* _ASM_IA64_PERFMON_COMPAT_H_ */
-diff --git a/arch/ia64/include/asm/perfmon_default_smpl.h b/arch/ia64/include/asm/perfmon_default_smpl.h
-index 48822c0..8234f32 100644
---- a/arch/ia64/include/asm/perfmon_default_smpl.h
-+++ b/arch/ia64/include/asm/perfmon_default_smpl.h
-@@ -1,83 +1,106 @@
- /*
-- * Copyright (C) 2002-2003 Hewlett-Packard Co
-- *               Stephane Eranian <eranian@hpl.hp.com>
-+ * Copyright (c) 2002-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-  *
-- * This file implements the default sampling buffer format
-- * for Linux/ia64 perfmon subsystem.
-+ * This file implements the old default sampling buffer format
-+ * for the perfmon2 subsystem. For IA-64 only.
-+ *
-+ * It requires the use of the perfmon_compat.h header. It is recommended
-+ * that applications be ported to the new format instead.
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-  */
--#ifndef __PERFMON_DEFAULT_SMPL_H__
--#define __PERFMON_DEFAULT_SMPL_H__ 1
-+#ifndef __ASM_IA64_PERFMON_DEFAULT_SMPL_H__
-+#define __ASM_IA64_PERFMON_DEFAULT_SMPL_H__ 1
-+
-+#ifndef __ia64__
-+#error "this file must be used for compatibility reasons only on IA-64"
-+#endif
- 
- #define PFM_DEFAULT_SMPL_UUID { \
--		0x4d, 0x72, 0xbe, 0xc0, 0x06, 0x64, 0x41, 0x43, 0x82, 0xb4, 0xd3, 0xfd, 0x27, 0x24, 0x3c, 0x97}
-+		0x4d, 0x72, 0xbe, 0xc0, 0x06, 0x64, 0x41, 0x43, 0x82,\
-+		0xb4, 0xd3, 0xfd, 0x27, 0x24, 0x3c, 0x97}
- 
- /*
-  * format specific parameters (passed at context creation)
-  */
--typedef struct {
-+struct pfm_default_smpl_arg {
- 	unsigned long buf_size;		/* size of the buffer in bytes */
- 	unsigned int  flags;		/* buffer specific flags */
- 	unsigned int  res1;		/* for future use */
- 	unsigned long reserved[2];	/* for future use */
--} pfm_default_smpl_arg_t;
-+};
- 
- /*
-  * combined context+format specific structure. Can be passed
-- * to PFM_CONTEXT_CREATE
-+ * to PFM_CONTEXT_CREATE (not PFM_CONTEXT_CREATE2)
-  */
--typedef struct {
--	pfarg_context_t		ctx_arg;
--	pfm_default_smpl_arg_t	buf_arg;
--} pfm_default_smpl_ctx_arg_t;
-+struct pfm_default_smpl_ctx_arg {
-+	struct pfarg_context		ctx_arg;
-+	struct pfm_default_smpl_arg	buf_arg;
-+};
- 
- /*
-  * This header is at the beginning of the sampling buffer returned to the user.
-  * It is directly followed by the first record.
-  */
--typedef struct {
--	unsigned long	hdr_count;		/* how many valid entries */
--	unsigned long	hdr_cur_offs;		/* current offset from top of buffer */
--	unsigned long	hdr_reserved2;		/* reserved for future use */
-+struct pfm_default_smpl_hdr {
-+	u64	hdr_count;	/* how many valid entries */
-+	u64	hdr_cur_offs;	/* current offset from top of buffer */
-+	u64	dr_reserved2;	/* reserved for future use */
- 
--	unsigned long	hdr_overflows;		/* how many times the buffer overflowed */
--	unsigned long   hdr_buf_size;		/* how many bytes in the buffer */
-+	u64	hdr_overflows;	/* how many times the buffer overflowed */
-+	u64	hdr_buf_size;	/* how many bytes in the buffer */
- 
--	unsigned int	hdr_version;		/* contains perfmon version (smpl format diffs) */
--	unsigned int	hdr_reserved1;		/* for future use */
--	unsigned long	hdr_reserved[10];	/* for future use */
--} pfm_default_smpl_hdr_t;
-+	u32	hdr_version;	/* smpl format version*/
-+	u32	hdr_reserved1;		/* for future use */
-+	u64	hdr_reserved[10];	/* for future use */
-+};
- 
- /*
-  * Entry header in the sampling buffer.  The header is directly followed
-- * with the values of the PMD registers of interest saved in increasing 
-- * index order: PMD4, PMD5, and so on. How many PMDs are present depends 
-+ * with the values of the PMD registers of interest saved in increasing
-+ * index order: PMD4, PMD5, and so on. How many PMDs are present depends
-  * on how the session was programmed.
-  *
-  * In the case where multiple counters overflow at the same time, multiple
-  * entries are written consecutively.
-  *
-- * last_reset_value member indicates the initial value of the overflowed PMD. 
-+ * last_reset_value member indicates the initial value of the overflowed PMD.
-  */
--typedef struct {
--        int             pid;                    /* thread id (for NPTL, this is gettid()) */
--        unsigned char   reserved1[3];           /* reserved for future use */
--        unsigned char   ovfl_pmd;               /* index of overflowed PMD */
--
--        unsigned long   last_reset_val;         /* initial value of overflowed PMD */
--        unsigned long   ip;                     /* where did the overflow interrupt happened  */
--        unsigned long   tstamp;                 /* ar.itc when entering perfmon intr. handler */
--
--        unsigned short  cpu;                    /* cpu on which the overfow occured */
--        unsigned short  set;                    /* event set active when overflow ocurred   */
--        int    		tgid;              	/* thread group id (for NPTL, this is getpid()) */
--} pfm_default_smpl_entry_t;
-+struct pfm_default_smpl_entry {
-+	pid_t	pid;		/* thread id (for NPTL, this is gettid()) */
-+	uint8_t	reserved1[3];	/* for future use */
-+	uint8_t	ovfl_pmd;	/* overflow pmd for this sample */
-+	u64	last_reset_val;	/* initial value of overflowed PMD */
-+	unsigned long ip;	/* where did the overflow interrupt happened */
-+	u64	tstamp; 	/* overflow timetamp */
-+	u16	cpu;  		/* cpu on which the overfow occured */
-+	u16	set;  		/* event set active when overflow ocurred   */
-+	pid_t	tgid;		/* thread group id (for NPTL, this is getpid()) */
-+};
- 
--#define PFM_DEFAULT_MAX_PMDS		64 /* how many pmds supported by data structures (sizeof(unsigned long) */
--#define PFM_DEFAULT_MAX_ENTRY_SIZE	(sizeof(pfm_default_smpl_entry_t)+(sizeof(unsigned long)*PFM_DEFAULT_MAX_PMDS))
--#define PFM_DEFAULT_SMPL_MIN_BUF_SIZE	(sizeof(pfm_default_smpl_hdr_t)+PFM_DEFAULT_MAX_ENTRY_SIZE)
-+#define PFM_DEFAULT_MAX_PMDS		64 /* #pmds supported  */
-+#define PFM_DEFAULT_MAX_ENTRY_SIZE	(sizeof(struct pfm_default_smpl_entry)+\
-+					 (sizeof(u64)*PFM_DEFAULT_MAX_PMDS))
-+#define PFM_DEFAULT_SMPL_MIN_BUF_SIZE	(sizeof(struct pfm_default_smpl_hdr)+\
-+					 PFM_DEFAULT_MAX_ENTRY_SIZE)
- 
- #define PFM_DEFAULT_SMPL_VERSION_MAJ	2U
--#define PFM_DEFAULT_SMPL_VERSION_MIN	0U
--#define PFM_DEFAULT_SMPL_VERSION	(((PFM_DEFAULT_SMPL_VERSION_MAJ&0xffff)<<16)|(PFM_DEFAULT_SMPL_VERSION_MIN & 0xffff))
-+#define PFM_DEFAULT_SMPL_VERSION_MIN 1U
-+#define PFM_DEFAULT_SMPL_VERSION (((PFM_DEFAULT_SMPL_VERSION_MAJ&0xffff)<<16)|\
-+				    (PFM_DEFAULT_SMPL_VERSION_MIN & 0xffff))
- 
--#endif /* __PERFMON_DEFAULT_SMPL_H__ */
-+#endif /* __ASM_IA64_PERFMON_DEFAULT_SMPL_H__ */
-diff --git a/arch/ia64/include/asm/perfmon_kern.h b/arch/ia64/include/asm/perfmon_kern.h
-new file mode 100644
-index 0000000..fb40459
---- /dev/null
-+++ b/arch/ia64/include/asm/perfmon_kern.h
-@@ -0,0 +1,356 @@
-+/*
-+ * Copyright (c) 2001-2007 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This file contains Itanium Processor Family specific definitions
-+ * for the perfmon interface.
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+  */
-+#ifndef _ASM_IA64_PERFMON_KERN_H_
-+#define _ASM_IA64_PERFMON_KERN_H_
-+
-+#ifdef __KERNEL__
-+
-+#ifdef CONFIG_PERFMON
-+#include <asm/unistd.h>
-+#include <asm/hw_irq.h>
-+
-+/*
-+ * describe the content of the pfm_syst_info field
-+ * layout:
-+ * bits[00-15] : generic flags
-+ * bits[16-31] : arch-specific flags
-+ */
-+#define PFM_ITA_CPUINFO_IDLE_EXCL 0x10000 /* stop monitoring in idle loop */
-+
-+/*
-+ * For some CPUs, the upper bits of a counter must be set in order for the
-+ * overflow interrupt to happen. On overflow, the counter has wrapped around,
-+ * and the upper bits are cleared. This function may be used to set them back.
-+ */
-+static inline void pfm_arch_ovfl_reset_pmd(struct pfm_context *ctx,
-+					   unsigned int cnum)
-+{}
-+
-+/*
-+ * called from __pfm_interrupt_handler(). ctx is not NULL.
-+ * ctx is locked. PMU interrupt is masked.
-+ *
-+ * must stop all monitoring to ensure handler has consistent view.
-+ * must collect overflowed PMDs bitmask  into povfls_pmds and
-+ * npend_ovfls. If no interrupt detected then npend_ovfls
-+ * must be set to zero.
-+ */
-+static inline void pfm_arch_intr_freeze_pmu(struct pfm_context *ctx,
-+					    struct pfm_event_set *set)
-+{
-+	u64 tmp;
-+
-+	/*
-+	 * do not overwrite existing value, must
-+	 * process those first (coming from context switch replay)
-+	 */
-+	if (set->npend_ovfls)
-+		return;
-+
-+	ia64_srlz_d();
-+
-+	tmp =  ia64_get_pmc(0) & ~0xf;
-+
-+	set->povfl_pmds[0] = tmp;
-+
-+	set->npend_ovfls = ia64_popcnt(tmp);
-+}
-+
-+static inline int pfm_arch_init_pmu_config(void)
-+{
-+	return 0;
-+}
-+
-+static inline void pfm_arch_resend_irq(struct pfm_context *ctx)
-+{
-+	ia64_resend_irq(IA64_PERFMON_VECTOR);
-+}
-+
-+static inline void pfm_arch_clear_pmd_ovfl_cond(struct pfm_context *ctx,
-+					        struct pfm_event_set *set)
-+{}
-+
-+static inline void pfm_arch_serialize(void)
-+{
-+	ia64_srlz_d();
-+}
-+
-+static inline void pfm_arch_intr_unfreeze_pmu(struct pfm_context *ctx)
-+{
-+	PFM_DBG_ovfl("state=%d", ctx->state);
-+	ia64_set_pmc(0, 0);
-+	/* no serialization */
-+}
-+
-+static inline void pfm_arch_write_pmc(struct pfm_context *ctx,
-+				      unsigned int cnum, u64 value)
-+{
-+	if (cnum < 256) {
-+		ia64_set_pmc(pfm_pmu_conf->pmc_desc[cnum].hw_addr, value);
-+	} else if (cnum < 264) {
-+		ia64_set_ibr(cnum-256, value);
-+		ia64_dv_serialize_instruction();
-+	} else {
-+		ia64_set_dbr(cnum-264, value);
-+		ia64_dv_serialize_instruction();
-+	}
-+}
-+
-+/*
-+ * On IA-64, for per-thread context which have the ITA_FL_INSECURE
-+ * flag, it is possible to start/stop monitoring directly from user evel
-+ * without calling pfm_start()/pfm_stop. This allows very lightweight
-+ * control yet the kernel sometimes needs to know if monitoring is actually
-+ * on or off.
-+ *
-+ * Tracking of this information is normally done by pfm_start/pfm_stop
-+ * in flags.started. Here we need to compensate by checking actual
-+ * psr bit.
-+ */
-+static inline int pfm_arch_is_active(struct pfm_context *ctx)
-+{
-+	return ctx->flags.started
-+	       || ia64_getreg(_IA64_REG_PSR) & (IA64_PSR_UP|IA64_PSR_PP);
-+}
-+
-+static inline void pfm_arch_write_pmd(struct pfm_context *ctx,
-+				      unsigned int cnum, u64 value)
-+{
-+	/*
-+	 * for a counting PMD, overflow bit must be cleared
-+	 */
-+	if (pfm_pmu_conf->pmd_desc[cnum].type & PFM_REG_C64)
-+		value &= pfm_pmu_conf->ovfl_mask;
-+
-+	/*
-+	 * for counters, write to upper bits are ignored, no need to mask
-+	 */
-+	ia64_set_pmd(pfm_pmu_conf->pmd_desc[cnum].hw_addr, value);
-+}
-+
-+static inline u64 pfm_arch_read_pmd(struct pfm_context *ctx, unsigned int cnum)
-+{
-+	return ia64_get_pmd(pfm_pmu_conf->pmd_desc[cnum].hw_addr);
-+}
-+
-+static inline u64 pfm_arch_read_pmc(struct pfm_context *ctx, unsigned int cnum)
-+{
-+	return ia64_get_pmc(pfm_pmu_conf->pmc_desc[cnum].hw_addr);
-+}
-+
-+static inline void pfm_arch_ctxswout_sys(struct task_struct *task,
-+					 struct pfm_context *ctx)
-+{
-+	struct pt_regs *regs;
-+
-+	regs = task_pt_regs(task);
-+	ia64_psr(regs)->pp = 0;
-+}
-+
-+static inline void pfm_arch_ctxswin_sys(struct task_struct *task,
-+					struct pfm_context *ctx)
-+{
-+	struct pt_regs *regs;
-+
-+	if (!(ctx->active_set->flags & PFM_ITA_SETFL_INTR_ONLY)) {
-+		regs = task_pt_regs(task);
-+		ia64_psr(regs)->pp = 1;
-+	}
-+}
-+
-+/*
-+ * On IA-64, the PMDs are NOT saved by pfm_arch_freeze_pmu()
-+ * when entering the PMU interrupt handler, thus, we need
-+ * to save them in pfm_switch_sets_from_intr()
-+ */
-+static inline void pfm_arch_save_pmds_from_intr(struct pfm_context *ctx,
-+					   struct pfm_event_set *set)
-+{
-+	pfm_save_pmds(ctx, set);
-+}
-+
-+int pfm_arch_context_create(struct pfm_context *ctx, u32 ctx_flags);
-+
-+static inline void pfm_arch_context_free(struct pfm_context *ctx)
-+{}
-+
-+int pfm_arch_ctxswout_thread(struct task_struct *task, struct pfm_context *ctx);
-+void pfm_arch_ctxswin_thread(struct task_struct *task,
-+			     struct pfm_context *ctx);
-+
-+void pfm_arch_unload_context(struct pfm_context *ctx);
-+int pfm_arch_load_context(struct pfm_context *ctx);
-+int pfm_arch_setfl_sane(struct pfm_context *ctx, u32 flags);
-+
-+void pfm_arch_mask_monitoring(struct pfm_context *ctx,
-+			      struct pfm_event_set *set);
-+void pfm_arch_unmask_monitoring(struct pfm_context *ctx,
-+				struct pfm_event_set *set);
-+
-+void pfm_arch_restore_pmds(struct pfm_context *ctx, struct pfm_event_set *set);
-+void pfm_arch_restore_pmcs(struct pfm_context *ctx, struct pfm_event_set *set);
-+
-+void pfm_arch_stop(struct task_struct *task, struct pfm_context *ctx);
-+void pfm_arch_start(struct task_struct *task, struct pfm_context *ctx);
-+
-+int  pfm_arch_init(void);
-+void pfm_arch_init_percpu(void);
-+char *pfm_arch_get_pmu_module_name(void);
-+
-+int __pfm_use_dbregs(struct task_struct *task);
-+int  __pfm_release_dbregs(struct task_struct *task);
-+int pfm_ia64_mark_dbregs_used(struct pfm_context *ctx,
-+			      struct pfm_event_set *set);
-+
-+void pfm_arch_show_session(struct seq_file *m);
-+
-+static inline int pfm_arch_pmu_acquire(u64 *unavail_pmcs, u64 *unavail_pmds)
-+{
-+	return 0;
-+}
-+
-+static inline void pfm_arch_pmu_release(void)
-+{}
-+
-+/* not necessary on IA-64 */
-+static inline void pfm_cacheflush(void *addr, unsigned int len)
-+{}
-+
-+/*
-+ * miscellaneous architected definitions
-+ */
-+#define PFM_ITA_FCNTR	4 /* first counting monitor (PMC/PMD) */
-+
-+/*
-+ * private event set flags  (set_priv_flags)
-+ */
-+#define PFM_ITA_SETFL_USE_DBR	0x1000000 /* set uses debug registers */
-+
-+
-+/*
-+ * Itanium-specific data structures
-+ */
-+struct pfm_ia64_context_flags {
-+	unsigned int use_dbr:1;	 /* use range restrictions (debug registers) */
-+	unsigned int insecure:1; /* insecure monitoring for non-self session */
-+	unsigned int reserved:30;/* for future use */
-+};
-+
-+struct pfm_arch_context {
-+	struct pfm_ia64_context_flags flags;	/* arch specific ctx flags */
-+	u64			 ctx_saved_psr_up;/* storage for psr_up */
-+#ifdef CONFIG_IA64_PERFMON_COMPAT
-+	void			*ctx_smpl_vaddr; /* vaddr of user mapping */
-+#endif
-+};
-+
-+#ifdef CONFIG_IA64_PERFMON_COMPAT
-+ssize_t pfm_arch_compat_read(struct pfm_context *ctx,
-+			     char __user *buf,
-+			     int non_block,
-+			     size_t size);
-+int pfm_ia64_compat_init(void);
-+int pfm_smpl_buf_alloc_compat(struct pfm_context *ctx,
-+			      size_t rsize, struct file *filp);
-+#else
-+static inline ssize_t pfm_arch_compat_read(struct pfm_context *ctx,
-+			     char __user *buf,
-+			     int non_block,
-+			     size_t size)
-+{
-+	return -EINVAL;
-+}
-+
-+static inline int pfm_smpl_buf_alloc_compat(struct pfm_context *ctx,
-+					    size_t rsize, struct file *filp)
-+{
-+	return -EINVAL;
-+}
-+#endif
-+
-+static inline void pfm_arch_arm_handle_work(struct task_struct *task)
-+{
-+	/*
-+	 * On IA-64, we ran out of bits in the bottom 7 bits of the
-+	 * threadinfo bitmask.Thus we used a 2-stage approach by piggybacking
-+	 * on NOTIFY_RESUME and then in do_notify_resume() we demultiplex and
-+	 * call pfm_handle_work() if needed
-+	 */
-+	set_tsk_thread_flag(task, TIF_NOTIFY_RESUME);
-+}
-+
-+static inline void pfm_arch_disarm_handle_work(struct task_struct *task)
-+{
-+	/*
-+	 * we cannot just clear TIF_NOTIFY_RESUME because other TIF flags are
-+	 * piggybackedonto it: TIF_PERFMON_WORK, TIF_RESTORE_RSE
-+	 *
-+	 * The tsk_clear_notify_resume() checks if any of those are set before
-+	 * clearing the * bit
-+	 */
-+	tsk_clear_notify_resume(task);
-+}
-+
-+static inline int pfm_arch_pmu_config_init(struct pfm_pmu_config *cfg)
-+{
-+	return 0;
-+}
-+
-+extern struct pfm_ia64_pmu_info *pfm_ia64_pmu_info;
-+
-+#define PFM_ARCH_CTX_SIZE	(sizeof(struct pfm_arch_context))
-+
-+/*
-+ * IA-64 does not need extra alignment requirements for the sampling buffer
-+ */
-+#define PFM_ARCH_SMPL_ALIGN_SIZE	0
-+
-+
-+static inline void pfm_release_dbregs(struct task_struct *task)
-+{
-+	if (task->thread.flags & IA64_THREAD_DBG_VALID)
-+		__pfm_release_dbregs(task);
-+}
-+
-+#define pfm_use_dbregs(_t)     __pfm_use_dbregs(_t)
-+
-+static inline int pfm_arch_get_base_syscall(void)
-+{
-+	return __NR_pfm_create_context;
-+}
-+
-+struct pfm_arch_pmu_info {
-+	unsigned long mask_pmcs[PFM_PMC_BV]; /* modify on when masking */
-+};
-+
-+DECLARE_PER_CPU(u32, pfm_syst_info);
-+#else /* !CONFIG_PERFMON */
-+/*
-+ * perfmon ia64-specific hooks
-+ */
-+#define pfm_release_dbregs(_t) 		do { } while (0)
-+#define pfm_use_dbregs(_t)     		(0)
-+
-+#endif /* CONFIG_PERFMON */
-+
-+#endif /* __KERNEL__ */
-+#endif /* _ASM_IA64_PERFMON_KERN_H_ */
-diff --git a/arch/ia64/include/asm/processor.h b/arch/ia64/include/asm/processor.h
-index f88fa05..9d6af9c 100644
---- a/arch/ia64/include/asm/processor.h
-+++ b/arch/ia64/include/asm/processor.h
-@@ -42,7 +42,6 @@
- 
- #define IA64_THREAD_FPH_VALID	(__IA64_UL(1) << 0)	/* floating-point high state valid? */
- #define IA64_THREAD_DBG_VALID	(__IA64_UL(1) << 1)	/* debug registers valid? */
--#define IA64_THREAD_PM_VALID	(__IA64_UL(1) << 2)	/* performance registers valid? */
- #define IA64_THREAD_UAC_NOPRINT	(__IA64_UL(1) << 3)	/* don't log unaligned accesses */
- #define IA64_THREAD_UAC_SIGBUS	(__IA64_UL(1) << 4)	/* generate SIGBUS on unaligned acc. */
- #define IA64_THREAD_MIGRATION	(__IA64_UL(1) << 5)	/* require migration
-@@ -321,14 +320,6 @@ struct thread_struct {
- #else
- # define INIT_THREAD_IA32
- #endif /* CONFIG_IA32_SUPPORT */
--#ifdef CONFIG_PERFMON
--	void *pfm_context;		     /* pointer to detailed PMU context */
--	unsigned long pfm_needs_checking;    /* when >0, pending perfmon work on kernel exit */
--# define INIT_THREAD_PM		.pfm_context =		NULL,     \
--				.pfm_needs_checking =	0UL,
--#else
--# define INIT_THREAD_PM
--#endif
- 	__u64 dbr[IA64_NUM_DBG_REGS];
- 	__u64 ibr[IA64_NUM_DBG_REGS];
- 	struct ia64_fpreg fph[96];	/* saved/loaded on demand */
-@@ -343,7 +334,6 @@ struct thread_struct {
- 	.task_size =	DEFAULT_TASK_SIZE,			\
- 	.last_fph_cpu =  -1,					\
- 	INIT_THREAD_IA32					\
--	INIT_THREAD_PM						\
- 	.dbr =		{0, },					\
- 	.ibr =		{0, },					\
- 	.fph =		{{{{0}}}, }				\
-diff --git a/arch/ia64/include/asm/system.h b/arch/ia64/include/asm/system.h
-index 927a381..ab5aeea 100644
---- a/arch/ia64/include/asm/system.h
-+++ b/arch/ia64/include/asm/system.h
-@@ -217,6 +217,7 @@ struct task_struct;
- extern void ia64_save_extra (struct task_struct *task);
- extern void ia64_load_extra (struct task_struct *task);
- 
-+
- #ifdef CONFIG_VIRT_CPU_ACCOUNTING
- extern void ia64_account_on_switch (struct task_struct *prev, struct task_struct *next);
- # define IA64_ACCOUNT_ON_SWITCH(p,n) ia64_account_on_switch(p,n)
-@@ -224,16 +225,9 @@ extern void ia64_account_on_switch (struct task_struct *prev, struct task_struct
- # define IA64_ACCOUNT_ON_SWITCH(p,n)
- #endif
- 
--#ifdef CONFIG_PERFMON
--  DECLARE_PER_CPU(unsigned long, pfm_syst_info);
--# define PERFMON_IS_SYSWIDE() (__get_cpu_var(pfm_syst_info) & 0x1)
--#else
--# define PERFMON_IS_SYSWIDE() (0)
--#endif
--
--#define IA64_HAS_EXTRA_STATE(t)							\
--	((t)->thread.flags & (IA64_THREAD_DBG_VALID|IA64_THREAD_PM_VALID)	\
--	 || IS_IA32_PROCESS(task_pt_regs(t)) || PERFMON_IS_SYSWIDE())
-+#define IA64_HAS_EXTRA_STATE(t)						\
-+	(((t)->thread.flags & IA64_THREAD_DBG_VALID)			\
-+	 || IS_IA32_PROCESS(task_pt_regs(t)))
- 
- #define __switch_to(prev,next,last) do {							 \
- 	IA64_ACCOUNT_ON_SWITCH(prev, next);							 \
-@@ -241,6 +235,10 @@ extern void ia64_account_on_switch (struct task_struct *prev, struct task_struct
- 		ia64_save_extra(prev);								 \
- 	if (IA64_HAS_EXTRA_STATE(next))								 \
- 		ia64_load_extra(next);								 \
-+	if (test_tsk_thread_flag(prev, TIF_PERFMON_CTXSW))					 \
-+		pfm_ctxsw_out(prev, next);						 	 \
-+	if (test_tsk_thread_flag(next, TIF_PERFMON_CTXSW))					 \
-+		pfm_ctxsw_in(prev, next);						 	 \
- 	ia64_psr(task_pt_regs(next))->dfh = !ia64_is_local_fpu_owner(next);			 \
- 	(last) = ia64_switch_to((next));							 \
- } while (0)
-diff --git a/arch/ia64/include/asm/thread_info.h b/arch/ia64/include/asm/thread_info.h
-index 7c60fcd..3355332 100644
---- a/arch/ia64/include/asm/thread_info.h
-+++ b/arch/ia64/include/asm/thread_info.h
-@@ -110,6 +110,8 @@ extern void tsk_clear_notify_resume(struct task_struct *tsk);
- #define TIF_DB_DISABLED		19	/* debug trap disabled for fsyscall */
- #define TIF_FREEZE		20	/* is freezing for suspend */
- #define TIF_RESTORE_RSE		21	/* user RBS is newer than kernel RBS */
-+#define TIF_PERFMON_CTXSW	22	/* perfmon needs ctxsw calls */
-+#define TIF_PERFMON_WORK	23	/* work for pfm_handle_work() */
- 
- #define _TIF_SYSCALL_TRACE	(1 << TIF_SYSCALL_TRACE)
- #define _TIF_SYSCALL_AUDIT	(1 << TIF_SYSCALL_AUDIT)
-@@ -123,6 +125,8 @@ extern void tsk_clear_notify_resume(struct task_struct *tsk);
- #define _TIF_DB_DISABLED	(1 << TIF_DB_DISABLED)
- #define _TIF_FREEZE		(1 << TIF_FREEZE)
- #define _TIF_RESTORE_RSE	(1 << TIF_RESTORE_RSE)
-+#define _TIF_PERFMON_CTXSW	(1 << TIF_PERFMON_CTXSW)
-+#define _TIF_PERFMON_WORK	(1 << TIF_PERFMON_WORK)
- 
- /* "work to do on user-return" bits */
- #define TIF_ALLWORK_MASK	(_TIF_SIGPENDING|_TIF_NOTIFY_RESUME|_TIF_SYSCALL_AUDIT|\
-diff --git a/arch/ia64/include/asm/unistd.h b/arch/ia64/include/asm/unistd.h
-index d535833..29a43bc 100644
---- a/arch/ia64/include/asm/unistd.h
-+++ b/arch/ia64/include/asm/unistd.h
-@@ -308,11 +308,23 @@
- #define __NR_dup3			1316
- #define __NR_pipe2			1317
- #define __NR_inotify_init1		1318
-+#define __NR_pfm_create_context		1319
-+#define __NR_pfm_write_pmcs		(__NR_pfm_create_context+1)
-+#define __NR_pfm_write_pmds		(__NR_pfm_create_context+2)
-+#define __NR_pfm_read_pmds		(__NR_pfm_create_context+3)
-+#define __NR_pfm_load_context		(__NR_pfm_create_context+4)
-+#define __NR_pfm_start			(__NR_pfm_create_context+5)
-+#define __NR_pfm_stop			(__NR_pfm_create_context+6)
-+#define __NR_pfm_restart		(__NR_pfm_create_context+7)
-+#define __NR_pfm_create_evtsets		(__NR_pfm_create_context+8)
-+#define __NR_pfm_getinfo_evtsets 	(__NR_pfm_create_context+9)
-+#define __NR_pfm_delete_evtsets 	(__NR_pfm_create_context+10)
-+#define __NR_pfm_unload_context		(__NR_pfm_create_context+11)
- 
- #ifdef __KERNEL__
- 
- 
--#define NR_syscalls			295 /* length of syscall table */
-+#define NR_syscalls			307 /* length of syscall table */
- 
- /*
-  * The following defines stop scripts/checksyscalls.sh from complaining about
-diff --git a/arch/ia64/kernel/Makefile b/arch/ia64/kernel/Makefile
-index 87fea11..b5ac54c 100644
---- a/arch/ia64/kernel/Makefile
-+++ b/arch/ia64/kernel/Makefile
-@@ -5,7 +5,7 @@
- extra-y	:= head.o init_task.o vmlinux.lds
- 
- obj-y := acpi.o entry.o efi.o efi_stub.o gate-data.o fsys.o ia64_ksyms.o irq.o irq_ia64.o	\
--	 irq_lsapic.o ivt.o machvec.o pal.o patch.o process.o perfmon.o ptrace.o sal.o		\
-+	 irq_lsapic.o ivt.o machvec.o pal.o patch.o process.o ptrace.o sal.o		\
- 	 salinfo.o setup.o signal.o sys_ia64.o time.o traps.o unaligned.o \
- 	 unwind.o mca.o mca_asm.o topology.o
- 
-@@ -23,7 +23,6 @@ obj-$(CONFIG_IOSAPIC)		+= iosapic.o
- obj-$(CONFIG_MODULES)		+= module.o
- obj-$(CONFIG_SMP)		+= smp.o smpboot.o
- obj-$(CONFIG_NUMA)		+= numa.o
--obj-$(CONFIG_PERFMON)		+= perfmon_default_smpl.o
- obj-$(CONFIG_IA64_CYCLONE)	+= cyclone.o
- obj-$(CONFIG_CPU_FREQ)		+= cpufreq/
- obj-$(CONFIG_IA64_MCA_RECOVERY)	+= mca_recovery.o
-diff --git a/arch/ia64/kernel/entry.S b/arch/ia64/kernel/entry.S
-index 0dd6c14..f1c3e41 100644
---- a/arch/ia64/kernel/entry.S
-+++ b/arch/ia64/kernel/entry.S
-@@ -1697,6 +1697,18 @@ sys_call_table:
- 	data8 sys_dup3
- 	data8 sys_pipe2
- 	data8 sys_inotify_init1
-+	data8 sys_pfm_create_context
-+	data8 sys_pfm_write_pmcs		// 1320
-+	data8 sys_pfm_write_pmds
-+	data8 sys_pfm_read_pmds
-+	data8 sys_pfm_load_context
-+	data8 sys_pfm_start
-+	data8 sys_pfm_stop			// 1325
-+	data8 sys_pfm_restart
-+	data8 sys_pfm_create_evtsets
-+	data8 sys_pfm_getinfo_evtsets
-+	data8 sys_pfm_delete_evtsets
-+	data8 sys_pfm_unload_context		// 1330
- 
- 	.org sys_call_table + 8*NR_syscalls	// guard against failures to increase NR_syscalls
- #endif /* __IA64_ASM_PARAVIRTUALIZED_NATIVE */
-diff --git a/arch/ia64/kernel/irq_ia64.c b/arch/ia64/kernel/irq_ia64.c
-index 28d3d48..ede8024 100644
---- a/arch/ia64/kernel/irq_ia64.c
-+++ b/arch/ia64/kernel/irq_ia64.c
-@@ -40,10 +40,6 @@
- #include <asm/system.h>
- #include <asm/tlbflush.h>
- 
--#ifdef CONFIG_PERFMON
--# include <asm/perfmon.h>
--#endif
--
- #define IRQ_DEBUG	0
- 
- #define IRQ_VECTOR_UNASSIGNED	(0)
-@@ -660,9 +656,6 @@ init_IRQ (void)
- 	}
- #endif
- #endif
--#ifdef CONFIG_PERFMON
--	pfm_init_percpu();
--#endif
- 	platform_irq_init();
- }
- 
-diff --git a/arch/ia64/kernel/perfmon_default_smpl.c b/arch/ia64/kernel/perfmon_default_smpl.c
-deleted file mode 100644
-index 5f637bb..0000000
---- a/arch/ia64/kernel/perfmon_default_smpl.c
-+++ /dev/null
-@@ -1,296 +0,0 @@
--/*
-- * Copyright (C) 2002-2003 Hewlett-Packard Co
-- *               Stephane Eranian <eranian@hpl.hp.com>
-- *
-- * This file implements the default sampling buffer format
-- * for the Linux/ia64 perfmon-2 subsystem.
-- */
--#include <linux/kernel.h>
--#include <linux/types.h>
--#include <linux/module.h>
--#include <linux/init.h>
--#include <asm/delay.h>
--#include <linux/smp.h>
--
--#include <asm/perfmon.h>
--#include <asm/perfmon_default_smpl.h>
--
--MODULE_AUTHOR("Stephane Eranian <eranian@hpl.hp.com>");
--MODULE_DESCRIPTION("perfmon default sampling format");
--MODULE_LICENSE("GPL");
--
--#define DEFAULT_DEBUG 1
--
--#ifdef DEFAULT_DEBUG
--#define DPRINT(a) \
--	do { \
--		if (unlikely(pfm_sysctl.debug >0)) { printk("%s.%d: CPU%d ", __func__, __LINE__, smp_processor_id()); printk a; } \
--	} while (0)
--
--#define DPRINT_ovfl(a) \
--	do { \
--		if (unlikely(pfm_sysctl.debug > 0 && pfm_sysctl.debug_ovfl >0)) { printk("%s.%d: CPU%d ", __func__, __LINE__, smp_processor_id()); printk a; } \
--	} while (0)
--
--#else
--#define DPRINT(a)
--#define DPRINT_ovfl(a)
--#endif
--
--static int
--default_validate(struct task_struct *task, unsigned int flags, int cpu, void *data)
--{
--	pfm_default_smpl_arg_t *arg = (pfm_default_smpl_arg_t*)data;
--	int ret = 0;
--
--	if (data == NULL) {
--		DPRINT(("[%d] no argument passed\n", task_pid_nr(task)));
--		return -EINVAL;
--	}
--
--	DPRINT(("[%d] validate flags=0x%x CPU%d\n", task_pid_nr(task), flags, cpu));
--
--	/*
--	 * must hold at least the buffer header + one minimally sized entry
--	 */
--	if (arg->buf_size < PFM_DEFAULT_SMPL_MIN_BUF_SIZE) return -EINVAL;
--
--	DPRINT(("buf_size=%lu\n", arg->buf_size));
--
--	return ret;
--}
--
--static int
--default_get_size(struct task_struct *task, unsigned int flags, int cpu, void *data, unsigned long *size)
--{
--	pfm_default_smpl_arg_t *arg = (pfm_default_smpl_arg_t *)data;
--
--	/*
--	 * size has been validated in default_validate
--	 */
--	*size = arg->buf_size;
--
--	return 0;
--}
--
--static int
--default_init(struct task_struct *task, void *buf, unsigned int flags, int cpu, void *data)
--{
--	pfm_default_smpl_hdr_t *hdr;
--	pfm_default_smpl_arg_t *arg = (pfm_default_smpl_arg_t *)data;
--
--	hdr = (pfm_default_smpl_hdr_t *)buf;
--
--	hdr->hdr_version      = PFM_DEFAULT_SMPL_VERSION;
--	hdr->hdr_buf_size     = arg->buf_size;
--	hdr->hdr_cur_offs     = sizeof(*hdr);
--	hdr->hdr_overflows    = 0UL;
--	hdr->hdr_count        = 0UL;
--
--	DPRINT(("[%d] buffer=%p buf_size=%lu hdr_size=%lu hdr_version=%u cur_offs=%lu\n",
--		task_pid_nr(task),
--		buf,
--		hdr->hdr_buf_size,
--		sizeof(*hdr),
--		hdr->hdr_version,
--		hdr->hdr_cur_offs));
--
--	return 0;
--}
--
--static int
--default_handler(struct task_struct *task, void *buf, pfm_ovfl_arg_t *arg, struct pt_regs *regs, unsigned long stamp)
--{
--	pfm_default_smpl_hdr_t *hdr;
--	pfm_default_smpl_entry_t *ent;
--	void *cur, *last;
--	unsigned long *e, entry_size;
--	unsigned int npmds, i;
--	unsigned char ovfl_pmd;
--	unsigned char ovfl_notify;
--
--	if (unlikely(buf == NULL || arg == NULL|| regs == NULL || task == NULL)) {
--		DPRINT(("[%d] invalid arguments buf=%p arg=%p\n", task->pid, buf, arg));
--		return -EINVAL;
--	}
--
--	hdr         = (pfm_default_smpl_hdr_t *)buf;
--	cur         = buf+hdr->hdr_cur_offs;
--	last        = buf+hdr->hdr_buf_size;
--	ovfl_pmd    = arg->ovfl_pmd;
--	ovfl_notify = arg->ovfl_notify;
--
--	/*
--	 * precheck for sanity
--	 */
--	if ((last - cur) < PFM_DEFAULT_MAX_ENTRY_SIZE) goto full;
--
--	npmds = hweight64(arg->smpl_pmds[0]);
--
--	ent = (pfm_default_smpl_entry_t *)cur;
--
--	prefetch(arg->smpl_pmds_values);
--
--	entry_size = sizeof(*ent) + (npmds << 3);
--
--	/* position for first pmd */
--	e = (unsigned long *)(ent+1);
--
--	hdr->hdr_count++;
--
--	DPRINT_ovfl(("[%d] count=%lu cur=%p last=%p free_bytes=%lu ovfl_pmd=%d ovfl_notify=%d npmds=%u\n",
--			task->pid,
--			hdr->hdr_count,
--			cur, last,
--			last-cur,
--			ovfl_pmd,
--			ovfl_notify, npmds));
--
--	/*
--	 * current = task running at the time of the overflow.
--	 *
--	 * per-task mode:
--	 * 	- this is ususally the task being monitored.
--	 * 	  Under certain conditions, it might be a different task
--	 *
--	 * system-wide:
--	 * 	- this is not necessarily the task controlling the session
--	 */
--	ent->pid            = current->pid;
--	ent->ovfl_pmd  	    = ovfl_pmd;
--	ent->last_reset_val = arg->pmd_last_reset; //pmd[0].reg_last_reset_val;
--
--	/*
--	 * where did the fault happen (includes slot number)
--	 */
--	ent->ip = regs->cr_iip | ((regs->cr_ipsr >> 41) & 0x3);
--
--	ent->tstamp    = stamp;
--	ent->cpu       = smp_processor_id();
--	ent->set       = arg->active_set;
--	ent->tgid      = current->tgid;
--
--	/*
--	 * selectively store PMDs in increasing index number
--	 */
--	if (npmds) {
--		unsigned long *val = arg->smpl_pmds_values;
--		for(i=0; i < npmds; i++) {
--			*e++ = *val++;
--		}
--	}
--
--	/*
--	 * update position for next entry
--	 */
--	hdr->hdr_cur_offs += entry_size;
--	cur               += entry_size;
--
--	/*
--	 * post check to avoid losing the last sample
--	 */
--	if ((last - cur) < PFM_DEFAULT_MAX_ENTRY_SIZE) goto full;
--
--	/*
--	 * keep same ovfl_pmds, ovfl_notify
--	 */
--	arg->ovfl_ctrl.bits.notify_user     = 0;
--	arg->ovfl_ctrl.bits.block_task      = 0;
--	arg->ovfl_ctrl.bits.mask_monitoring = 0;
--	arg->ovfl_ctrl.bits.reset_ovfl_pmds = 1; /* reset before returning from interrupt handler */
--
--	return 0;
--full:
--	DPRINT_ovfl(("sampling buffer full free=%lu, count=%lu, ovfl_notify=%d\n", last-cur, hdr->hdr_count, ovfl_notify));
--
--	/*
--	 * increment number of buffer overflow.
--	 * important to detect duplicate set of samples.
--	 */
--	hdr->hdr_overflows++;
--
--	/*
--	 * if no notification requested, then we saturate the buffer
--	 */
--	if (ovfl_notify == 0) {
--		arg->ovfl_ctrl.bits.notify_user     = 0;
--		arg->ovfl_ctrl.bits.block_task      = 0;
--		arg->ovfl_ctrl.bits.mask_monitoring = 1;
--		arg->ovfl_ctrl.bits.reset_ovfl_pmds = 0;
--	} else {
--		arg->ovfl_ctrl.bits.notify_user     = 1;
--		arg->ovfl_ctrl.bits.block_task      = 1; /* ignored for non-blocking context */
--		arg->ovfl_ctrl.bits.mask_monitoring = 1;
--		arg->ovfl_ctrl.bits.reset_ovfl_pmds = 0; /* no reset now */
--	}
--	return -1; /* we are full, sorry */
--}
--
--static int
--default_restart(struct task_struct *task, pfm_ovfl_ctrl_t *ctrl, void *buf, struct pt_regs *regs)
--{
--	pfm_default_smpl_hdr_t *hdr;
--
--	hdr = (pfm_default_smpl_hdr_t *)buf;
--
--	hdr->hdr_count    = 0UL;
--	hdr->hdr_cur_offs = sizeof(*hdr);
--
--	ctrl->bits.mask_monitoring = 0;
--	ctrl->bits.reset_ovfl_pmds = 1; /* uses long-reset values */
--
--	return 0;
--}
--
--static int
--default_exit(struct task_struct *task, void *buf, struct pt_regs *regs)
--{
--	DPRINT(("[%d] exit(%p)\n", task_pid_nr(task), buf));
--	return 0;
--}
--
--static pfm_buffer_fmt_t default_fmt={
-- 	.fmt_name 	    = "default_format",
-- 	.fmt_uuid	    = PFM_DEFAULT_SMPL_UUID,
-- 	.fmt_arg_size	    = sizeof(pfm_default_smpl_arg_t),
-- 	.fmt_validate	    = default_validate,
-- 	.fmt_getsize	    = default_get_size,
-- 	.fmt_init	    = default_init,
-- 	.fmt_handler	    = default_handler,
-- 	.fmt_restart	    = default_restart,
-- 	.fmt_restart_active = default_restart,
-- 	.fmt_exit	    = default_exit,
--};
--
--static int __init
--pfm_default_smpl_init_module(void)
--{
--	int ret;
--
--	ret = pfm_register_buffer_fmt(&default_fmt);
--	if (ret == 0) {
--		printk("perfmon_default_smpl: %s v%u.%u registered\n",
--			default_fmt.fmt_name,
--			PFM_DEFAULT_SMPL_VERSION_MAJ,
--			PFM_DEFAULT_SMPL_VERSION_MIN);
--	} else {
--		printk("perfmon_default_smpl: %s cannot register ret=%d\n",
--			default_fmt.fmt_name,
--			ret);
--	}
--
--	return ret;
--}
--
--static void __exit
--pfm_default_smpl_cleanup_module(void)
--{
--	int ret;
--	ret = pfm_unregister_buffer_fmt(default_fmt.fmt_uuid);
--
--	printk("perfmon_default_smpl: unregister %s=%d\n", default_fmt.fmt_name, ret);
--}
--
--module_init(pfm_default_smpl_init_module);
--module_exit(pfm_default_smpl_cleanup_module);
--
-diff --git a/arch/ia64/kernel/perfmon_generic.h b/arch/ia64/kernel/perfmon_generic.h
-deleted file mode 100644
-index 6748947..0000000
---- a/arch/ia64/kernel/perfmon_generic.h
-+++ /dev/null
-@@ -1,45 +0,0 @@
--/*
-- * This file contains the generic PMU register description tables
-- * and pmc checker used by perfmon.c.
-- *
-- * Copyright (C) 2002-2003  Hewlett Packard Co
-- *               Stephane Eranian <eranian@hpl.hp.com>
-- */
--
--static pfm_reg_desc_t pfm_gen_pmc_desc[PMU_MAX_PMCS]={
--/* pmc0  */ { PFM_REG_CONTROL , 0, 0x1UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc1  */ { PFM_REG_CONTROL , 0, 0x0UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc2  */ { PFM_REG_CONTROL , 0, 0x0UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc3  */ { PFM_REG_CONTROL , 0, 0x0UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc4  */ { PFM_REG_COUNTING, 0, 0x0UL, -1UL, NULL, NULL, {RDEP(4),0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc5  */ { PFM_REG_COUNTING, 0, 0x0UL, -1UL, NULL, NULL, {RDEP(5),0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc6  */ { PFM_REG_COUNTING, 0, 0x0UL, -1UL, NULL, NULL, {RDEP(6),0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc7  */ { PFM_REG_COUNTING, 0, 0x0UL, -1UL, NULL, NULL, {RDEP(7),0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--	    { PFM_REG_END     , 0, 0x0UL, -1UL, NULL, NULL, {0,}, {0,}}, /* end marker */
--};
--
--static pfm_reg_desc_t pfm_gen_pmd_desc[PMU_MAX_PMDS]={
--/* pmd0  */ { PFM_REG_NOTIMPL , 0, 0x0UL, -1UL, NULL, NULL, {0,}, {0,}},
--/* pmd1  */ { PFM_REG_NOTIMPL , 0, 0x0UL, -1UL, NULL, NULL, {0,}, {0,}},
--/* pmd2  */ { PFM_REG_NOTIMPL , 0, 0x0UL, -1UL, NULL, NULL, {0,}, {0,}},
--/* pmd3  */ { PFM_REG_NOTIMPL , 0, 0x0UL, -1UL, NULL, NULL, {0,}, {0,}},
--/* pmd4  */ { PFM_REG_COUNTING, 0, 0x0UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {RDEP(4),0UL, 0UL, 0UL}},
--/* pmd5  */ { PFM_REG_COUNTING, 0, 0x0UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {RDEP(5),0UL, 0UL, 0UL}},
--/* pmd6  */ { PFM_REG_COUNTING, 0, 0x0UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {RDEP(6),0UL, 0UL, 0UL}},
--/* pmd7  */ { PFM_REG_COUNTING, 0, 0x0UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {RDEP(7),0UL, 0UL, 0UL}},
--	    { PFM_REG_END     , 0, 0x0UL, -1UL, NULL, NULL, {0,}, {0,}}, /* end marker */
--};
--
--/*
-- * impl_pmcs, impl_pmds are computed at runtime to minimize errors!
-- */
--static pmu_config_t pmu_conf_gen={
--	.pmu_name   = "Generic",
--	.pmu_family = 0xff, /* any */
--	.ovfl_val   = (1UL << 32) - 1,
--	.num_ibrs   = 0, /* does not use */
--	.num_dbrs   = 0, /* does not use */
--	.pmd_desc   = pfm_gen_pmd_desc,
--	.pmc_desc   = pfm_gen_pmc_desc
--};
--
-diff --git a/arch/ia64/kernel/perfmon_itanium.h b/arch/ia64/kernel/perfmon_itanium.h
-deleted file mode 100644
-index d1d508a..0000000
---- a/arch/ia64/kernel/perfmon_itanium.h
-+++ /dev/null
-@@ -1,115 +0,0 @@
--/*
-- * This file contains the Itanium PMU register description tables
-- * and pmc checker used by perfmon.c.
-- *
-- * Copyright (C) 2002-2003  Hewlett Packard Co
-- *               Stephane Eranian <eranian@hpl.hp.com>
-- */
--static int pfm_ita_pmc_check(struct task_struct *task, pfm_context_t *ctx, unsigned int cnum, unsigned long *val, struct pt_regs *regs);
--
--static pfm_reg_desc_t pfm_ita_pmc_desc[PMU_MAX_PMCS]={
--/* pmc0  */ { PFM_REG_CONTROL , 0, 0x1UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc1  */ { PFM_REG_CONTROL , 0, 0x0UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc2  */ { PFM_REG_CONTROL , 0, 0x0UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc3  */ { PFM_REG_CONTROL , 0, 0x0UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc4  */ { PFM_REG_COUNTING, 6, 0x0UL, -1UL, NULL, NULL, {RDEP(4),0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc5  */ { PFM_REG_COUNTING, 6, 0x0UL, -1UL, NULL, NULL, {RDEP(5),0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc6  */ { PFM_REG_COUNTING, 6, 0x0UL, -1UL, NULL, NULL, {RDEP(6),0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc7  */ { PFM_REG_COUNTING, 6, 0x0UL, -1UL, NULL, NULL, {RDEP(7),0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc8  */ { PFM_REG_CONFIG  , 0, 0xf00000003ffffff8UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc9  */ { PFM_REG_CONFIG  , 0, 0xf00000003ffffff8UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc10 */ { PFM_REG_MONITOR , 6, 0x0UL, -1UL, NULL, NULL, {RDEP(0)|RDEP(1),0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc11 */ { PFM_REG_MONITOR , 6, 0x0000000010000000UL, -1UL, NULL, pfm_ita_pmc_check, {RDEP(2)|RDEP(3)|RDEP(17),0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc12 */ { PFM_REG_MONITOR , 6, 0x0UL, -1UL, NULL, NULL, {RDEP(8)|RDEP(9)|RDEP(10)|RDEP(11)|RDEP(12)|RDEP(13)|RDEP(14)|RDEP(15)|RDEP(16),0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc13 */ { PFM_REG_CONFIG  , 0, 0x0003ffff00000001UL, -1UL, NULL, pfm_ita_pmc_check, {0UL,0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--	    { PFM_REG_END     , 0, 0x0UL, -1UL, NULL, NULL, {0,}, {0,}}, /* end marker */
--};
--
--static pfm_reg_desc_t pfm_ita_pmd_desc[PMU_MAX_PMDS]={
--/* pmd0  */ { PFM_REG_BUFFER  , 0, 0UL, -1UL, NULL, NULL, {RDEP(1),0UL, 0UL, 0UL}, {RDEP(10),0UL, 0UL, 0UL}},
--/* pmd1  */ { PFM_REG_BUFFER  , 0, 0UL, -1UL, NULL, NULL, {RDEP(0),0UL, 0UL, 0UL}, {RDEP(10),0UL, 0UL, 0UL}},
--/* pmd2  */ { PFM_REG_BUFFER  , 0, 0UL, -1UL, NULL, NULL, {RDEP(3)|RDEP(17),0UL, 0UL, 0UL}, {RDEP(11),0UL, 0UL, 0UL}},
--/* pmd3  */ { PFM_REG_BUFFER  , 0, 0UL, -1UL, NULL, NULL, {RDEP(2)|RDEP(17),0UL, 0UL, 0UL}, {RDEP(11),0UL, 0UL, 0UL}},
--/* pmd4  */ { PFM_REG_COUNTING, 0, 0UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {RDEP(4),0UL, 0UL, 0UL}},
--/* pmd5  */ { PFM_REG_COUNTING, 0, 0UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {RDEP(5),0UL, 0UL, 0UL}},
--/* pmd6  */ { PFM_REG_COUNTING, 0, 0UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {RDEP(6),0UL, 0UL, 0UL}},
--/* pmd7  */ { PFM_REG_COUNTING, 0, 0UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {RDEP(7),0UL, 0UL, 0UL}},
--/* pmd8  */ { PFM_REG_BUFFER  , 0, 0UL, -1UL, NULL, NULL, {RDEP(9)|RDEP(10)|RDEP(11)|RDEP(12)|RDEP(13)|RDEP(14)|RDEP(15)|RDEP(16),0UL, 0UL, 0UL}, {RDEP(12),0UL, 0UL, 0UL}},
--/* pmd9  */ { PFM_REG_BUFFER  , 0, 0UL, -1UL, NULL, NULL, {RDEP(8)|RDEP(10)|RDEP(11)|RDEP(12)|RDEP(13)|RDEP(14)|RDEP(15)|RDEP(16),0UL, 0UL, 0UL}, {RDEP(12),0UL, 0UL, 0UL}},
--/* pmd10 */ { PFM_REG_BUFFER  , 0, 0UL, -1UL, NULL, NULL, {RDEP(8)|RDEP(9)|RDEP(11)|RDEP(12)|RDEP(13)|RDEP(14)|RDEP(15)|RDEP(16),0UL, 0UL, 0UL}, {RDEP(12),0UL, 0UL, 0UL}},
--/* pmd11 */ { PFM_REG_BUFFER  , 0, 0UL, -1UL, NULL, NULL, {RDEP(8)|RDEP(9)|RDEP(10)|RDEP(12)|RDEP(13)|RDEP(14)|RDEP(15)|RDEP(16),0UL, 0UL, 0UL}, {RDEP(12),0UL, 0UL, 0UL}},
--/* pmd12 */ { PFM_REG_BUFFER  , 0, 0UL, -1UL, NULL, NULL, {RDEP(8)|RDEP(9)|RDEP(10)|RDEP(11)|RDEP(13)|RDEP(14)|RDEP(15)|RDEP(16),0UL, 0UL, 0UL}, {RDEP(12),0UL, 0UL, 0UL}},
--/* pmd13 */ { PFM_REG_BUFFER  , 0, 0UL, -1UL, NULL, NULL, {RDEP(8)|RDEP(9)|RDEP(10)|RDEP(11)|RDEP(12)|RDEP(14)|RDEP(15)|RDEP(16),0UL, 0UL, 0UL}, {RDEP(12),0UL, 0UL, 0UL}},
--/* pmd14 */ { PFM_REG_BUFFER  , 0, 0UL, -1UL, NULL, NULL, {RDEP(8)|RDEP(9)|RDEP(10)|RDEP(11)|RDEP(12)|RDEP(13)|RDEP(15)|RDEP(16),0UL, 0UL, 0UL}, {RDEP(12),0UL, 0UL, 0UL}},
--/* pmd15 */ { PFM_REG_BUFFER  , 0, 0UL, -1UL, NULL, NULL, {RDEP(8)|RDEP(9)|RDEP(10)|RDEP(11)|RDEP(12)|RDEP(13)|RDEP(14)|RDEP(16),0UL, 0UL, 0UL}, {RDEP(12),0UL, 0UL, 0UL}},
--/* pmd16 */ { PFM_REG_BUFFER  , 0, 0UL, -1UL, NULL, NULL, {RDEP(8)|RDEP(9)|RDEP(10)|RDEP(11)|RDEP(12)|RDEP(13)|RDEP(14)|RDEP(15),0UL, 0UL, 0UL}, {RDEP(12),0UL, 0UL, 0UL}},
--/* pmd17 */ { PFM_REG_BUFFER  , 0, 0UL, -1UL, NULL, NULL, {RDEP(2)|RDEP(3),0UL, 0UL, 0UL}, {RDEP(11),0UL, 0UL, 0UL}},
--	    { PFM_REG_END     , 0, 0UL, -1UL, NULL, NULL, {0,}, {0,}}, /* end marker */
--};
--
--static int
--pfm_ita_pmc_check(struct task_struct *task, pfm_context_t *ctx, unsigned int cnum, unsigned long *val, struct pt_regs *regs)
--{
--	int ret;
--	int is_loaded;
--
--	/* sanitfy check */
--	if (ctx == NULL) return -EINVAL;
--
--	is_loaded = ctx->ctx_state == PFM_CTX_LOADED || ctx->ctx_state == PFM_CTX_MASKED;
--
--	/*
--	 * we must clear the (instruction) debug registers if pmc13.ta bit is cleared
--	 * before they are written (fl_using_dbreg==0) to avoid picking up stale information.
--	 */
--	if (cnum == 13 && is_loaded && ((*val & 0x1) == 0UL) && ctx->ctx_fl_using_dbreg == 0) {
--
--		DPRINT(("pmc[%d]=0x%lx has active pmc13.ta cleared, clearing ibr\n", cnum, *val));
--
--		/* don't mix debug with perfmon */
--		if (task && (task->thread.flags & IA64_THREAD_DBG_VALID) != 0) return -EINVAL;
--
--		/*
--		 * a count of 0 will mark the debug registers as in use and also
--		 * ensure that they are properly cleared.
--		 */
--		ret = pfm_write_ibr_dbr(1, ctx, NULL, 0, regs);
--		if (ret) return ret;
--	}
--
--	/*
--	 * we must clear the (data) debug registers if pmc11.pt bit is cleared
--	 * before they are written (fl_using_dbreg==0) to avoid picking up stale information.
--	 */
--	if (cnum == 11 && is_loaded && ((*val >> 28)& 0x1) == 0 && ctx->ctx_fl_using_dbreg == 0) {
--
--		DPRINT(("pmc[%d]=0x%lx has active pmc11.pt cleared, clearing dbr\n", cnum, *val));
--
--		/* don't mix debug with perfmon */
--		if (task && (task->thread.flags & IA64_THREAD_DBG_VALID) != 0) return -EINVAL;
--
--		/*
--		 * a count of 0 will mark the debug registers as in use and also
--		 * ensure that they are properly cleared.
--		 */
--		ret = pfm_write_ibr_dbr(0, ctx, NULL, 0, regs);
--		if (ret) return ret;
--	}
--	return 0;
--}
--
--/*
-- * impl_pmcs, impl_pmds are computed at runtime to minimize errors!
-- */
--static pmu_config_t pmu_conf_ita={
--	.pmu_name      = "Itanium",
--	.pmu_family    = 0x7,
--	.ovfl_val      = (1UL << 32) - 1,
--	.pmd_desc      = pfm_ita_pmd_desc,
--	.pmc_desc      = pfm_ita_pmc_desc,
--	.num_ibrs      = 8,
--	.num_dbrs      = 8,
--	.use_rr_dbregs = 1, /* debug register are use for range retrictions */
--};
--
--
-diff --git a/arch/ia64/kernel/perfmon_mckinley.h b/arch/ia64/kernel/perfmon_mckinley.h
-deleted file mode 100644
-index c4bec7a..0000000
---- a/arch/ia64/kernel/perfmon_mckinley.h
-+++ /dev/null
-@@ -1,187 +0,0 @@
--/*
-- * This file contains the McKinley PMU register description tables
-- * and pmc checker used by perfmon.c.
-- *
-- * Copyright (C) 2002-2003  Hewlett Packard Co
-- *               Stephane Eranian <eranian@hpl.hp.com>
-- */
--static int pfm_mck_pmc_check(struct task_struct *task, pfm_context_t *ctx, unsigned int cnum, unsigned long *val, struct pt_regs *regs);
--
--static pfm_reg_desc_t pfm_mck_pmc_desc[PMU_MAX_PMCS]={
--/* pmc0  */ { PFM_REG_CONTROL , 0, 0x1UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc1  */ { PFM_REG_CONTROL , 0, 0x0UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc2  */ { PFM_REG_CONTROL , 0, 0x0UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc3  */ { PFM_REG_CONTROL , 0, 0x0UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc4  */ { PFM_REG_COUNTING, 6, 0x0000000000800000UL, 0xfffff7fUL, NULL, pfm_mck_pmc_check, {RDEP(4),0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc5  */ { PFM_REG_COUNTING, 6, 0x0UL, 0xfffff7fUL, NULL,  pfm_mck_pmc_check, {RDEP(5),0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc6  */ { PFM_REG_COUNTING, 6, 0x0UL, 0xfffff7fUL, NULL,  pfm_mck_pmc_check, {RDEP(6),0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc7  */ { PFM_REG_COUNTING, 6, 0x0UL, 0xfffff7fUL, NULL,  pfm_mck_pmc_check, {RDEP(7),0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc8  */ { PFM_REG_CONFIG  , 0, 0xffffffff3fffffffUL, 0xffffffff3ffffffbUL, NULL, pfm_mck_pmc_check, {0UL,0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc9  */ { PFM_REG_CONFIG  , 0, 0xffffffff3ffffffcUL, 0xffffffff3ffffffbUL, NULL, pfm_mck_pmc_check, {0UL,0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc10 */ { PFM_REG_MONITOR , 4, 0x0UL, 0xffffUL, NULL, pfm_mck_pmc_check, {RDEP(0)|RDEP(1),0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc11 */ { PFM_REG_MONITOR , 6, 0x0UL, 0x30f01cf, NULL,  pfm_mck_pmc_check, {RDEP(2)|RDEP(3)|RDEP(17),0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc12 */ { PFM_REG_MONITOR , 6, 0x0UL, 0xffffUL, NULL,  pfm_mck_pmc_check, {RDEP(8)|RDEP(9)|RDEP(10)|RDEP(11)|RDEP(12)|RDEP(13)|RDEP(14)|RDEP(15)|RDEP(16),0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc13 */ { PFM_REG_CONFIG  , 0, 0x00002078fefefefeUL, 0x1e00018181818UL, NULL, pfm_mck_pmc_check, {0UL,0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc14 */ { PFM_REG_CONFIG  , 0, 0x0db60db60db60db6UL, 0x2492UL, NULL, pfm_mck_pmc_check, {0UL,0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--/* pmc15 */ { PFM_REG_CONFIG  , 0, 0x00000000fffffff0UL, 0xfUL, NULL, pfm_mck_pmc_check, {0UL,0UL, 0UL, 0UL}, {0UL,0UL, 0UL, 0UL}},
--	    { PFM_REG_END     , 0, 0x0UL, -1UL, NULL, NULL, {0,}, {0,}}, /* end marker */
--};
--
--static pfm_reg_desc_t pfm_mck_pmd_desc[PMU_MAX_PMDS]={
--/* pmd0  */ { PFM_REG_BUFFER  , 0, 0x0UL, -1UL, NULL, NULL, {RDEP(1),0UL, 0UL, 0UL}, {RDEP(10),0UL, 0UL, 0UL}},
--/* pmd1  */ { PFM_REG_BUFFER  , 0, 0x0UL, -1UL, NULL, NULL, {RDEP(0),0UL, 0UL, 0UL}, {RDEP(10),0UL, 0UL, 0UL}},
--/* pmd2  */ { PFM_REG_BUFFER  , 0, 0x0UL, -1UL, NULL, NULL, {RDEP(3)|RDEP(17),0UL, 0UL, 0UL}, {RDEP(11),0UL, 0UL, 0UL}},
--/* pmd3  */ { PFM_REG_BUFFER  , 0, 0x0UL, -1UL, NULL, NULL, {RDEP(2)|RDEP(17),0UL, 0UL, 0UL}, {RDEP(11),0UL, 0UL, 0UL}},
--/* pmd4  */ { PFM_REG_COUNTING, 0, 0x0UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {RDEP(4),0UL, 0UL, 0UL}},
--/* pmd5  */ { PFM_REG_COUNTING, 0, 0x0UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {RDEP(5),0UL, 0UL, 0UL}},
--/* pmd6  */ { PFM_REG_COUNTING, 0, 0x0UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {RDEP(6),0UL, 0UL, 0UL}},
--/* pmd7  */ { PFM_REG_COUNTING, 0, 0x0UL, -1UL, NULL, NULL, {0UL,0UL, 0UL, 0UL}, {RDEP(7),0UL, 0UL, 0UL}},
--/* pmd8  */ { PFM_REG_BUFFER  , 0, 0x0UL, -1UL, NULL, NULL, {RDEP(9)|RDEP(10)|RDEP(11)|RDEP(12)|RDEP(13)|RDEP(14)|RDEP(15)|RDEP(16),0UL, 0UL, 0UL}, {RDEP(12),0UL, 0UL, 0UL}},
--/* pmd9  */ { PFM_REG_BUFFER  , 0, 0x0UL, -1UL, NULL, NULL, {RDEP(8)|RDEP(10)|RDEP(11)|RDEP(12)|RDEP(13)|RDEP(14)|RDEP(15)|RDEP(16),0UL, 0UL, 0UL}, {RDEP(12),0UL, 0UL, 0UL}},
--/* pmd10 */ { PFM_REG_BUFFER  , 0, 0x0UL, -1UL, NULL, NULL, {RDEP(8)|RDEP(9)|RDEP(11)|RDEP(12)|RDEP(13)|RDEP(14)|RDEP(15)|RDEP(16),0UL, 0UL, 0UL}, {RDEP(12),0UL, 0UL, 0UL}},
--/* pmd11 */ { PFM_REG_BUFFER  , 0, 0x0UL, -1UL, NULL, NULL, {RDEP(8)|RDEP(9)|RDEP(10)|RDEP(12)|RDEP(13)|RDEP(14)|RDEP(15)|RDEP(16),0UL, 0UL, 0UL}, {RDEP(12),0UL, 0UL, 0UL}},
--/* pmd12 */ { PFM_REG_BUFFER  , 0, 0x0UL, -1UL, NULL, NULL, {RDEP(8)|RDEP(9)|RDEP(10)|RDEP(11)|RDEP(13)|RDEP(14)|RDEP(15)|RDEP(16),0UL, 0UL, 0UL}, {RDEP(12),0UL, 0UL, 0UL}},
--/* pmd13 */ { PFM_REG_BUFFER  , 0, 0x0UL, -1UL, NULL, NULL, {RDEP(8)|RDEP(9)|RDEP(10)|RDEP(11)|RDEP(12)|RDEP(14)|RDEP(15)|RDEP(16),0UL, 0UL, 0UL}, {RDEP(12),0UL, 0UL, 0UL}},
--/* pmd14 */ { PFM_REG_BUFFER  , 0, 0x0UL, -1UL, NULL, NULL, {RDEP(8)|RDEP(9)|RDEP(10)|RDEP(11)|RDEP(12)|RDEP(13)|RDEP(15)|RDEP(16),0UL, 0UL, 0UL}, {RDEP(12),0UL, 0UL, 0UL}},
--/* pmd15 */ { PFM_REG_BUFFER  , 0, 0x0UL, -1UL, NULL, NULL, {RDEP(8)|RDEP(9)|RDEP(10)|RDEP(11)|RDEP(12)|RDEP(13)|RDEP(14)|RDEP(16),0UL, 0UL, 0UL}, {RDEP(12),0UL, 0UL, 0UL}},
--/* pmd16 */ { PFM_REG_BUFFER  , 0, 0x0UL, -1UL, NULL, NULL, {RDEP(8)|RDEP(9)|RDEP(10)|RDEP(11)|RDEP(12)|RDEP(13)|RDEP(14)|RDEP(15),0UL, 0UL, 0UL}, {RDEP(12),0UL, 0UL, 0UL}},
--/* pmd17 */ { PFM_REG_BUFFER  , 0, 0x0UL, -1UL, NULL, NULL, {RDEP(2)|RDEP(3),0UL, 0UL, 0UL}, {RDEP(11),0UL, 0UL, 0UL}},
--	    { PFM_REG_END     , 0, 0x0UL, -1UL, NULL, NULL, {0,}, {0,}}, /* end marker */
--};
--
--/*
-- * PMC reserved fields must have their power-up values preserved
-- */
--static int
--pfm_mck_reserved(unsigned int cnum, unsigned long *val, struct pt_regs *regs)
--{
--	unsigned long tmp1, tmp2, ival = *val;
--
--	/* remove reserved areas from user value */
--	tmp1 = ival & PMC_RSVD_MASK(cnum);
--
--	/* get reserved fields values */
--	tmp2 = PMC_DFL_VAL(cnum) & ~PMC_RSVD_MASK(cnum);
--
--	*val = tmp1 | tmp2;
--
--	DPRINT(("pmc[%d]=0x%lx, mask=0x%lx, reset=0x%lx, val=0x%lx\n",
--		  cnum, ival, PMC_RSVD_MASK(cnum), PMC_DFL_VAL(cnum), *val));
--	return 0;
--}
--
--/*
-- * task can be NULL if the context is unloaded
-- */
--static int
--pfm_mck_pmc_check(struct task_struct *task, pfm_context_t *ctx, unsigned int cnum, unsigned long *val, struct pt_regs *regs)
--{
--	int ret = 0, check_case1 = 0;
--	unsigned long val8 = 0, val14 = 0, val13 = 0;
--	int is_loaded;
--
--	/* first preserve the reserved fields */
--	pfm_mck_reserved(cnum, val, regs);
--
--	/* sanitfy check */
--	if (ctx == NULL) return -EINVAL;
--
--	is_loaded = ctx->ctx_state == PFM_CTX_LOADED || ctx->ctx_state == PFM_CTX_MASKED;
--
--	/*
--	 * we must clear the debug registers if pmc13 has a value which enable
--	 * memory pipeline event constraints. In this case we need to clear the
--	 * the debug registers if they have not yet been accessed. This is required
--	 * to avoid picking stale state.
--	 * PMC13 is "active" if:
--	 * 	one of the pmc13.cfg_dbrpXX field is different from 0x3
--	 * AND
--	 * 	at the corresponding pmc13.ena_dbrpXX is set.
--	 */
--	DPRINT(("cnum=%u val=0x%lx, using_dbreg=%d loaded=%d\n", cnum, *val, ctx->ctx_fl_using_dbreg, is_loaded));
--
--	if (cnum == 13 && is_loaded
--	    && (*val & 0x1e00000000000UL) && (*val & 0x18181818UL) != 0x18181818UL && ctx->ctx_fl_using_dbreg == 0) {
--
--		DPRINT(("pmc[%d]=0x%lx has active pmc13 settings, clearing dbr\n", cnum, *val));
--
--		/* don't mix debug with perfmon */
--		if (task && (task->thread.flags & IA64_THREAD_DBG_VALID) != 0) return -EINVAL;
--
--		/*
--		 * a count of 0 will mark the debug registers as in use and also
--		 * ensure that they are properly cleared.
--		 */
--		ret = pfm_write_ibr_dbr(PFM_DATA_RR, ctx, NULL, 0, regs);
--		if (ret) return ret;
--	}
--	/*
--	 * we must clear the (instruction) debug registers if any pmc14.ibrpX bit is enabled
--	 * before they are (fl_using_dbreg==0) to avoid picking up stale information.
--	 */
--	if (cnum == 14 && is_loaded && ((*val & 0x2222UL) != 0x2222UL) && ctx->ctx_fl_using_dbreg == 0) {
--
--		DPRINT(("pmc[%d]=0x%lx has active pmc14 settings, clearing ibr\n", cnum, *val));
--
--		/* don't mix debug with perfmon */
--		if (task && (task->thread.flags & IA64_THREAD_DBG_VALID) != 0) return -EINVAL;
--
--		/*
--		 * a count of 0 will mark the debug registers as in use and also
--		 * ensure that they are properly cleared.
--		 */
--		ret = pfm_write_ibr_dbr(PFM_CODE_RR, ctx, NULL, 0, regs);
--		if (ret) return ret;
--
--	}
--
--	switch(cnum) {
--		case  4: *val |= 1UL << 23; /* force power enable bit */
--			 break;
--		case  8: val8 = *val;
--			 val13 = ctx->ctx_pmcs[13];
--			 val14 = ctx->ctx_pmcs[14];
--			 check_case1 = 1;
--			 break;
--		case 13: val8  = ctx->ctx_pmcs[8];
--			 val13 = *val;
--			 val14 = ctx->ctx_pmcs[14];
--			 check_case1 = 1;
--			 break;
--		case 14: val8  = ctx->ctx_pmcs[8];
--			 val13 = ctx->ctx_pmcs[13];
--			 val14 = *val;
--			 check_case1 = 1;
--			 break;
--	}
--	/* check illegal configuration which can produce inconsistencies in tagging
--	 * i-side events in L1D and L2 caches
--	 */
--	if (check_case1) {
--		ret =   ((val13 >> 45) & 0xf) == 0
--		   && ((val8 & 0x1) == 0)
--		   && ((((val14>>1) & 0x3) == 0x2 || ((val14>>1) & 0x3) == 0x0)
--		       ||(((val14>>4) & 0x3) == 0x2 || ((val14>>4) & 0x3) == 0x0));
--
--		if (ret) DPRINT((KERN_DEBUG "perfmon: failure check_case1\n"));
--	}
--
--	return ret ? -EINVAL : 0;
--}
--
--/*
-- * impl_pmcs, impl_pmds are computed at runtime to minimize errors!
-- */
--static pmu_config_t pmu_conf_mck={
--	.pmu_name      = "Itanium 2",
--	.pmu_family    = 0x1f,
--	.flags	       = PFM_PMU_IRQ_RESEND,
--	.ovfl_val      = (1UL << 47) - 1,
--	.pmd_desc      = pfm_mck_pmd_desc,
--	.pmc_desc      = pfm_mck_pmc_desc,
--	.num_ibrs       = 8,
--	.num_dbrs       = 8,
--	.use_rr_dbregs = 1 /* debug register are use for range restrictions */
--};
--
--
-diff --git a/arch/ia64/kernel/perfmon_montecito.h b/arch/ia64/kernel/perfmon_montecito.h
-deleted file mode 100644
-index 7f8da4c..0000000
---- a/arch/ia64/kernel/perfmon_montecito.h
-+++ /dev/null
-@@ -1,269 +0,0 @@
--/*
-- * This file contains the Montecito PMU register description tables
-- * and pmc checker used by perfmon.c.
-- *
-- * Copyright (c) 2005-2006 Hewlett-Packard Development Company, L.P.
-- *               Contributed by Stephane Eranian <eranian@hpl.hp.com>
-- */
--static int pfm_mont_pmc_check(struct task_struct *task, pfm_context_t *ctx, unsigned int cnum, unsigned long *val, struct pt_regs *regs);
--
--#define RDEP_MONT_ETB	(RDEP(38)|RDEP(39)|RDEP(48)|RDEP(49)|RDEP(50)|RDEP(51)|RDEP(52)|RDEP(53)|RDEP(54)|\
--			 RDEP(55)|RDEP(56)|RDEP(57)|RDEP(58)|RDEP(59)|RDEP(60)|RDEP(61)|RDEP(62)|RDEP(63))
--#define RDEP_MONT_DEAR  (RDEP(32)|RDEP(33)|RDEP(36))
--#define RDEP_MONT_IEAR  (RDEP(34)|RDEP(35))
--
--static pfm_reg_desc_t pfm_mont_pmc_desc[PMU_MAX_PMCS]={
--/* pmc0  */ { PFM_REG_CONTROL , 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {0,0, 0, 0}},
--/* pmc1  */ { PFM_REG_CONTROL , 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {0,0, 0, 0}},
--/* pmc2  */ { PFM_REG_CONTROL , 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {0,0, 0, 0}},
--/* pmc3  */ { PFM_REG_CONTROL , 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {0,0, 0, 0}},
--/* pmc4  */ { PFM_REG_COUNTING, 6, 0x2000000, 0x7c7fff7f, NULL, pfm_mont_pmc_check, {RDEP(4),0, 0, 0}, {0,0, 0, 0}},
--/* pmc5  */ { PFM_REG_COUNTING, 6, 0x2000000, 0x7c7fff7f, NULL, pfm_mont_pmc_check, {RDEP(5),0, 0, 0}, {0,0, 0, 0}},
--/* pmc6  */ { PFM_REG_COUNTING, 6, 0x2000000, 0x7c7fff7f, NULL, pfm_mont_pmc_check, {RDEP(6),0, 0, 0}, {0,0, 0, 0}},
--/* pmc7  */ { PFM_REG_COUNTING, 6, 0x2000000, 0x7c7fff7f, NULL, pfm_mont_pmc_check, {RDEP(7),0, 0, 0}, {0,0, 0, 0}},
--/* pmc8  */ { PFM_REG_COUNTING, 6, 0x2000000, 0x7c7fff7f, NULL, pfm_mont_pmc_check, {RDEP(8),0, 0, 0}, {0,0, 0, 0}},
--/* pmc9  */ { PFM_REG_COUNTING, 6, 0x2000000, 0x7c7fff7f, NULL, pfm_mont_pmc_check, {RDEP(9),0, 0, 0}, {0,0, 0, 0}},
--/* pmc10 */ { PFM_REG_COUNTING, 6, 0x2000000, 0x7c7fff7f, NULL, pfm_mont_pmc_check, {RDEP(10),0, 0, 0}, {0,0, 0, 0}},
--/* pmc11 */ { PFM_REG_COUNTING, 6, 0x2000000, 0x7c7fff7f, NULL, pfm_mont_pmc_check, {RDEP(11),0, 0, 0}, {0,0, 0, 0}},
--/* pmc12 */ { PFM_REG_COUNTING, 6, 0x2000000, 0x7c7fff7f, NULL, pfm_mont_pmc_check, {RDEP(12),0, 0, 0}, {0,0, 0, 0}},
--/* pmc13 */ { PFM_REG_COUNTING, 6, 0x2000000, 0x7c7fff7f, NULL, pfm_mont_pmc_check, {RDEP(13),0, 0, 0}, {0,0, 0, 0}},
--/* pmc14 */ { PFM_REG_COUNTING, 6, 0x2000000, 0x7c7fff7f, NULL, pfm_mont_pmc_check, {RDEP(14),0, 0, 0}, {0,0, 0, 0}},
--/* pmc15 */ { PFM_REG_COUNTING, 6, 0x2000000, 0x7c7fff7f, NULL, pfm_mont_pmc_check, {RDEP(15),0, 0, 0}, {0,0, 0, 0}},
--/* pmc16 */ { PFM_REG_NOTIMPL, },
--/* pmc17 */ { PFM_REG_NOTIMPL, },
--/* pmc18 */ { PFM_REG_NOTIMPL, },
--/* pmc19 */ { PFM_REG_NOTIMPL, },
--/* pmc20 */ { PFM_REG_NOTIMPL, },
--/* pmc21 */ { PFM_REG_NOTIMPL, },
--/* pmc22 */ { PFM_REG_NOTIMPL, },
--/* pmc23 */ { PFM_REG_NOTIMPL, },
--/* pmc24 */ { PFM_REG_NOTIMPL, },
--/* pmc25 */ { PFM_REG_NOTIMPL, },
--/* pmc26 */ { PFM_REG_NOTIMPL, },
--/* pmc27 */ { PFM_REG_NOTIMPL, },
--/* pmc28 */ { PFM_REG_NOTIMPL, },
--/* pmc29 */ { PFM_REG_NOTIMPL, },
--/* pmc30 */ { PFM_REG_NOTIMPL, },
--/* pmc31 */ { PFM_REG_NOTIMPL, },
--/* pmc32 */ { PFM_REG_CONFIG,  0, 0x30f01ffffffffffUL, 0x30f01ffffffffffUL, NULL, pfm_mont_pmc_check, {0,0, 0, 0}, {0,0, 0, 0}},
--/* pmc33 */ { PFM_REG_CONFIG,  0, 0x0,  0x1ffffffffffUL, NULL, pfm_mont_pmc_check, {0,0, 0, 0}, {0,0, 0, 0}},
--/* pmc34 */ { PFM_REG_CONFIG,  0, 0xf01ffffffffffUL, 0xf01ffffffffffUL, NULL, pfm_mont_pmc_check, {0,0, 0, 0}, {0,0, 0, 0}},
--/* pmc35 */ { PFM_REG_CONFIG,  0, 0x0,  0x1ffffffffffUL, NULL, pfm_mont_pmc_check, {0,0, 0, 0}, {0,0, 0, 0}},
--/* pmc36 */ { PFM_REG_CONFIG,  0, 0xfffffff0, 0xf, NULL, pfm_mont_pmc_check, {0,0, 0, 0}, {0,0, 0, 0}},
--/* pmc37 */ { PFM_REG_MONITOR, 4, 0x0, 0x3fff, NULL, pfm_mont_pmc_check, {RDEP_MONT_IEAR, 0, 0, 0}, {0, 0, 0, 0}},
--/* pmc38 */ { PFM_REG_CONFIG,  0, 0xdb6, 0x2492, NULL, pfm_mont_pmc_check, {0,0, 0, 0}, {0,0, 0, 0}},
--/* pmc39 */ { PFM_REG_MONITOR, 6, 0x0, 0xffcf, NULL, pfm_mont_pmc_check, {RDEP_MONT_ETB,0, 0, 0}, {0,0, 0, 0}},
--/* pmc40 */ { PFM_REG_MONITOR, 6, 0x2000000, 0xf01cf, NULL, pfm_mont_pmc_check, {RDEP_MONT_DEAR,0, 0, 0}, {0,0, 0, 0}},
--/* pmc41 */ { PFM_REG_CONFIG,  0, 0x00002078fefefefeUL, 0x1e00018181818UL, NULL, pfm_mont_pmc_check, {0,0, 0, 0}, {0,0, 0, 0}},
--/* pmc42 */ { PFM_REG_MONITOR, 6, 0x0, 0x7ff4f, NULL, pfm_mont_pmc_check, {RDEP_MONT_ETB,0, 0, 0}, {0,0, 0, 0}},
--	    { PFM_REG_END    , 0, 0x0, -1, NULL, NULL, {0,}, {0,}}, /* end marker */
--};
--
--static pfm_reg_desc_t pfm_mont_pmd_desc[PMU_MAX_PMDS]={
--/* pmd0  */ { PFM_REG_NOTIMPL, }, 
--/* pmd1  */ { PFM_REG_NOTIMPL, },
--/* pmd2  */ { PFM_REG_NOTIMPL, },
--/* pmd3  */ { PFM_REG_NOTIMPL, },
--/* pmd4  */ { PFM_REG_COUNTING, 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {RDEP(4),0, 0, 0}},
--/* pmd5  */ { PFM_REG_COUNTING, 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {RDEP(5),0, 0, 0}},
--/* pmd6  */ { PFM_REG_COUNTING, 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {RDEP(6),0, 0, 0}},
--/* pmd7  */ { PFM_REG_COUNTING, 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {RDEP(7),0, 0, 0}},
--/* pmd8  */ { PFM_REG_COUNTING, 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {RDEP(8),0, 0, 0}}, 
--/* pmd9  */ { PFM_REG_COUNTING, 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {RDEP(9),0, 0, 0}},
--/* pmd10 */ { PFM_REG_COUNTING, 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {RDEP(10),0, 0, 0}},
--/* pmd11 */ { PFM_REG_COUNTING, 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {RDEP(11),0, 0, 0}},
--/* pmd12 */ { PFM_REG_COUNTING, 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {RDEP(12),0, 0, 0}},
--/* pmd13 */ { PFM_REG_COUNTING, 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {RDEP(13),0, 0, 0}},
--/* pmd14 */ { PFM_REG_COUNTING, 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {RDEP(14),0, 0, 0}},
--/* pmd15 */ { PFM_REG_COUNTING, 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {RDEP(15),0, 0, 0}},
--/* pmd16 */ { PFM_REG_NOTIMPL, },
--/* pmd17 */ { PFM_REG_NOTIMPL, },
--/* pmd18 */ { PFM_REG_NOTIMPL, },
--/* pmd19 */ { PFM_REG_NOTIMPL, },
--/* pmd20 */ { PFM_REG_NOTIMPL, },
--/* pmd21 */ { PFM_REG_NOTIMPL, },
--/* pmd22 */ { PFM_REG_NOTIMPL, },
--/* pmd23 */ { PFM_REG_NOTIMPL, },
--/* pmd24 */ { PFM_REG_NOTIMPL, },
--/* pmd25 */ { PFM_REG_NOTIMPL, },
--/* pmd26 */ { PFM_REG_NOTIMPL, },
--/* pmd27 */ { PFM_REG_NOTIMPL, },
--/* pmd28 */ { PFM_REG_NOTIMPL, },
--/* pmd29 */ { PFM_REG_NOTIMPL, },
--/* pmd30 */ { PFM_REG_NOTIMPL, },
--/* pmd31 */ { PFM_REG_NOTIMPL, },
--/* pmd32 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP(33)|RDEP(36),0, 0, 0}, {RDEP(40),0, 0, 0}},
--/* pmd33 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP(32)|RDEP(36),0, 0, 0}, {RDEP(40),0, 0, 0}},
--/* pmd34 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP(35),0, 0, 0}, {RDEP(37),0, 0, 0}},
--/* pmd35 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP(34),0, 0, 0}, {RDEP(37),0, 0, 0}},
--/* pmd36 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP(32)|RDEP(33),0, 0, 0}, {RDEP(40),0, 0, 0}},
--/* pmd37 */ { PFM_REG_NOTIMPL, },
--/* pmd38 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
--/* pmd39 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
--/* pmd40 */ { PFM_REG_NOTIMPL, },
--/* pmd41 */ { PFM_REG_NOTIMPL, },
--/* pmd42 */ { PFM_REG_NOTIMPL, },
--/* pmd43 */ { PFM_REG_NOTIMPL, },
--/* pmd44 */ { PFM_REG_NOTIMPL, },
--/* pmd45 */ { PFM_REG_NOTIMPL, },
--/* pmd46 */ { PFM_REG_NOTIMPL, },
--/* pmd47 */ { PFM_REG_NOTIMPL, },
--/* pmd48 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
--/* pmd49 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
--/* pmd50 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
--/* pmd51 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
--/* pmd52 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
--/* pmd53 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
--/* pmd54 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
--/* pmd55 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
--/* pmd56 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
--/* pmd57 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
--/* pmd58 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
--/* pmd59 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
--/* pmd60 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
--/* pmd61 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
--/* pmd62 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
--/* pmd63 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
--	    { PFM_REG_END   , 0, 0x0, -1, NULL, NULL, {0,}, {0,}}, /* end marker */
--};
--
--/*
-- * PMC reserved fields must have their power-up values preserved
-- */
--static int
--pfm_mont_reserved(unsigned int cnum, unsigned long *val, struct pt_regs *regs)
--{
--	unsigned long tmp1, tmp2, ival = *val;
--
--	/* remove reserved areas from user value */
--	tmp1 = ival & PMC_RSVD_MASK(cnum);
--
--	/* get reserved fields values */
--	tmp2 = PMC_DFL_VAL(cnum) & ~PMC_RSVD_MASK(cnum);
--
--	*val = tmp1 | tmp2;
--
--	DPRINT(("pmc[%d]=0x%lx, mask=0x%lx, reset=0x%lx, val=0x%lx\n",
--		  cnum, ival, PMC_RSVD_MASK(cnum), PMC_DFL_VAL(cnum), *val));
--	return 0;
--}
--
--/*
-- * task can be NULL if the context is unloaded
-- */
--static int
--pfm_mont_pmc_check(struct task_struct *task, pfm_context_t *ctx, unsigned int cnum, unsigned long *val, struct pt_regs *regs)
--{
--	int ret = 0;
--	unsigned long val32 = 0, val38 = 0, val41 = 0;
--	unsigned long tmpval;
--	int check_case1 = 0;
--	int is_loaded;
--
--	/* first preserve the reserved fields */
--	pfm_mont_reserved(cnum, val, regs);
--
--	tmpval = *val;
--
--	/* sanity check */
--	if (ctx == NULL) return -EINVAL;
--
--	is_loaded = ctx->ctx_state == PFM_CTX_LOADED || ctx->ctx_state == PFM_CTX_MASKED;
--
--	/*
--	 * we must clear the debug registers if pmc41 has a value which enable
--	 * memory pipeline event constraints. In this case we need to clear the
--	 * the debug registers if they have not yet been accessed. This is required
--	 * to avoid picking stale state.
--	 * PMC41 is "active" if:
--	 * 	one of the pmc41.cfg_dtagXX field is different from 0x3
--	 * AND
--	 * 	at the corresponding pmc41.en_dbrpXX is set.
--	 * AND
--	 *	ctx_fl_using_dbreg == 0  (i.e., dbr not yet used)
--	 */
--	DPRINT(("cnum=%u val=0x%lx, using_dbreg=%d loaded=%d\n", cnum, tmpval, ctx->ctx_fl_using_dbreg, is_loaded));
--
--	if (cnum == 41 && is_loaded 
--	    && (tmpval & 0x1e00000000000UL) && (tmpval & 0x18181818UL) != 0x18181818UL && ctx->ctx_fl_using_dbreg == 0) {
--
--		DPRINT(("pmc[%d]=0x%lx has active pmc41 settings, clearing dbr\n", cnum, tmpval));
--
--		/* don't mix debug with perfmon */
--		if (task && (task->thread.flags & IA64_THREAD_DBG_VALID) != 0) return -EINVAL;
--
--		/*
--		 * a count of 0 will mark the debug registers if:
--		 * AND
--		 */
--		ret = pfm_write_ibr_dbr(PFM_DATA_RR, ctx, NULL, 0, regs);
--		if (ret) return ret;
--	}
--	/*
--	 * we must clear the (instruction) debug registers if:
--	 * 	pmc38.ig_ibrpX is 0 (enabled)
--	 * AND
--	 *	ctx_fl_using_dbreg == 0  (i.e., dbr not yet used)
--	 */
--	if (cnum == 38 && is_loaded && ((tmpval & 0x492UL) != 0x492UL) && ctx->ctx_fl_using_dbreg == 0) {
--
--		DPRINT(("pmc38=0x%lx has active pmc38 settings, clearing ibr\n", tmpval));
--
--		/* don't mix debug with perfmon */
--		if (task && (task->thread.flags & IA64_THREAD_DBG_VALID) != 0) return -EINVAL;
--
--		/*
--		 * a count of 0 will mark the debug registers as in use and also
--		 * ensure that they are properly cleared.
--		 */
--		ret = pfm_write_ibr_dbr(PFM_CODE_RR, ctx, NULL, 0, regs);
--		if (ret) return ret;
--
--	}
--	switch(cnum) {
--		case  32: val32 = *val;
--			  val38 = ctx->ctx_pmcs[38];
--			  val41 = ctx->ctx_pmcs[41];
--			  check_case1 = 1;
--			  break;
--		case  38: val38 = *val;
--			  val32 = ctx->ctx_pmcs[32];
--			  val41 = ctx->ctx_pmcs[41];
--			  check_case1 = 1;
--			  break;
--		case  41: val41 = *val;
--			  val32 = ctx->ctx_pmcs[32];
--			  val38 = ctx->ctx_pmcs[38];
--			  check_case1 = 1;
--			  break;
--	}
--	/* check illegal configuration which can produce inconsistencies in tagging
--	 * i-side events in L1D and L2 caches
--	 */
--	if (check_case1) {
--		ret =   (((val41 >> 45) & 0xf) == 0 && ((val32>>57) & 0x1) == 0)
--		     && ((((val38>>1) & 0x3) == 0x2 || ((val38>>1) & 0x3) == 0)
--		     ||  (((val38>>4) & 0x3) == 0x2 || ((val38>>4) & 0x3) == 0));
--		if (ret) {
--			DPRINT(("invalid config pmc38=0x%lx pmc41=0x%lx pmc32=0x%lx\n", val38, val41, val32));
--			return -EINVAL;
--		}
--	}
--	*val = tmpval;
--	return 0;
--}
--
--/*
-- * impl_pmcs, impl_pmds are computed at runtime to minimize errors!
-- */
--static pmu_config_t pmu_conf_mont={
--	.pmu_name        = "Montecito",
--	.pmu_family      = 0x20,
--	.flags           = PFM_PMU_IRQ_RESEND,
--	.ovfl_val        = (1UL << 47) - 1,
--	.pmd_desc        = pfm_mont_pmd_desc,
--	.pmc_desc        = pfm_mont_pmc_desc,
--	.num_ibrs        = 8,
--	.num_dbrs        = 8,
--	.use_rr_dbregs   = 1 /* debug register are use for range retrictions */
--};
-diff --git a/arch/ia64/kernel/process.c b/arch/ia64/kernel/process.c
-index 3ab8373..a7dfb39 100644
---- a/arch/ia64/kernel/process.c
-+++ b/arch/ia64/kernel/process.c
-@@ -28,6 +28,7 @@
- #include <linux/delay.h>
- #include <linux/kdebug.h>
- #include <linux/utsname.h>
-+#include <linux/perfmon_kern.h>
- 
- #include <asm/cpu.h>
- #include <asm/delay.h>
-@@ -45,10 +46,6 @@
- 
- #include "entry.h"
- 
--#ifdef CONFIG_PERFMON
--# include <asm/perfmon.h>
--#endif
--
- #include "sigframe.h"
- 
- void (*ia64_mark_idle)(int);
-@@ -162,10 +159,8 @@ show_regs (struct pt_regs *regs)
- 
- void tsk_clear_notify_resume(struct task_struct *tsk)
- {
--#ifdef CONFIG_PERFMON
--	if (tsk->thread.pfm_needs_checking)
-+	if (test_ti_thread_flag(task_thread_info(tsk), TIF_PERFMON_WORK))
- 		return;
--#endif
- 	if (test_ti_thread_flag(task_thread_info(tsk), TIF_RESTORE_RSE))
- 		return;
- 	clear_ti_thread_flag(task_thread_info(tsk), TIF_NOTIFY_RESUME);
-@@ -188,14 +183,9 @@ do_notify_resume_user(sigset_t *unused, struct sigscratch *scr, long in_syscall)
- 		return;
- 	}
- 
--#ifdef CONFIG_PERFMON
--	if (current->thread.pfm_needs_checking)
--		/*
--		 * Note: pfm_handle_work() allow us to call it with interrupts
--		 * disabled, and may enable interrupts within the function.
--		 */
--		pfm_handle_work();
--#endif
-+	/* process perfmon asynchronous work (e.g. block thread or reset) */
-+	if (test_thread_flag(TIF_PERFMON_WORK))
-+		pfm_handle_work(task_pt_regs(current));
- 
- 	/* deal with pending signal delivery */
- 	if (test_thread_flag(TIF_SIGPENDING)) {
-@@ -212,22 +202,15 @@ do_notify_resume_user(sigset_t *unused, struct sigscratch *scr, long in_syscall)
- 	local_irq_disable();	/* force interrupt disable */
- }
- 
--static int pal_halt        = 1;
- static int can_do_pal_halt = 1;
- 
- static int __init nohalt_setup(char * str)
- {
--	pal_halt = can_do_pal_halt = 0;
-+	can_do_pal_halt = 0;
- 	return 1;
- }
- __setup("nohalt", nohalt_setup);
- 
--void
--update_pal_halt_status(int status)
--{
--	can_do_pal_halt = pal_halt && status;
--}
--
- /*
-  * We use this if we don't have any better idle routine..
-  */
-@@ -236,6 +219,22 @@ default_idle (void)
- {
- 	local_irq_enable();
- 	while (!need_resched()) {
-+#ifdef CONFIG_PERFMON
-+		u64 psr = 0;
-+		/*
-+		 * If requested, we stop the PMU to avoid
-+		 * measuring across the core idle loop.
-+		 *
-+		 * dcr.pp is not modified on purpose
-+		 * it is used when coming out of
-+		 * safe_halt() via interrupt
-+		 */
-+		if ((__get_cpu_var(pfm_syst_info) & PFM_ITA_CPUINFO_IDLE_EXCL)) {
-+			psr = ia64_getreg(_IA64_REG_PSR);
-+			if (psr & IA64_PSR_PP)
-+				ia64_rsm(IA64_PSR_PP);
-+		}
-+#endif
- 		if (can_do_pal_halt) {
- 			local_irq_disable();
- 			if (!need_resched()) {
-@@ -244,6 +243,12 @@ default_idle (void)
- 			local_irq_enable();
- 		} else
- 			cpu_relax();
-+#ifdef CONFIG_PERFMON
-+		if ((__get_cpu_var(pfm_syst_info) & PFM_ITA_CPUINFO_IDLE_EXCL)) {
-+			if (psr & IA64_PSR_PP)
-+				ia64_ssm(IA64_PSR_PP);
-+		}
-+#endif
- 	}
- }
- 
-@@ -344,22 +349,9 @@ cpu_idle (void)
- void
- ia64_save_extra (struct task_struct *task)
- {
--#ifdef CONFIG_PERFMON
--	unsigned long info;
--#endif
--
- 	if ((task->thread.flags & IA64_THREAD_DBG_VALID) != 0)
- 		ia64_save_debug_regs(&task->thread.dbr[0]);
- 
--#ifdef CONFIG_PERFMON
--	if ((task->thread.flags & IA64_THREAD_PM_VALID) != 0)
--		pfm_save_regs(task);
--
--	info = __get_cpu_var(pfm_syst_info);
--	if (info & PFM_CPUINFO_SYST_WIDE)
--		pfm_syst_wide_update_task(task, info, 0);
--#endif
--
- #ifdef CONFIG_IA32_SUPPORT
- 	if (IS_IA32_PROCESS(task_pt_regs(task)))
- 		ia32_save_state(task);
-@@ -369,22 +361,9 @@ ia64_save_extra (struct task_struct *task)
- void
- ia64_load_extra (struct task_struct *task)
- {
--#ifdef CONFIG_PERFMON
--	unsigned long info;
--#endif
--
- 	if ((task->thread.flags & IA64_THREAD_DBG_VALID) != 0)
- 		ia64_load_debug_regs(&task->thread.dbr[0]);
- 
--#ifdef CONFIG_PERFMON
--	if ((task->thread.flags & IA64_THREAD_PM_VALID) != 0)
--		pfm_load_regs(task);
--
--	info = __get_cpu_var(pfm_syst_info);
--	if (info & PFM_CPUINFO_SYST_WIDE) 
--		pfm_syst_wide_update_task(task, info, 1);
--#endif
--
- #ifdef CONFIG_IA32_SUPPORT
- 	if (IS_IA32_PROCESS(task_pt_regs(task)))
- 		ia32_load_state(task);
-@@ -510,8 +489,7 @@ copy_thread (int nr, unsigned long clone_flags,
- 	 * call behavior where scratch registers are preserved across
- 	 * system calls (unless used by the system call itself).
- 	 */
--#	define THREAD_FLAGS_TO_CLEAR	(IA64_THREAD_FPH_VALID | IA64_THREAD_DBG_VALID \
--					 | IA64_THREAD_PM_VALID)
-+#	define THREAD_FLAGS_TO_CLEAR	(IA64_THREAD_FPH_VALID | IA64_THREAD_DBG_VALID)
- #	define THREAD_FLAGS_TO_SET	0
- 	p->thread.flags = ((current->thread.flags & ~THREAD_FLAGS_TO_CLEAR)
- 			   | THREAD_FLAGS_TO_SET);
-@@ -533,10 +511,8 @@ copy_thread (int nr, unsigned long clone_flags,
- 	}
- #endif
- 
--#ifdef CONFIG_PERFMON
--	if (current->thread.pfm_context)
--		pfm_inherit(p, child_ptregs);
--#endif
-+	pfm_copy_thread(p);
-+
- 	return retval;
- }
- 
-@@ -745,15 +721,13 @@ exit_thread (void)
- {
- 
- 	ia64_drop_fpu(current);
--#ifdef CONFIG_PERFMON
--       /* if needed, stop monitoring and flush state to perfmon context */
--	if (current->thread.pfm_context)
--		pfm_exit_thread(current);
-+
-+	/* if needed, stop monitoring and flush state to perfmon context */
-+	pfm_exit_thread();
- 
- 	/* free debug register resources */
--	if (current->thread.flags & IA64_THREAD_DBG_VALID)
--		pfm_release_debug_registers(current);
--#endif
-+	pfm_release_dbregs(current);
-+
- 	if (IS_IA32_PROCESS(task_pt_regs(current)))
- 		ia32_drop_ia64_partial_page_list(current);
- }
-diff --git a/arch/ia64/kernel/ptrace.c b/arch/ia64/kernel/ptrace.c
-index 2a9943b..bb1ca1e 100644
---- a/arch/ia64/kernel/ptrace.c
-+++ b/arch/ia64/kernel/ptrace.c
-@@ -20,6 +20,7 @@
- #include <linux/security.h>
- #include <linux/audit.h>
- #include <linux/signal.h>
-+#include <linux/perfmon_kern.h>
- #include <linux/regset.h>
- #include <linux/elf.h>
- 
-@@ -30,9 +31,6 @@
- #include <asm/system.h>
- #include <asm/uaccess.h>
- #include <asm/unwind.h>
--#ifdef CONFIG_PERFMON
--#include <asm/perfmon.h>
--#endif
- 
- #include "entry.h"
- 
-@@ -2124,7 +2122,6 @@ access_uarea(struct task_struct *child, unsigned long addr,
- 				"address 0x%lx\n", addr);
- 		return -1;
- 	}
--#ifdef CONFIG_PERFMON
- 	/*
- 	 * Check if debug registers are used by perfmon. This
- 	 * test must be done once we know that we can do the
-@@ -2142,9 +2139,8 @@ access_uarea(struct task_struct *child, unsigned long addr,
- 	 * IA64_THREAD_DBG_VALID. The registers are restored
- 	 * by the PMU context switch code.
- 	 */
--	if (pfm_use_debug_registers(child))
-+	if (pfm_use_dbregs(child))
- 		return -1;
--#endif
- 
- 	if (!(child->thread.flags & IA64_THREAD_DBG_VALID)) {
- 		child->thread.flags |= IA64_THREAD_DBG_VALID;
-diff --git a/arch/ia64/kernel/setup.c b/arch/ia64/kernel/setup.c
-index de636b2..677fa68 100644
---- a/arch/ia64/kernel/setup.c
-+++ b/arch/ia64/kernel/setup.c
-@@ -45,6 +45,7 @@
- #include <linux/cpufreq.h>
- #include <linux/kexec.h>
- #include <linux/crash_dump.h>
-+#include <linux/perfmon_kern.h>
- 
- #include <asm/ia32.h>
- #include <asm/machvec.h>
-@@ -1051,6 +1052,8 @@ cpu_init (void)
- 	}
- 	platform_cpu_init();
- 	pm_idle = default_idle;
-+
-+	pfm_init_percpu();
- }
- 
- void __init
-diff --git a/arch/ia64/kernel/smpboot.c b/arch/ia64/kernel/smpboot.c
-index d8f05e5..3d7a739 100644
---- a/arch/ia64/kernel/smpboot.c
-+++ b/arch/ia64/kernel/smpboot.c
-@@ -39,6 +39,7 @@
- #include <linux/efi.h>
- #include <linux/percpu.h>
- #include <linux/bitops.h>
-+#include <linux/perfmon_kern.h>
- 
- #include <asm/atomic.h>
- #include <asm/cache.h>
-@@ -381,10 +382,6 @@ smp_callin (void)
- 	extern void ia64_init_itm(void);
- 	extern volatile int time_keeper_id;
- 
--#ifdef CONFIG_PERFMON
--	extern void pfm_init_percpu(void);
--#endif
--
- 	cpuid = smp_processor_id();
- 	phys_id = hard_smp_processor_id();
- 	itc_master = time_keeper_id;
-@@ -410,10 +407,6 @@ smp_callin (void)
- 
- 	ia64_mca_cmc_vector_setup();	/* Setup vector on AP */
- 
--#ifdef CONFIG_PERFMON
--	pfm_init_percpu();
--#endif
--
- 	local_irq_enable();
- 
- 	if (!(sal_platform_features & IA64_SAL_PLATFORM_FEATURE_ITC_DRIFT)) {
-@@ -751,6 +744,7 @@ int __cpu_disable(void)
- 	cpu_clear(cpu, cpu_online_map);
- 	local_flush_tlb_all();
- 	cpu_clear(cpu, cpu_callin_map);
-+	pfm_cpu_disable();
- 	return 0;
- }
- 
-diff --git a/arch/ia64/kernel/sys_ia64.c b/arch/ia64/kernel/sys_ia64.c
-index bcbb6d8..a0ed33a 100644
---- a/arch/ia64/kernel/sys_ia64.c
-+++ b/arch/ia64/kernel/sys_ia64.c
-@@ -284,3 +284,11 @@ sys_pciconfig_write (unsigned long bus, unsigned long dfn, unsigned long off, un
- }
- 
- #endif /* CONFIG_PCI */
-+
-+#ifndef CONFIG_IA64_PERFMON_COMPAT
-+asmlinkage long
-+sys_perfmonctl (int fd, int cmd, void __user *arg, int count)
-+{
-+	return -ENOSYS;
-+}
-+#endif
-diff --git a/arch/ia64/lib/Makefile b/arch/ia64/lib/Makefile
-index 98771e2..077fd09 100644
---- a/arch/ia64/lib/Makefile
-+++ b/arch/ia64/lib/Makefile
-@@ -13,7 +13,6 @@ lib-y := __divsi3.o __udivsi3.o __modsi3.o __umodsi3.o			\
- 
- obj-$(CONFIG_ITANIUM)	+= copy_page.o copy_user.o memcpy.o
- obj-$(CONFIG_MCKINLEY)	+= copy_page_mck.o memcpy_mck.o
--lib-$(CONFIG_PERFMON)	+= carta_random.o
- 
- AFLAGS___divdi3.o	=
- AFLAGS___udivdi3.o	= -DUNSIGNED
-diff --git a/arch/ia64/oprofile/init.c b/arch/ia64/oprofile/init.c
-index 125a602..892de6a 100644
---- a/arch/ia64/oprofile/init.c
-+++ b/arch/ia64/oprofile/init.c
-@@ -12,8 +12,8 @@
- #include <linux/init.h>
- #include <linux/errno.h>
-  
--extern int perfmon_init(struct oprofile_operations * ops);
--extern void perfmon_exit(void);
-+extern int op_perfmon_init(struct oprofile_operations * ops);
-+extern void op_perfmon_exit(void);
- extern void ia64_backtrace(struct pt_regs * const regs, unsigned int depth);
- 
- int __init oprofile_arch_init(struct oprofile_operations * ops)
-@@ -22,7 +22,7 @@ int __init oprofile_arch_init(struct oprofile_operations * ops)
- 
- #ifdef CONFIG_PERFMON
- 	/* perfmon_init() can fail, but we have no way to report it */
--	ret = perfmon_init(ops);
-+	ret = op_perfmon_init(ops);
- #endif
- 	ops->backtrace = ia64_backtrace;
- 
-@@ -33,6 +33,6 @@ int __init oprofile_arch_init(struct oprofile_operations * ops)
- void oprofile_arch_exit(void)
- {
- #ifdef CONFIG_PERFMON
--	perfmon_exit();
-+	op_perfmon_exit();
- #endif
- }
-diff --git a/arch/ia64/oprofile/perfmon.c b/arch/ia64/oprofile/perfmon.c
-index bc41dd3..6fa9d17 100644
---- a/arch/ia64/oprofile/perfmon.c
-+++ b/arch/ia64/oprofile/perfmon.c
-@@ -10,25 +10,30 @@
- #include <linux/kernel.h>
- #include <linux/oprofile.h>
- #include <linux/sched.h>
--#include <asm/perfmon.h>
-+#include <linux/module.h>
-+#include <linux/perfmon_kern.h>
- #include <asm/ptrace.h>
- #include <asm/errno.h>
- 
- static int allow_ints;
- 
- static int
--perfmon_handler(struct task_struct *task, void *buf, pfm_ovfl_arg_t *arg,
--                struct pt_regs *regs, unsigned long stamp)
-+perfmon_handler(struct pfm_context *ctx,
-+		unsigned long ip, u64 stamp, void *data)
- {
--	int event = arg->pmd_eventid;
-+	struct pt_regs *regs;
-+	struct pfm_ovfl_arg *arg;
-+
-+ 	regs = data;
-+	arg = &ctx->ovfl_arg;
-  
--	arg->ovfl_ctrl.bits.reset_ovfl_pmds = 1;
-+	arg->ovfl_ctrl = PFM_OVFL_CTRL_RESET;
- 
- 	/* the owner of the oprofile event buffer may have exited
- 	 * without perfmon being shutdown (e.g. SIGSEGV)
- 	 */
- 	if (allow_ints)
--		oprofile_add_sample(regs, event);
-+		oprofile_add_sample(regs, arg->pmd_eventid);
- 	return 0;
- }
- 
-@@ -45,17 +50,13 @@ static void perfmon_stop(void)
- 	allow_ints = 0;
- }
- 
--
--#define OPROFILE_FMT_UUID { \
--	0x77, 0x7a, 0x6e, 0x61, 0x20, 0x65, 0x73, 0x69, 0x74, 0x6e, 0x72, 0x20, 0x61, 0x65, 0x0a, 0x6c }
--
--static pfm_buffer_fmt_t oprofile_fmt = {
-- 	.fmt_name 	    = "oprofile_format",
-- 	.fmt_uuid	    = OPROFILE_FMT_UUID,
-- 	.fmt_handler	    = perfmon_handler,
-+static struct pfm_smpl_fmt oprofile_fmt = {
-+	.fmt_name = "OProfile",
-+	.fmt_handler = perfmon_handler,
-+	.fmt_flags = PFM_FMT_BUILTIN_FLAG,
-+	.owner = THIS_MODULE
- };
- 
--
- static char * get_cpu_type(void)
- {
- 	__u8 family = local_cpu_data->family;
-@@ -75,9 +76,9 @@ static char * get_cpu_type(void)
- 
- static int using_perfmon;
- 
--int perfmon_init(struct oprofile_operations * ops)
-+int __init op_perfmon_init(struct oprofile_operations * ops)
- {
--	int ret = pfm_register_buffer_fmt(&oprofile_fmt);
-+	int ret = pfm_fmt_register(&oprofile_fmt);
- 	if (ret)
- 		return -ENODEV;
- 
-@@ -90,10 +91,10 @@ int perfmon_init(struct oprofile_operations * ops)
- }
- 
- 
--void perfmon_exit(void)
-+void __exit op_perfmon_exit(void)
- {
- 	if (!using_perfmon)
- 		return;
- 
--	pfm_unregister_buffer_fmt(oprofile_fmt.fmt_uuid);
-+	pfm_fmt_unregister(&oprofile_fmt);
- }
-diff --git a/arch/ia64/perfmon/Kconfig b/arch/ia64/perfmon/Kconfig
-new file mode 100644
-index 0000000..99c68bd
---- /dev/null
-+++ b/arch/ia64/perfmon/Kconfig
-@@ -0,0 +1,67 @@
-+menu "Hardware Performance Monitoring support"
-+config PERFMON
-+	bool "Perfmon2 performance monitoring interface"
-+	default n
-+	help
-+	Enables the perfmon2 interface to access the hardware
-+	performance counters. See <http://perfmon2.sf.net/> for
-+	more details.
-+
-+config PERFMON_DEBUG
-+	bool "Perfmon debugging"
-+	default n
-+	depends on PERFMON
-+	help
-+	Enables perfmon debugging support
-+
-+config PERFMON_DEBUG_FS
-+	bool "Enable perfmon statistics reporting via debugfs"
-+	default y
-+	depends on PERFMON && DEBUG_FS
-+	help
-+	Enable collection and reporting of perfmon timing statistics under
-+	debugfs. This is used for debugging and performance analysis of the
-+	subsystem. The debugfs filesystem must be mounted.
-+
-+config IA64_PERFMON_COMPAT
-+	bool "Enable old perfmon-2 compatbility mode"
-+	default n
-+	depends on PERFMON
-+	help
-+	Enable this option to allow performance tools which used the old
-+	perfmon-2 interface to continue to work. Old tools are those using
-+	the obsolete commands and arguments. Check your programs and look
-+	in include/asm-ia64/perfmon_compat.h for more information.
-+
-+config IA64_PERFMON_GENERIC
-+	tristate "Generic IA-64 PMU support"
-+	depends on PERFMON
-+	default n
-+	help
-+	Enables generic IA-64 PMU support.
-+	The generic PMU is defined by the IA-64 architecture document.
-+	This option should only be necessary when running with a PMU that
-+	is not yet explicitely supported. Even then, there is no guarantee
-+	that this support will work.
-+
-+config IA64_PERFMON_ITANIUM
-+	tristate "Itanium (Merced) Performance Monitoring support"
-+	depends on PERFMON
-+	default n
-+	help
-+	Enables Itanium (Merced) PMU support.
-+
-+config IA64_PERFMON_MCKINLEY
-+	tristate "Itanium 2 (McKinley) Performance Monitoring  support"
-+	depends on PERFMON
-+	default n
-+	help
-+	Enables Itanium 2 (McKinley, Madison, Deerfield) PMU support.
-+
-+config IA64_PERFMON_MONTECITO
-+	tristate "Itanium 2 9000 (Montecito) Performance Monitoring  support"
-+	depends on PERFMON
-+	default n
-+	help
-+	Enables support for Itanium 2 9000 (Montecito) PMU.
-+endmenu
-diff --git a/arch/ia64/perfmon/Makefile b/arch/ia64/perfmon/Makefile
-new file mode 100644
-index 0000000..c9cdf9f
---- /dev/null
-+++ b/arch/ia64/perfmon/Makefile
-@@ -0,0 +1,11 @@
-+#
-+# Copyright (c) 2005-2006 Hewlett-Packard Development Company, L.P.
-+# Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+#
-+obj-$(CONFIG_PERFMON)			+= perfmon.o
-+obj-$(CONFIG_IA64_PERFMON_COMPAT)	+= perfmon_default_smpl.o \
-+					   perfmon_compat.o
-+obj-$(CONFIG_IA64_PERFMON_GENERIC)	+= perfmon_generic.o
-+obj-$(CONFIG_IA64_PERFMON_ITANIUM)	+= perfmon_itanium.o
-+obj-$(CONFIG_IA64_PERFMON_MCKINLEY)	+= perfmon_mckinley.o
-+obj-$(CONFIG_IA64_PERFMON_MONTECITO)	+= perfmon_montecito.o
-diff --git a/arch/ia64/perfmon/perfmon.c b/arch/ia64/perfmon/perfmon.c
-new file mode 100644
-index 0000000..3f59410
---- /dev/null
-+++ b/arch/ia64/perfmon/perfmon.c
-@@ -0,0 +1,946 @@
-+/*
-+ * This file implements the IA-64 specific
-+ * support for the perfmon2 interface
-+ *
-+ * Copyright (c) 1999-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+  */
-+#include <linux/module.h>
-+#include <linux/perfmon_kern.h>
-+
-+struct pfm_arch_session {
-+	u32	pfs_sys_use_dbr;    /* syswide session uses dbr */
-+	u32	pfs_ptrace_use_dbr; /* a thread uses dbr via ptrace()*/
-+};
-+
-+DEFINE_PER_CPU(u32, pfm_syst_info);
-+
-+static struct pfm_arch_session pfm_arch_sessions;
-+static __cacheline_aligned_in_smp DEFINE_SPINLOCK(pfm_arch_sessions_lock);
-+
-+static inline void pfm_clear_psr_pp(void)
-+{
-+	ia64_rsm(IA64_PSR_PP);
-+}
-+
-+static inline void pfm_set_psr_pp(void)
-+{
-+	ia64_ssm(IA64_PSR_PP);
-+}
-+
-+static inline void pfm_clear_psr_up(void)
-+{
-+	ia64_rsm(IA64_PSR_UP);
-+}
-+
-+static inline void pfm_set_psr_up(void)
-+{
-+	ia64_ssm(IA64_PSR_UP);
-+}
-+
-+static inline void pfm_set_psr_l(u64 val)
-+{
-+	ia64_setreg(_IA64_REG_PSR_L, val);
-+}
-+
-+static inline void pfm_restore_ibrs(u64 *ibrs, unsigned int nibrs)
-+{
-+	unsigned int i;
-+
-+	for (i = 0; i < nibrs; i++) {
-+		ia64_set_ibr(i, ibrs[i]);
-+		ia64_dv_serialize_instruction();
-+	}
-+	ia64_srlz_i();
-+}
-+
-+static inline void pfm_restore_dbrs(u64 *dbrs, unsigned int ndbrs)
-+{
-+	unsigned int i;
-+
-+	for (i = 0; i < ndbrs; i++) {
-+		ia64_set_dbr(i, dbrs[i]);
-+		ia64_dv_serialize_data();
-+	}
-+	ia64_srlz_d();
-+}
-+
-+irqreturn_t pmu_interrupt_handler(int irq, void *arg)
-+{
-+	struct pt_regs *regs;
-+	regs = get_irq_regs();
-+	irq_enter();
-+	pfm_interrupt_handler(instruction_pointer(regs), regs);
-+	irq_exit();
-+	return IRQ_HANDLED;
-+}
-+static struct irqaction perfmon_irqaction = {
-+	.handler = pmu_interrupt_handler,
-+	.flags = IRQF_DISABLED, /* means keep interrupts masked */
-+	.name = "perfmon"
-+};
-+
-+void pfm_arch_quiesce_pmu_percpu(void)
-+{
-+	u64 dcr;
-+	/*
-+	 * make sure no measurement is active
-+	 * (may inherit programmed PMCs from EFI).
-+	 */
-+	pfm_clear_psr_pp();
-+	pfm_clear_psr_up();
-+
-+	/*
-+	 * ensure dcr.pp is cleared
-+	 */
-+	dcr = ia64_getreg(_IA64_REG_CR_DCR);
-+	ia64_setreg(_IA64_REG_CR_DCR, dcr & ~IA64_DCR_PP);
-+
-+	/*
-+	 * we run with the PMU not frozen at all times
-+	 */
-+	ia64_set_pmc(0, 0);
-+	ia64_srlz_d();
-+}
-+
-+void pfm_arch_init_percpu(void)
-+{
-+	pfm_arch_quiesce_pmu_percpu();
-+	/*
-+	 * program PMU interrupt vector
-+	 */
-+	ia64_setreg(_IA64_REG_CR_PMV, IA64_PERFMON_VECTOR);
-+	ia64_srlz_d();
-+}
-+
-+int pfm_arch_context_create(struct pfm_context *ctx, u32 ctx_flags)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+
-+	ctx_arch->flags.use_dbr = 0;
-+	ctx_arch->flags.insecure = (ctx_flags & PFM_ITA_FL_INSECURE) ? 1: 0;
-+
-+	PFM_DBG("insecure=%d", ctx_arch->flags.insecure);
-+
-+	return 0;
-+}
-+
-+/*
-+ * Called from pfm_ctxsw(). Task is guaranteed to be current.
-+ * Context is locked. Interrupts are masked. Monitoring may be active.
-+ * PMU access is guaranteed. PMC and PMD registers are live in PMU.
-+ *
-+ * Return:
-+ * 	non-zero : did not save PMDs (as part of stopping the PMU)
-+ * 	       0 : saved PMDs (no need to save them in caller)
-+ */
-+int pfm_arch_ctxswout_thread(struct task_struct *task, struct pfm_context *ctx)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+	struct pfm_event_set *set;
-+	u64 psr, tmp;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+	set = ctx->active_set;
-+
-+	/*
-+	 * save current PSR: needed because we modify it
-+	 */
-+	ia64_srlz_d();
-+	psr = ia64_getreg(_IA64_REG_PSR);
-+
-+	/*
-+	 * stop monitoring:
-+	 * This is the last instruction which may generate an overflow
-+	 *
-+	 * we do not clear ipsr.up
-+	 */
-+	pfm_clear_psr_up();
-+	ia64_srlz_d();
-+
-+	/*
-+	 * extract overflow status bits
-+	 */
-+	tmp =  ia64_get_pmc(0) & ~0xf;
-+
-+	/*
-+	 * keep a copy of psr.up (for reload)
-+	 */
-+	ctx_arch->ctx_saved_psr_up = psr & IA64_PSR_UP;
-+
-+	/*
-+	 * save overflow status bits
-+	 */
-+	set->povfl_pmds[0] = tmp;
-+
-+	/*
-+	 * record how many pending overflows
-+	 * XXX: assume identity mapping for counters
-+	 */
-+	set->npend_ovfls = ia64_popcnt(tmp);
-+
-+	/*
-+	 * make sure the PMU is unfrozen for the next task
-+	 */
-+	if (set->npend_ovfls) {
-+		ia64_set_pmc(0, 0);
-+		ia64_srlz_d();
-+	}
-+	return 1;
-+}
-+
-+/*
-+ * Called from pfm_ctxsw(). Task is guaranteed to be current.
-+ * set cannot be NULL. Context is locked. Interrupts are masked.
-+ * Caller has already restored all PMD and PMC registers.
-+ *
-+ * must reactivate monitoring
-+ */
-+void pfm_arch_ctxswin_thread(struct task_struct *task, struct pfm_context *ctx)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+
-+	/*
-+	 * when monitoring is not explicitly started
-+	 * then psr_up = 0, in which case we do not
-+	 * need to restore
-+	 */
-+	if (likely(ctx_arch->ctx_saved_psr_up)) {
-+		pfm_set_psr_up();
-+		ia64_srlz_d();
-+	}
-+}
-+
-+int pfm_arch_reserve_session(struct pfm_context *ctx, u32 cpu)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+	int is_system;
-+	int ret = 0;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+	is_system = ctx->flags.system;
-+
-+	spin_lock(&pfm_arch_sessions_lock);
-+
-+	if (is_system && ctx_arch->flags.use_dbr) {
-+		PFM_DBG("syswide context uses dbregs");
-+
-+		if (pfm_arch_sessions.pfs_ptrace_use_dbr) {
-+			PFM_DBG("cannot reserve syswide context: "
-+				  "dbregs in use by ptrace");
-+			ret = -EBUSY;
-+		} else {
-+			pfm_arch_sessions.pfs_sys_use_dbr++;
-+		}
-+	}
-+	spin_unlock(&pfm_arch_sessions_lock);
-+
-+	return ret;
-+}
-+
-+void pfm_arch_release_session(struct pfm_context *ctx, u32 cpu)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+	int is_system;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+	is_system = ctx->flags.system;
-+
-+	spin_lock(&pfm_arch_sessions_lock);
-+
-+	if (is_system && ctx_arch->flags.use_dbr)
-+		pfm_arch_sessions.pfs_sys_use_dbr--;
-+	spin_unlock(&pfm_arch_sessions_lock);
-+}
-+
-+/*
-+ * function called from pfm_load_context_*(). Task is not guaranteed to be
-+ * current task. If not then other task is guaranteed stopped and off any CPU.
-+ * context is locked and interrupts are masked.
-+ *
-+ * On PFM_LOAD_CONTEXT, the interface guarantees monitoring is stopped.
-+ *
-+ * For system-wide task is NULL
-+ */
-+int pfm_arch_load_context(struct pfm_context *ctx)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+	struct pt_regs *regs;
-+	int ret = 0;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+
-+	/*
-+	 * cannot load a context which is using range restrictions,
-+	 * into a thread that is being debugged.
-+	 *
-+	 * if one set out of several is using the debug registers, then
-+	 * we assume the context as whole is using them.
-+	 */
-+	if (ctx_arch->flags.use_dbr) {
-+		if (ctx->flags.system) {
-+			spin_lock(&pfm_arch_sessions_lock);
-+
-+			if (pfm_arch_sessions.pfs_ptrace_use_dbr) {
-+				PFM_DBG("cannot reserve syswide context: "
-+					"dbregs in use by ptrace");
-+				ret = -EBUSY;
-+			} else {
-+				pfm_arch_sessions.pfs_sys_use_dbr++;
-+				PFM_DBG("pfs_sys_use_dbr=%u",
-+					pfm_arch_sessions.pfs_sys_use_dbr);
-+			}
-+			spin_unlock(&pfm_arch_sessions_lock);
-+
-+		} else if (ctx->task->thread.flags & IA64_THREAD_DBG_VALID) {
-+			PFM_DBG("load_pid [%d] thread is debugged, cannot "
-+				  "use range restrictions", ctx->task->pid);
-+			ret = -EBUSY;
-+		}
-+		if (ret)
-+			return ret;
-+	}
-+
-+	/*
-+	 * We need to intervene on context switch to toggle the
-+	 * psr.pp bit in system-wide. As such, we set the TIF
-+	 * flag so that pfm_arch_ctxswout_sys() and the
-+	 * pfm_arch_ctxswin_sys() functions get called
-+	 * from pfm_ctxsw_sys();
-+	 */
-+	if (ctx->flags.system) {
-+		set_thread_flag(TIF_PERFMON_CTXSW);
-+		PFM_DBG("[%d] set TIF", current->pid);
-+		return 0;
-+	}
-+
-+	regs = task_pt_regs(ctx->task);
-+
-+	/*
-+	 * self-monitoring systematically allows user level control
-+	 */
-+	if (ctx->task != current) {
-+		/*
-+		 * when not current, task is stopped, so this is safe
-+		 */
-+		ctx_arch->ctx_saved_psr_up = 0;
-+		ia64_psr(regs)->up = ia64_psr(regs)->pp = 0;
-+	} else
-+		ctx_arch->flags.insecure = 1;
-+
-+	/*
-+	 * allow user level control (start/stop/read pmd) if:
-+	 * 	- self-monitoring
-+	 * 	- requested at context creation (PFM_IA64_FL_INSECURE)
-+	 *
-+	 * There is not security hole with PFM_IA64_FL_INSECURE because
-+	 * when not self-monitored, the caller must have permissions to
-+	 * attached to the task.
-+	 */
-+	if (ctx_arch->flags.insecure) {
-+		ia64_psr(regs)->sp = 0;
-+		PFM_DBG("clearing psr.sp for [%d]", ctx->task->pid);
-+	}
-+	return 0;
-+}
-+
-+int pfm_arch_setfl_sane(struct pfm_context *ctx, u32 flags)
-+{
-+#define PFM_SETFL_BOTH_SWITCH	(PFM_SETFL_OVFL_SWITCH|PFM_SETFL_TIME_SWITCH)
-+#define PFM_ITA_SETFL_BOTH_INTR	(PFM_ITA_SETFL_INTR_ONLY|\
-+				 PFM_ITA_SETFL_EXCL_INTR)
-+
-+/* exclude return value field */
-+#define PFM_SETFL_ALL_MASK	(PFM_ITA_SETFL_BOTH_INTR \
-+				 | PFM_SETFL_BOTH_SWITCH	\
-+				 | PFM_ITA_SETFL_IDLE_EXCL)
-+
-+	if ((flags & ~PFM_SETFL_ALL_MASK)) {
-+		PFM_DBG("invalid flags=0x%x", flags);
-+		return -EINVAL;
-+	}
-+
-+	if ((flags & PFM_ITA_SETFL_BOTH_INTR) == PFM_ITA_SETFL_BOTH_INTR) {
-+		PFM_DBG("both excl intr and ontr only are set");
-+		return -EINVAL;
-+	}
-+
-+	if ((flags & PFM_ITA_SETFL_IDLE_EXCL) && !ctx->flags.system) {
-+		PFM_DBG("idle exclude flag only for system-wide context");
-+		return -EINVAL;
-+	}
-+	return 0;
-+}
-+
-+/*
-+ * function called from pfm_unload_context_*(). Context is locked.
-+ * interrupts are masked. task is not guaranteed to be current task.
-+ * Access to PMU is not guaranteed.
-+ *
-+ * function must do whatever arch-specific action is required on unload
-+ * of a context.
-+ *
-+ * called for both system-wide and per-thread. task is NULL for ssytem-wide
-+ */
-+void pfm_arch_unload_context(struct pfm_context *ctx)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+	struct pt_regs *regs;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+
-+	if (ctx->flags.system) {
-+		/*
-+		 * disable context switch hook
-+		 */
-+		clear_thread_flag(TIF_PERFMON_CTXSW);
-+
-+		if (ctx_arch->flags.use_dbr) {
-+			spin_lock(&pfm_arch_sessions_lock);
-+			pfm_arch_sessions.pfs_sys_use_dbr--;
-+			PFM_DBG("sys_use_dbr=%u", pfm_arch_sessions.pfs_sys_use_dbr);
-+			spin_unlock(&pfm_arch_sessions_lock);
-+		}
-+	} else {
-+		regs = task_pt_regs(ctx->task);
-+
-+		/*
-+		 * cancel user level control for per-task context
-+		 */
-+		ia64_psr(regs)->sp = 1;
-+		PFM_DBG("setting psr.sp for [%d]", ctx->task->pid);
-+	}
-+}
-+
-+/*
-+ * mask monitoring by setting the privilege level to 0
-+ * we cannot use psr.pp/psr.up for this, it is controlled by
-+ * the user
-+ */
-+void pfm_arch_mask_monitoring(struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	struct pfm_arch_pmu_info *arch_info;
-+	unsigned long mask;
-+	unsigned int i;
-+
-+	arch_info = pfm_pmu_info();
-+	/*
-+	 * as an optimization we look at the first 64 PMC
-+	 * registers only starting at PMC4.
-+	 */
-+	mask = arch_info->mask_pmcs[0] >> PFM_ITA_FCNTR;
-+	for (i = PFM_ITA_FCNTR; mask; i++, mask >>= 1) {
-+		if (likely(mask & 0x1))
-+			ia64_set_pmc(i, set->pmcs[i] & ~0xfUL);
-+	}
-+	/*
-+	 * make changes visisble
-+	 */
-+	ia64_srlz_d();
-+}
-+
-+/*
-+ * function called from pfm_switch_sets(), pfm_context_load_thread(),
-+ * pfm_context_load_sys(), pfm_ctxsw(), pfm_switch_sets()
-+ * context is locked. Interrupts are masked. set cannot be NULL.
-+ * Access to the PMU is guaranteed.
-+ *
-+ * function must restore all PMD registers from set.
-+ */
-+void pfm_arch_restore_pmds(struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+	unsigned long *mask;
-+	u16 i, num;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+
-+	if (ctx_arch->flags.insecure) {
-+		num = ctx->regs.num_rw_pmd;
-+		mask = ctx->regs.rw_pmds;
-+	} else {
-+		num = set->nused_pmds;
-+		mask = set->used_pmds;
-+	}
-+	/*
-+	 * must restore all implemented read-write PMDS to avoid leaking
-+	 * information especially when PFM_IA64_FL_INSECURE is set.
-+	 *
-+	 * XXX: should check PFM_IA64_FL_INSECURE==0 and use used_pmd instead
-+	 */
-+	for (i = 0; num; i++) {
-+		if (likely(test_bit(i, mask))) {
-+			pfm_arch_write_pmd(ctx, i, set->pmds[i].value);
-+			num--;
-+		}
-+	}
-+	ia64_srlz_d();
-+}
-+
-+/*
-+ * function called from pfm_switch_sets(), pfm_context_load_thread(),
-+ * pfm_context_load_sys(), pfm_ctxsw(), pfm_switch_sets()
-+ * context is locked. Interrupts are masked. set cannot be NULL.
-+ * Access to the PMU is guaranteed.
-+ *
-+ * function must restore all PMC registers from set if needed
-+ */
-+void pfm_arch_restore_pmcs(struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	struct pfm_arch_pmu_info *arch_info;
-+	u64 mask2 = 0, val, plm;
-+	unsigned long impl_mask, mask_pmcs;
-+	unsigned int i;
-+
-+	arch_info = pfm_pmu_info();
-+	/*
-+	 * as an optimization we only look at the first 64
-+	 * PMC registers. In fact, we should never scan the
-+	 * entire impl_pmcs because ibr/dbr are implemented
-+	 * separately.
-+	 *
-+	 * always skip PMC0-PMC3. PMC0 taken care of when saving
-+	 * state. PMC1-PMC3 not used until we get counters in
-+	 * the 60 and above index range.
-+	 */
-+	impl_mask = ctx->regs.pmcs[0] >> PFM_ITA_FCNTR;
-+	mask_pmcs = arch_info->mask_pmcs[0] >> PFM_ITA_FCNTR;
-+	plm = ctx->state == PFM_CTX_MASKED ? ~0xf : ~0x0;
-+
-+	for (i = PFM_ITA_FCNTR;
-+	     impl_mask;
-+	     i++, impl_mask >>= 1, mask_pmcs >>= 1) {
-+		if (likely(impl_mask & 0x1)) {
-+			mask2 = mask_pmcs & 0x1 ? plm : ~0;
-+			val = set->pmcs[i] & mask2;
-+			ia64_set_pmc(i, val);
-+			PFM_DBG_ovfl("pmc%u=0x%lx", i, val);
-+		}
-+	}
-+	/*
-+	 * restore DBR/IBR
-+	 */
-+	if (set->priv_flags & PFM_ITA_SETFL_USE_DBR) {
-+		pfm_restore_ibrs(set->pmcs+256, 8);
-+		pfm_restore_dbrs(set->pmcs+264, 8);
-+	}
-+	ia64_srlz_d();
-+}
-+
-+void pfm_arch_unmask_monitoring(struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	u64 psr;
-+	int is_system;
-+
-+	is_system = ctx->flags.system;
-+
-+	psr = ia64_getreg(_IA64_REG_PSR);
-+
-+	/*
-+	 * monitoring is masked via the PMC.plm
-+	 *
-+	 * As we restore their value, we do not want each counter to
-+	 * restart right away. We stop monitoring using the PSR,
-+	 * restore the PMC (and PMD) and then re-establish the psr
-+	 * as it was. Note that there can be no pending overflow at
-+	 * this point, because monitoring is still MASKED.
-+	 *
-+	 * Because interrupts are masked we can avoid changing
-+	 * DCR.pp.
-+	 */
-+	if (is_system)
-+		pfm_clear_psr_pp();
-+	else
-+		pfm_clear_psr_up();
-+
-+	ia64_srlz_d();
-+
-+	pfm_arch_restore_pmcs(ctx, set);
-+
-+	/*
-+	 * restore psr
-+	 *
-+	 * monitoring may start right now but interrupts
-+	 * are still masked
-+	 */
-+	pfm_set_psr_l(psr);
-+	ia64_srlz_d();
-+}
-+
-+/*
-+ * Called from pfm_stop()
-+ *
-+ * For per-thread:
-+ *   task is not necessarily current. If not current task, then
-+ *   task is guaranteed stopped and off any cpu. Access to PMU
-+ *   is not guaranteed. Interrupts are masked. Context is locked.
-+ *   Set is the active set.
-+ *
-+ * must disable active monitoring. ctx cannot be NULL
-+ */
-+void pfm_arch_stop(struct task_struct *task, struct pfm_context *ctx)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+	struct pt_regs *regs;
-+	u64 dcr, psr;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+	regs = task_pt_regs(task);
-+
-+	if (!ctx->flags.system) {
-+		/*
-+		 * in ZOMBIE state we always have task == current due to
-+		 * pfm_exit_thread()
-+		 */
-+		ia64_psr(regs)->up = 0;
-+		ctx_arch->ctx_saved_psr_up = 0;
-+
-+		/*
-+		 * in case of ZOMBIE state, there is no unload to clear
-+		 * insecure monitoring, so we do it in stop instead.
-+		 */
-+		if (ctx->state == PFM_CTX_ZOMBIE)
-+			ia64_psr(regs)->sp = 1;
-+
-+		if (task == current) {
-+			pfm_clear_psr_up();
-+			ia64_srlz_d();
-+		}
-+	} else if (ctx->flags.started) { /* do not stop twice */
-+		dcr = ia64_getreg(_IA64_REG_CR_DCR);
-+		psr = ia64_getreg(_IA64_REG_PSR);
-+
-+		ia64_psr(regs)->pp = 0;
-+		ia64_setreg(_IA64_REG_CR_DCR, dcr & ~IA64_DCR_PP);
-+		pfm_clear_psr_pp();
-+		ia64_srlz_d();
-+
-+		if (ctx->active_set->flags & PFM_ITA_SETFL_IDLE_EXCL) {
-+			PFM_DBG("disabling idle exclude");
-+			__get_cpu_var(pfm_syst_info) &= ~PFM_ITA_CPUINFO_IDLE_EXCL;
-+		}
-+	}
-+}
-+
-+/*
-+ * called from pfm_start()
-+ *
-+ * Interrupts are masked. Context is locked. Set is the active set.
-+ *
-+ * For per-thread:
-+ * 	Task is not necessarily current. If not current task, then task
-+ * 	is guaranteed stopped and off any cpu. No access to PMU is task
-+ *	is not current.
-+ *
-+ * For system-wide:
-+ * 	task is always current
-+ *
-+ * must enable active monitoring.
-+ */
-+void pfm_arch_start(struct task_struct *task, struct pfm_context *ctx)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+	struct pt_regs *regs;
-+	u64 dcr, dcr_pp, psr_pp;
-+	u32 flags;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+	regs = task_pt_regs(task);
-+	flags = ctx->active_set->flags;
-+
-+	/*
-+	 * per-thread mode
-+	 */
-+	if (!ctx->flags.system) {
-+
-+		ia64_psr(regs)->up = 1;
-+
-+		if (task == current) {
-+			pfm_set_psr_up();
-+			ia64_srlz_d();
-+		} else {
-+			/*
-+			 * activate monitoring at next ctxswin
-+			 */
-+			ctx_arch->ctx_saved_psr_up = IA64_PSR_UP;
-+		}
-+		return;
-+	}
-+
-+	/*
-+	 * system-wide mode
-+	 */
-+	dcr = ia64_getreg(_IA64_REG_CR_DCR);
-+	if (flags & PFM_ITA_SETFL_INTR_ONLY) {
-+		dcr_pp = 1;
-+		psr_pp = 0;
-+	} else if (flags & PFM_ITA_SETFL_EXCL_INTR) {
-+		dcr_pp = 0;
-+		psr_pp = 1;
-+	} else {
-+		dcr_pp = psr_pp = 1;
-+	}
-+	PFM_DBG("dcr_pp=%lu psr_pp=%lu", dcr_pp, psr_pp);
-+
-+	/*
-+	 * update dcr_pp and psr_pp
-+	 */
-+	if (dcr_pp)
-+		ia64_setreg(_IA64_REG_CR_DCR, dcr | IA64_DCR_PP);
-+	else
-+		ia64_setreg(_IA64_REG_CR_DCR, dcr & ~IA64_DCR_PP);
-+
-+	if (psr_pp) {
-+		pfm_set_psr_pp();
-+		ia64_psr(regs)->pp = 1;
-+	} else {
-+		pfm_clear_psr_pp();
-+		ia64_psr(regs)->pp = 0;
-+	}
-+	ia64_srlz_d();
-+
-+	if (ctx->active_set->flags & PFM_ITA_SETFL_IDLE_EXCL) {
-+		PFM_DBG("enable idle exclude");
-+		__get_cpu_var(pfm_syst_info) |= PFM_ITA_CPUINFO_IDLE_EXCL;
-+	}
-+}
-+
-+/*
-+ * Only call this function when a process is trying to
-+ * write the debug registers (reading is always allowed)
-+ * called from arch/ia64/kernel/ptrace.c:access_uarea()
-+ */
-+int __pfm_use_dbregs(struct task_struct *task)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+	struct pfm_context *ctx;
-+	unsigned long flags;
-+	int ret = 0;
-+
-+	PFM_DBG("called for [%d]", task->pid);
-+
-+	ctx = task->pfm_context;
-+
-+	/*
-+	 * do it only once
-+	 */
-+	if (task->thread.flags & IA64_THREAD_DBG_VALID) {
-+		PFM_DBG("IA64_THREAD_DBG_VALID already set");
-+		return 0;
-+	}
-+	if (ctx) {
-+		spin_lock_irqsave(&ctx->lock, flags);
-+		ctx_arch = pfm_ctx_arch(ctx);
-+
-+		if (ctx_arch->flags.use_dbr == 1) {
-+			PFM_DBG("PMU using dbregs already, no ptrace access");
-+			ret = -1;
-+		}
-+		spin_unlock_irqrestore(&ctx->lock, flags);
-+		if (ret)
-+			return ret;
-+	}
-+
-+	spin_lock(&pfm_arch_sessions_lock);
-+
-+	/*
-+	 * We cannot allow setting breakpoints when system wide monitoring
-+	 * sessions are using the debug registers.
-+	 */
-+	if (!pfm_arch_sessions.pfs_sys_use_dbr)
-+		pfm_arch_sessions.pfs_ptrace_use_dbr++;
-+	else
-+		ret = -1;
-+
-+	PFM_DBG("ptrace_use_dbr=%u  sys_use_dbr=%u by [%d] ret = %d",
-+		  pfm_arch_sessions.pfs_ptrace_use_dbr,
-+		  pfm_arch_sessions.pfs_sys_use_dbr,
-+		  task->pid, ret);
-+
-+	spin_unlock(&pfm_arch_sessions_lock);
-+	if (ret)
-+		return ret;
-+#ifndef CONFIG_SMP
-+	/*
-+	 * in UP, we need to check whether the current
-+	 * owner of the PMU is not using the debug registers
-+	 * for monitoring. Because we are using a lazy
-+	 * save on ctxswout, we must force a save in this
-+	 * case because the debug registers are being
-+	 * modified by another task. We save the current
-+	 * PMD registers, and clear ownership. In ctxswin,
-+	 * full state will be reloaded.
-+	 *
-+	 * Note: we overwrite task.
-+	 */
-+	task = __get_cpu_var(pmu_owner);
-+	ctx = __get_cpu_var(pmu_ctx);
-+
-+	if (task == NULL)
-+		return 0;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+
-+	if (ctx_arch->flags.use_dbr)
-+		pfm_save_pmds_release(ctx);
-+#endif
-+	return 0;
-+}
-+
-+/*
-+ * This function is called for every task that exits with the
-+ * IA64_THREAD_DBG_VALID set. This indicates a task which was
-+ * able to use the debug registers for debugging purposes via
-+ * ptrace(). Therefore we know it was not using them for
-+ * perfmormance monitoring, so we only decrement the number
-+ * of "ptraced" debug register users to keep the count up to date
-+ */
-+int __pfm_release_dbregs(struct task_struct *task)
-+{
-+	int ret;
-+
-+	spin_lock(&pfm_arch_sessions_lock);
-+
-+	if (pfm_arch_sessions.pfs_ptrace_use_dbr == 0) {
-+		PFM_ERR("invalid release for [%d] ptrace_use_dbr=0", task->pid);
-+		ret = -1;
-+	}  else {
-+		pfm_arch_sessions.pfs_ptrace_use_dbr--;
-+		ret = 0;
-+	}
-+	spin_unlock(&pfm_arch_sessions_lock);
-+
-+	return ret;
-+}
-+
-+int pfm_ia64_mark_dbregs_used(struct pfm_context *ctx,
-+			      struct pfm_event_set *set)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+	struct task_struct *task;
-+	struct thread_struct *thread;
-+	int ret = 0, state;
-+	int i, can_access_pmu = 0;
-+	int is_loaded, is_system;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+	state = ctx->state;
-+	task = ctx->task;
-+	is_loaded = state == PFM_CTX_LOADED || state == PFM_CTX_MASKED;
-+	is_system = ctx->flags.system;
-+	can_access_pmu = __get_cpu_var(pmu_owner) == task || is_system;
-+
-+	if (is_loaded == 0)
-+		goto done;
-+
-+	if (is_system == 0) {
-+		thread = &(task->thread);
-+
-+		/*
-+		 * cannot use debug registers for montioring if they are
-+		 * already used for debugging
-+		 */
-+		if (thread->flags & IA64_THREAD_DBG_VALID) {
-+			PFM_DBG("debug registers already in use for [%d]",
-+				  task->pid);
-+			return -EBUSY;
-+		}
-+	}
-+
-+	/*
-+	 * check for debug registers in system wide mode
-+	 */
-+	spin_lock(&pfm_arch_sessions_lock);
-+
-+	if (is_system) {
-+		if (pfm_arch_sessions.pfs_ptrace_use_dbr)
-+			ret = -EBUSY;
-+		else
-+			pfm_arch_sessions.pfs_sys_use_dbr++;
-+	}
-+
-+	spin_unlock(&pfm_arch_sessions_lock);
-+
-+	if (ret != 0)
-+		return ret;
-+
-+	/*
-+	 * clear hardware registers to make sure we don't
-+	 * pick up stale state.
-+	 */
-+	if (can_access_pmu) {
-+		PFM_DBG("clearing ibrs, dbrs");
-+		for (i = 0; i < 8; i++) {
-+			ia64_set_ibr(i, 0);
-+			ia64_dv_serialize_instruction();
-+		}
-+		ia64_srlz_i();
-+		for (i = 0; i < 8; i++) {
-+			ia64_set_dbr(i, 0);
-+			ia64_dv_serialize_data();
-+		}
-+		ia64_srlz_d();
-+	}
-+done:
-+	/*
-+	 * debug registers are now in use
-+	 */
-+	ctx_arch->flags.use_dbr = 1;
-+	set->priv_flags |= PFM_ITA_SETFL_USE_DBR;
-+	PFM_DBG("set%u use_dbr=1", set->id);
-+	return 0;
-+}
-+EXPORT_SYMBOL(pfm_ia64_mark_dbregs_used);
-+
-+char *pfm_arch_get_pmu_module_name(void)
-+{
-+	switch (local_cpu_data->family) {
-+	case 0x07:
-+		return "perfmon_itanium";
-+	case 0x1f:
-+		return "perfmon_mckinley";
-+	case 0x20:
-+		return "perfmon_montecito";
-+	default:
-+		return "perfmon_generic";
-+	}
-+	return NULL;
-+}
-+
-+/*
-+ * global arch-specific intialization, called only once
-+ */
-+int __init pfm_arch_init(void)
-+{
-+	int ret;
-+
-+	spin_lock_init(&pfm_arch_sessions_lock);
-+
-+#ifdef CONFIG_IA64_PERFMON_COMPAT
-+	ret = pfm_ia64_compat_init();
-+	if (ret)
-+		return ret;
-+#endif
-+	register_percpu_irq(IA64_PERFMON_VECTOR, &perfmon_irqaction);
-+
-+
-+	return 0;
-+}
-diff --git a/arch/ia64/perfmon/perfmon_compat.c b/arch/ia64/perfmon/perfmon_compat.c
-new file mode 100644
-index 0000000..2fd3d3c
---- /dev/null
-+++ b/arch/ia64/perfmon/perfmon_compat.c
-@@ -0,0 +1,1210 @@
-+/*
-+ * This file implements the IA-64 specific
-+ * support for the perfmon2 interface
-+ *
-+ * Copyright (c) 1999-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+  */
-+#include <linux/interrupt.h>
-+#include <linux/module.h>
-+#include <linux/file.h>
-+#include <linux/fdtable.h>
-+#include <linux/seq_file.h>
-+#include <linux/vmalloc.h>
-+#include <linux/proc_fs.h>
-+#include <linux/perfmon_kern.h>
-+#include <linux/uaccess.h>
-+
-+asmlinkage long sys_pfm_stop(int fd);
-+asmlinkage long sys_pfm_start(int fd, struct pfarg_start __user *st);
-+asmlinkage long sys_pfm_unload_context(int fd);
-+asmlinkage long sys_pfm_restart(int fd);
-+asmlinkage long sys_pfm_load_context(int fd, struct pfarg_load __user *ld);
-+
-+ssize_t pfm_sysfs_res_show(char *buf, size_t sz, int what);
-+
-+extern ssize_t __pfm_read(struct pfm_context *ctx,
-+			  union pfarg_msg *msg_buf,
-+			  int non_block);
-+/*
-+ * function providing some help for backward compatiblity with old IA-64
-+ * applications. In the old model, certain attributes of a counter were
-+ * passed via the PMC, now they are passed via the PMD.
-+ */
-+static int pfm_compat_update_pmd(struct pfm_context *ctx, u16 set_id, u16 cnum,
-+				 u32 rflags,
-+				 unsigned long *smpl_pmds,
-+				 unsigned long *reset_pmds,
-+				 u64 eventid)
-+{
-+	struct pfm_event_set *set;
-+	int is_counting;
-+	unsigned long *impl_pmds;
-+	u32 flags = 0;
-+	u16 max_pmd;
-+
-+	impl_pmds = ctx->regs.pmds;
-+	max_pmd	= ctx->regs.max_pmd;
-+
-+	/*
-+	 * given that we do not maintain PMC ->PMD dependencies
-+	 * we cannot figure out what to do in case PMCxx != PMDxx
-+	 */
-+	if (cnum > max_pmd)
-+		return 0;
-+
-+	/*
-+	 * assumes PMCxx controls PMDxx which is always true for counters
-+	 * on Itanium PMUs.
-+	 */
-+	is_counting = pfm_pmu_conf->pmd_desc[cnum].type & PFM_REG_C64;
-+	set = pfm_find_set(ctx, set_id, 0);
-+
-+	/*
-+	 * for v2.0, we only allowed counting PMD to generate
-+	 * user-level notifications. Same thing with randomization.
-+	 */
-+	if (is_counting) {
-+		if (rflags & PFM_REGFL_OVFL_NOTIFY)
-+			flags |= PFM_REGFL_OVFL_NOTIFY;
-+		if (rflags & PFM_REGFL_RANDOM)
-+			flags |= PFM_REGFL_RANDOM;
-+		/*
-+		 * verify validity of smpl_pmds
-+		 */
-+		if (unlikely(bitmap_subset(smpl_pmds,
-+					   impl_pmds, max_pmd) == 0)) {
-+			PFM_DBG("invalid smpl_pmds=0x%llx for pmd%u",
-+				  (unsigned long long)smpl_pmds[0], cnum);
-+			return -EINVAL;
-+		}
-+		/*
-+		 * verify validity of reset_pmds
-+		 */
-+		if (unlikely(bitmap_subset(reset_pmds,
-+					   impl_pmds, max_pmd) == 0)) {
-+			PFM_DBG("invalid reset_pmds=0x%lx for pmd%u",
-+				  reset_pmds[0], cnum);
-+			return -EINVAL;
-+		}
-+		/*
-+		 * ensures that a PFM_READ_PMDS succeeds with a
-+		 * corresponding PFM_WRITE_PMDS
-+		 */
-+		__set_bit(cnum, set->used_pmds);
-+
-+	} else if (rflags & (PFM_REGFL_OVFL_NOTIFY|PFM_REGFL_RANDOM)) {
-+		PFM_DBG("cannot set ovfl_notify or random on pmd%u", cnum);
-+		return -EINVAL;
-+	}
-+
-+	set->pmds[cnum].flags = flags;
-+
-+	if (is_counting) {
-+		bitmap_copy(set->pmds[cnum].reset_pmds,
-+			    reset_pmds,
-+			    max_pmd);
-+
-+		bitmap_copy(set->pmds[cnum].smpl_pmds,
-+			    smpl_pmds,
-+			    max_pmd);
-+
-+		set->pmds[cnum].eventid = eventid;
-+
-+		/*
-+		 * update ovfl_notify
-+		 */
-+		if (rflags & PFM_REGFL_OVFL_NOTIFY)
-+			__set_bit(cnum, set->ovfl_notify);
-+		else
-+			__clear_bit(cnum, set->ovfl_notify);
-+
-+	}
-+	PFM_DBG("pmd%u flags=0x%x eventid=0x%lx r_pmds=0x%lx s_pmds=0x%lx",
-+		  cnum, flags,
-+		  eventid,
-+		  reset_pmds[0],
-+		  smpl_pmds[0]);
-+
-+	return 0;
-+}
-+
-+
-+int __pfm_write_ibrs_old(struct pfm_context *ctx, void *arg, int count)
-+{
-+	struct pfarg_dbreg *req = arg;
-+	struct pfarg_pmc pmc;
-+	int i, ret = 0;
-+
-+	memset(&pmc, 0, sizeof(pmc));
-+
-+	for (i = 0; i < count; i++, req++) {
-+		pmc.reg_num   = 256+req->dbreg_num;
-+		pmc.reg_value = req->dbreg_value;
-+		pmc.reg_flags = 0;
-+		pmc.reg_set   = req->dbreg_set;
-+
-+		ret = __pfm_write_pmcs(ctx, &pmc, 1);
-+
-+		req->dbreg_flags &= ~PFM_REG_RETFL_MASK;
-+		req->dbreg_flags |= pmc.reg_flags;
-+
-+		if (ret)
-+			return ret;
-+	}
-+	return 0;
-+}
-+
-+static long pfm_write_ibrs_old(int fd, void __user *ureq, int count)
-+{
-+	struct pfm_context *ctx;
-+	struct task_struct *task;
-+	struct file *filp;
-+	struct pfarg_dbreg *req = NULL;
-+	void *fptr, *resume;
-+	unsigned long flags;
-+	size_t sz;
-+	int ret, fput_needed;
-+
-+	if (count < 1 || count >= PFM_MAX_ARG_COUNT(req))
-+		return -EINVAL;
-+
-+	sz = count*sizeof(*req);
-+
-+	filp = fget_light(fd, &fput_needed);
-+	if (unlikely(filp == NULL)) {
-+		PFM_DBG("invalid fd %d", fd);
-+		return -EBADF;
-+	}
-+
-+	ctx = filp->private_data;
-+	ret = -EBADF;
-+
-+	if (unlikely(!ctx || filp->f_op != &pfm_file_ops)) {
-+		PFM_DBG("fd %d not related to perfmon", fd);
-+		goto error;
-+	}
-+
-+	ret = pfm_get_args(ureq, sz, 0, NULL, (void **)&req, &fptr);
-+	if (ret)
-+		goto error;
-+
-+	spin_lock_irqsave(&ctx->lock, flags);
-+
-+	task = ctx->task;
-+
-+	ret = pfm_check_task_state(ctx, PFM_CMD_STOPPED, &flags, &resume);
-+	if (ret == 0)
-+		ret = __pfm_write_ibrs_old(ctx, req, count);
-+
-+	spin_unlock_irqrestore(&ctx->lock, flags);
-+
-+	if (resume)
-+		pfm_resume_task(task, resume);
-+
-+	if (copy_to_user(ureq, req, sz))
-+		ret = -EFAULT;
-+
-+	kfree(fptr);
-+error:
-+	fput_light(filp, fput_needed);
-+	return ret;
-+}
-+
-+int __pfm_write_dbrs_old(struct pfm_context *ctx, void *arg, int count)
-+{
-+	struct pfarg_dbreg *req = arg;
-+	struct pfarg_pmc pmc;
-+	int i, ret = 0;
-+
-+	memset(&pmc, 0, sizeof(pmc));
-+
-+	for (i = 0; i < count; i++, req++) {
-+		pmc.reg_num   = 264+req->dbreg_num;
-+		pmc.reg_value = req->dbreg_value;
-+		pmc.reg_flags = 0;
-+		pmc.reg_set   = req->dbreg_set;
-+
-+		ret = __pfm_write_pmcs(ctx, &pmc, 1);
-+
-+		req->dbreg_flags &= ~PFM_REG_RETFL_MASK;
-+		req->dbreg_flags |= pmc.reg_flags;
-+		if (ret)
-+			return ret;
-+	}
-+	return 0;
-+}
-+
-+static long pfm_write_dbrs_old(int fd, void __user *ureq, int count)
-+{
-+	struct pfm_context *ctx;
-+	struct task_struct *task;
-+	struct file *filp;
-+	struct pfarg_dbreg *req = NULL;
-+	void *fptr, *resume;
-+	unsigned long flags;
-+	size_t sz;
-+	int ret, fput_needed;
-+
-+	if (count < 1 || count >= PFM_MAX_ARG_COUNT(req))
-+		return -EINVAL;
-+
-+	sz = count*sizeof(*req);
-+
-+	filp = fget_light(fd, &fput_needed);
-+	if (unlikely(filp == NULL)) {
-+		PFM_DBG("invalid fd %d", fd);
-+		return -EBADF;
-+	}
-+
-+	ctx = filp->private_data;
-+	ret = -EBADF;
-+
-+	if (unlikely(!ctx || filp->f_op != &pfm_file_ops)) {
-+		PFM_DBG("fd %d not related to perfmon", fd);
-+		goto error;
-+	}
-+
-+	ret = pfm_get_args(ureq, sz, 0, NULL, (void **)&req, &fptr);
-+	if (ret)
-+		goto error;
-+
-+	spin_lock_irqsave(&ctx->lock, flags);
-+
-+	task = ctx->task;
-+
-+	ret = pfm_check_task_state(ctx, PFM_CMD_STOPPED, &flags, &resume);
-+	if (ret == 0)
-+		ret = __pfm_write_dbrs_old(ctx, req, count);
-+
-+	spin_unlock_irqrestore(&ctx->lock, flags);
-+
-+	if (resume)
-+		pfm_resume_task(task, resume);
-+
-+	if (copy_to_user(ureq, req, sz))
-+		ret = -EFAULT;
-+
-+	kfree(fptr);
-+error:
-+	fput_light(filp, fput_needed);
-+	return ret;
-+}
-+
-+int __pfm_write_pmcs_old(struct pfm_context *ctx, struct pfarg_reg *req_old,
-+			 int count)
-+{
-+	struct pfarg_pmc req;
-+	unsigned int i;
-+	int ret, error_code;
-+
-+	memset(&req, 0, sizeof(req));
-+
-+	for (i = 0; i < count; i++, req_old++) {
-+		req.reg_num   = req_old->reg_num;
-+		req.reg_set   = req_old->reg_set;
-+		req.reg_flags = 0;
-+		req.reg_value = req_old->reg_value;
-+
-+		ret = __pfm_write_pmcs(ctx, (void *)&req, 1);
-+		req_old->reg_flags &= ~PFM_REG_RETFL_MASK;
-+		req_old->reg_flags |= req.reg_flags;
-+
-+		if (ret)
-+			return ret;
-+
-+		ret = pfm_compat_update_pmd(ctx, req_old->reg_set,
-+				      req_old->reg_num,
-+				      (u32)req_old->reg_flags,
-+				      req_old->reg_smpl_pmds,
-+				      req_old->reg_reset_pmds,
-+				      req_old->reg_smpl_eventid);
-+
-+		error_code = ret ? PFM_REG_RETFL_EINVAL : 0;
-+		req_old->reg_flags &= ~PFM_REG_RETFL_MASK;
-+		req_old->reg_flags |= error_code;
-+
-+		if (ret)
-+			return ret;
-+	}
-+	return 0;
-+}
-+
-+static long pfm_write_pmcs_old(int fd, void __user *ureq, int count)
-+{
-+	struct pfm_context *ctx;
-+	struct task_struct *task;
-+	struct file *filp;
-+	struct pfarg_reg *req = NULL;
-+	void *fptr, *resume;
-+	unsigned long flags;
-+	size_t sz;
-+	int ret, fput_needed;
-+
-+	if (count < 1 || count >= PFM_MAX_ARG_COUNT(req))
-+		return -EINVAL;
-+
-+	sz = count*sizeof(*req);
-+
-+	filp = fget_light(fd, &fput_needed);
-+	if (unlikely(filp == NULL)) {
-+		PFM_DBG("invalid fd %d", fd);
-+		return -EBADF;
-+	}
-+
-+	ctx = filp->private_data;
-+	ret = -EBADF;
-+
-+	if (unlikely(!ctx || filp->f_op != &pfm_file_ops)) {
-+		PFM_DBG("fd %d not related to perfmon", fd);
-+		goto error;
-+	}
-+
-+	ret = pfm_get_args(ureq, sz, 0, NULL, (void **)&req, &fptr);
-+	if (ret)
-+		goto error;
-+
-+	spin_lock_irqsave(&ctx->lock, flags);
-+
-+	task = ctx->task;
-+
-+	ret = pfm_check_task_state(ctx, PFM_CMD_STOPPED, &flags, &resume);
-+	if (ret == 0)
-+		ret = __pfm_write_pmcs_old(ctx, req, count);
-+
-+	spin_unlock_irqrestore(&ctx->lock, flags);
-+
-+	if (resume)
-+		pfm_resume_task(task, resume);
-+
-+	if (copy_to_user(ureq, req, sz))
-+		ret = -EFAULT;
-+
-+	kfree(fptr);
-+
-+error:
-+	fput_light(filp, fput_needed);
-+	return ret;
-+}
-+
-+int __pfm_write_pmds_old(struct pfm_context *ctx, struct pfarg_reg *req_old,
-+			 int count)
-+{
-+	struct pfarg_pmd req;
-+	int i, ret;
-+
-+	memset(&req, 0, sizeof(req));
-+
-+	for (i = 0; i < count; i++, req_old++) {
-+		req.reg_num   = req_old->reg_num;
-+		req.reg_set   = req_old->reg_set;
-+		req.reg_value = req_old->reg_value;
-+		/* flags passed with pmcs in v2.0 */
-+
-+		req.reg_long_reset  = req_old->reg_long_reset;
-+		req.reg_short_reset = req_old->reg_short_reset;
-+		req.reg_random_mask = req_old->reg_random_mask;
-+		/*
-+		 * reg_random_seed is ignored since v2.3
-+		 */
-+
-+		/*
-+		 * skip last_reset_val not used for writing
-+		 * skip smpl_pmds, reset_pmds, eventid, ovfl_swtch_cnt
-+		 * as set in pfm_write_pmcs_old.
-+		 *
-+		 * ovfl_switch_cnt ignored, not implemented in v2.0
-+		 */
-+		ret = __pfm_write_pmds(ctx, (void *)&req, 1, 1);
-+
-+		req_old->reg_flags &= ~PFM_REG_RETFL_MASK;
-+		req_old->reg_flags |= req.reg_flags;
-+
-+		if (ret)
-+			return ret;
-+	}
-+	return 0;
-+}
-+
-+static long pfm_write_pmds_old(int fd, void __user *ureq, int count)
-+{
-+	struct pfm_context *ctx;
-+	struct task_struct *task;
-+	struct file *filp;
-+	struct pfarg_reg *req = NULL;
-+	void *fptr, *resume;
-+	unsigned long flags;
-+	size_t sz;
-+	int ret, fput_needed;
-+
-+	if (count < 1 || count >= PFM_MAX_ARG_COUNT(req))
-+		return -EINVAL;
-+
-+	sz = count*sizeof(*req);
-+
-+	filp = fget_light(fd, &fput_needed);
-+	if (unlikely(filp == NULL)) {
-+		PFM_DBG("invalid fd %d", fd);
-+		return -EBADF;
-+	}
-+
-+	ctx = filp->private_data;
-+	ret = -EBADF;
-+
-+	if (unlikely(!ctx || filp->f_op != &pfm_file_ops)) {
-+		PFM_DBG("fd %d not related to perfmon", fd);
-+		goto error;
-+	}
-+
-+	ret = pfm_get_args(ureq, sz, 0, NULL, (void **)&req, &fptr);
-+	if (ret)
-+		goto error;
-+
-+	spin_lock_irqsave(&ctx->lock, flags);
-+
-+	task = ctx->task;
-+
-+	ret = pfm_check_task_state(ctx, PFM_CMD_STOPPED, &flags, &resume);
-+	if (ret == 0)
-+		ret = __pfm_write_pmds_old(ctx, req, count);
-+
-+	spin_unlock_irqrestore(&ctx->lock, flags);
-+
-+	if (copy_to_user(ureq, req, sz))
-+		ret = -EFAULT;
-+
-+	if (resume)
-+		pfm_resume_task(task, resume);
-+
-+	kfree(fptr);
-+error:
-+	fput_light(filp, fput_needed);
-+	return ret;
-+}
-+
-+int __pfm_read_pmds_old(struct pfm_context *ctx, struct pfarg_reg *req_old,
-+			int count)
-+{
-+	struct pfarg_pmd req;
-+	int i, ret;
-+
-+	memset(&req, 0, sizeof(req));
-+
-+	for (i = 0; i < count; i++, req_old++) {
-+		req.reg_num   = req_old->reg_num;
-+		req.reg_set   = req_old->reg_set;
-+
-+		/* skip value not used for reading */
-+		req.reg_flags = req_old->reg_flags;
-+
-+		/* skip short/long_reset not used for reading */
-+		/* skip last_reset_val not used for reading */
-+		/* skip ovfl_switch_cnt not used for reading */
-+
-+		ret = __pfm_read_pmds(ctx, (void *)&req, 1);
-+
-+		req_old->reg_flags &= ~PFM_REG_RETFL_MASK;
-+		req_old->reg_flags |= req.reg_flags;
-+		if (ret)
-+			return ret;
-+
-+		/* update fields */
-+		req_old->reg_value = req.reg_value;
-+
-+		req_old->reg_last_reset_val  = req.reg_last_reset_val;
-+		req_old->reg_ovfl_switch_cnt = req.reg_ovfl_switch_cnt;
-+	}
-+	return 0;
-+}
-+
-+static long pfm_read_pmds_old(int fd, void __user *ureq, int count)
-+{
-+	struct pfm_context *ctx;
-+	struct task_struct *task;
-+	struct file *filp;
-+	struct pfarg_reg *req = NULL;
-+	void *fptr, *resume;
-+	unsigned long flags;
-+	size_t sz;
-+	int ret, fput_needed;
-+
-+	if (count < 1 || count >= PFM_MAX_ARG_COUNT(req))
-+		return -EINVAL;
-+
-+	sz = count*sizeof(*req);
-+
-+	filp = fget_light(fd, &fput_needed);
-+	if (unlikely(filp == NULL)) {
-+		PFM_DBG("invalid fd %d", fd);
-+		return -EBADF;
-+	}
-+
-+	ctx = filp->private_data;
-+	ret = -EBADF;
-+
-+	if (unlikely(!ctx || filp->f_op != &pfm_file_ops)) {
-+		PFM_DBG("fd %d not related to perfmon", fd);
-+		goto error;
-+	}
-+
-+	ret = pfm_get_args(ureq, sz, 0, NULL, (void **)&req, &fptr);
-+	if (ret)
-+		goto error;
-+
-+	spin_lock_irqsave(&ctx->lock, flags);
-+
-+	task = ctx->task;
-+
-+	ret = pfm_check_task_state(ctx, PFM_CMD_STOPPED, &flags, &resume);
-+	if (ret == 0)
-+		ret = __pfm_read_pmds_old(ctx, req, count);
-+
-+	spin_unlock_irqrestore(&ctx->lock, flags);
-+
-+	if (resume)
-+		pfm_resume_task(task, resume);
-+
-+	if (copy_to_user(ureq, req, sz))
-+		ret = -EFAULT;
-+
-+	kfree(fptr);
-+error:
-+	fput_light(filp, fput_needed);
-+	return ret;
-+}
-+
-+/*
-+ * OBSOLETE: use /proc/perfmon_map instead
-+ */
-+static long pfm_get_default_pmcs_old(int fd, void __user *ureq, int count)
-+{
-+	struct pfarg_reg *req = NULL;
-+	void *fptr;
-+	size_t sz;
-+	int ret, i;
-+	unsigned int cnum;
-+
-+	if (count < 1)
-+		return -EINVAL;
-+
-+	/*
-+	 * ensure the pfm_pmu_conf does not disappear while
-+	 * we use it
-+	 */
-+	ret = pfm_pmu_conf_get(1);
-+	if (ret)
-+		return ret;
-+
-+	sz = count*sizeof(*ureq);
-+
-+	ret = pfm_get_args(ureq, sz, 0, NULL, (void **)&req, &fptr);
-+	if (ret)
-+		goto error;
-+
-+
-+	for (i = 0; i < count; i++, req++) {
-+		cnum   = req->reg_num;
-+
-+		if (i >= PFM_MAX_PMCS ||
-+		    (pfm_pmu_conf->pmc_desc[cnum].type & PFM_REG_I) == 0) {
-+			req->reg_flags = PFM_REG_RETFL_EINVAL;
-+			break;
-+		}
-+		req->reg_value = pfm_pmu_conf->pmc_desc[cnum].dfl_val;
-+		req->reg_flags = 0;
-+
-+		PFM_DBG("pmc[%u]=0x%lx", cnum, req->reg_value);
-+	}
-+
-+	if (copy_to_user(ureq, req, sz))
-+		ret = -EFAULT;
-+
-+	kfree(fptr);
-+error:
-+	pfm_pmu_conf_put();
-+
-+	return ret;
-+}
-+
-+/*
-+ * allocate a sampling buffer and remaps it into the user address space of
-+ * the task. This is only in compatibility mode
-+ *
-+ * function called ONLY on current task
-+ */
-+int pfm_smpl_buf_alloc_compat(struct pfm_context *ctx, size_t rsize,
-+			      struct file *filp)
-+{
-+	struct mm_struct *mm = current->mm;
-+	struct vm_area_struct *vma = NULL;
-+	struct pfm_arch_context *ctx_arch;
-+	size_t size;
-+	int ret;
-+	extern struct vm_operations_struct pfm_buf_map_vm_ops;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+
-+	/*
-+	 * allocate buffer + map desc
-+	 */
-+	ret = pfm_smpl_buf_alloc(ctx, rsize);
-+	if (ret)
-+		return ret;
-+
-+	size = ctx->smpl_size;
-+
-+
-+	/* allocate vma */
-+	vma = kmem_cache_alloc(vm_area_cachep, GFP_KERNEL);
-+	if (!vma) {
-+		PFM_DBG("Cannot allocate vma");
-+		goto error_kmem;
-+	}
-+	memset(vma, 0, sizeof(*vma));
-+
-+	/*
-+	 * partially initialize the vma for the sampling buffer
-+	 */
-+	vma->vm_mm	     = mm;
-+	vma->vm_flags	     = VM_READ | VM_MAYREAD | VM_RESERVED;
-+	vma->vm_page_prot    = PAGE_READONLY;
-+	vma->vm_ops	     = &pfm_buf_map_vm_ops;
-+	vma->vm_file	     = filp;
-+	vma->vm_private_data = ctx;
-+	vma->vm_pgoff        = 0;
-+
-+	/*
-+	 * simulate effect of mmap()
-+	 */
-+	get_file(filp);
-+
-+	/*
-+	 * Let's do the difficult operations next.
-+	 *
-+	 * now we atomically find some area in the address space and
-+	 * remap the buffer into it.
-+	 */
-+	down_write(&current->mm->mmap_sem);
-+
-+	/* find some free area in address space, must have mmap sem held */
-+	vma->vm_start = get_unmapped_area(NULL, 0, size, 0,
-+					  MAP_PRIVATE|MAP_ANONYMOUS);
-+	if (vma->vm_start == 0) {
-+		PFM_DBG("cannot find unmapped area of size %zu", size);
-+		up_write(&current->mm->mmap_sem);
-+		goto error;
-+	}
-+	vma->vm_end = vma->vm_start + size;
-+
-+	PFM_DBG("aligned_size=%zu mapped @0x%lx", size, vma->vm_start);
-+	/*
-+	 * now insert the vma in the vm list for the process, must be
-+	 * done with mmap lock held
-+	 */
-+	insert_vm_struct(mm, vma);
-+
-+	mm->total_vm  += size >> PAGE_SHIFT;
-+
-+	up_write(&current->mm->mmap_sem);
-+
-+	/*
-+	 * IMPORTANT: we do not issue the fput()
-+	 * because we want to increase the ref count
-+	 * on the descriptor to simulate what mmap()
-+	 * would do
-+	 */
-+
-+	/*
-+	 * used to propagate vaddr to syscall stub
-+	 */
-+	ctx_arch->ctx_smpl_vaddr = (void *)vma->vm_start;
-+
-+	return 0;
-+error:
-+	kmem_cache_free(vm_area_cachep, vma);
-+error_kmem:
-+	pfm_smpl_buf_space_release(ctx, ctx->smpl_size);
-+	vfree(ctx->smpl_addr);
-+	return -ENOMEM;
-+}
-+
-+#define PFM_DEFAULT_SMPL_UUID { \
-+		0x4d, 0x72, 0xbe, 0xc0, 0x06, 0x64, 0x41, 0x43, 0x82,\
-+		0xb4, 0xd3, 0xfd, 0x27, 0x24, 0x3c, 0x97}
-+
-+static pfm_uuid_t old_default_uuid = PFM_DEFAULT_SMPL_UUID;
-+static pfm_uuid_t null_uuid;
-+
-+/*
-+ * function invoked in case, pfm_context_create fails
-+ * at the last operation, copy_to_user. It needs to
-+ * undo memory allocations and free the file descriptor
-+ */
-+static void pfm_undo_create_context_fd(int fd, struct pfm_context *ctx)
-+{
-+	struct files_struct *files = current->files;
-+	struct file *file;
-+	int fput_needed;
-+
-+	file = fget_light(fd, &fput_needed);
-+	/*
-+	 * there is no fd_uninstall(), so we do it
-+	 * here. put_unused_fd() does not remove the
-+	 * effect of fd_install().
-+	 */
-+
-+	spin_lock(&files->file_lock);
-+	files->fd_array[fd] = NULL;
-+	spin_unlock(&files->file_lock);
-+
-+	fput_light(file, fput_needed);
-+
-+	/*
-+	 * decrement ref count and kill file
-+	 */
-+	put_filp(file);
-+
-+	put_unused_fd(fd);
-+
-+	pfm_free_context(ctx);
-+}
-+
-+static int pfm_get_smpl_arg_old(pfm_uuid_t uuid, void __user *fmt_uarg,
-+				size_t usize, void **arg,
-+				struct pfm_smpl_fmt **fmt)
-+{
-+	struct pfm_smpl_fmt *f;
-+	void *addr = NULL;
-+	size_t sz;
-+	int ret;
-+
-+	if (!memcmp(uuid, null_uuid, sizeof(pfm_uuid_t)))
-+		return 0;
-+
-+	if (memcmp(uuid, old_default_uuid, sizeof(pfm_uuid_t))) {
-+		PFM_DBG("compatibility mode supports only default sampling format");
-+		return -EINVAL;
-+	}
-+	/*
-+	 * find fmt and increase refcount
-+	 */
-+	f = pfm_smpl_fmt_get("default-old");
-+	if (f == NULL) {
-+		PFM_DBG("default-old buffer format not found");
-+		return -EINVAL;
-+	}
-+
-+	/*
-+	 * expected format argument size
-+	 */
-+	sz = f->fmt_arg_size;
-+
-+	/*
-+	 * check user size matches expected size
-+	 * usize = -1 is for IA-64 backward compatibility
-+	 */
-+	ret = -EINVAL;
-+	if (sz != usize && usize != -1) {
-+		PFM_DBG("invalid arg size %zu, format expects %zu",
-+			usize, sz);
-+		goto error;
-+	}
-+
-+	ret = -ENOMEM;
-+	addr = kmalloc(sz, GFP_KERNEL);
-+	if (addr == NULL)
-+		goto error;
-+
-+	ret = -EFAULT;
-+	if (copy_from_user(addr, fmt_uarg, sz))
-+		goto error;
-+
-+	*arg = addr;
-+	*fmt = f;
-+	return 0;
-+
-+error:
-+	kfree(addr);
-+	pfm_smpl_fmt_put(f);
-+	return ret;
-+}
-+
-+static long pfm_create_context_old(int fd, void __user *ureq, int count)
-+{
-+	struct pfm_context *new_ctx;
-+	struct pfm_arch_context *ctx_arch;
-+	struct pfm_smpl_fmt *fmt = NULL;
-+	struct pfarg_context req_old;
-+	void __user *usmpl_arg;
-+	void *smpl_arg = NULL;
-+	struct pfarg_ctx req;
-+	int ret;
-+
-+	if (count != 1)
-+		return -EINVAL;
-+
-+	if (copy_from_user(&req_old, ureq, sizeof(req_old)))
-+		return -EFAULT;
-+
-+	memset(&req, 0, sizeof(req));
-+
-+	/*
-+	 * sampling format args are following pfarg_context
-+	 */
-+	usmpl_arg = ureq+sizeof(req_old);
-+
-+	ret = pfm_get_smpl_arg_old(req_old.ctx_smpl_buf_id, usmpl_arg, -1,
-+				   &smpl_arg, &fmt);
-+	if (ret)
-+		return ret;
-+
-+	req.ctx_flags = req_old.ctx_flags;
-+
-+	/*
-+	 * returns file descriptor if >=0, or error code */
-+	ret = __pfm_create_context(&req, fmt, smpl_arg, PFM_COMPAT, &new_ctx);
-+	if (ret >= 0) {
-+		ctx_arch = pfm_ctx_arch(new_ctx);
-+		req_old.ctx_fd = ret;
-+		req_old.ctx_smpl_vaddr = ctx_arch->ctx_smpl_vaddr;
-+	}
-+
-+	if (copy_to_user(ureq, &req_old, sizeof(req_old))) {
-+		pfm_undo_create_context_fd(req_old.ctx_fd, new_ctx);
-+		ret = -EFAULT;
-+	}
-+
-+	kfree(smpl_arg);
-+
-+	return ret;
-+}
-+
-+/*
-+ * obsolete call: use /proc/perfmon
-+ */
-+static long pfm_get_features_old(int fd, void __user *arg, int count)
-+{
-+	struct pfarg_features req;
-+	int ret = 0;
-+
-+	if (count != 1)
-+		return -EINVAL;
-+
-+	memset(&req, 0, sizeof(req));
-+
-+	req.ft_version = PFM_VERSION;
-+
-+	if (copy_to_user(arg, &req, sizeof(req)))
-+		ret = -EFAULT;
-+
-+	return ret;
-+}
-+
-+static long pfm_debug_old(int fd, void __user *arg, int count)
-+{
-+	int m;
-+
-+	if (count != 1)
-+		return -EINVAL;
-+
-+	if (get_user(m, (int __user *)arg))
-+		return -EFAULT;
-+
-+
-+	pfm_controls.debug = m == 0 ? 0 : 1;
-+
-+	PFM_INFO("debugging %s (timing reset)",
-+		 pfm_controls.debug ? "on" : "off");
-+
-+	if (m == 0)
-+		for_each_online_cpu(m) {
-+			memset(&per_cpu(pfm_stats, m), 0,
-+			       sizeof(struct pfm_stats));
-+		}
-+	return 0;
-+}
-+
-+static long pfm_unload_context_old(int fd, void __user *arg, int count)
-+{
-+	if (count)
-+		return -EINVAL;
-+
-+	return sys_pfm_unload_context(fd);
-+}
-+
-+static long pfm_restart_old(int fd, void __user *arg, int count)
-+{
-+	if (count)
-+		return -EINVAL;
-+
-+	return sys_pfm_restart(fd);
-+}
-+
-+static long pfm_stop_old(int fd, void __user *arg, int count)
-+{
-+	if (count)
-+		return -EINVAL;
-+
-+	return sys_pfm_stop(fd);
-+}
-+
-+static long pfm_start_old(int fd, void __user *arg, int count)
-+{
-+	if (count > 1)
-+		return -EINVAL;
-+
-+	return sys_pfm_start(fd, arg);
-+}
-+
-+static long pfm_load_context_old(int fd, void __user *ureq, int count)
-+{
-+	if (count != 1)
-+		return -EINVAL;
-+
-+	return sys_pfm_load_context(fd, ureq);
-+}
-+
-+/*
-+ * perfmon command descriptions
-+ */
-+struct pfm_cmd_desc {
-+	long (*cmd_func)(int fd, void __user *arg, int count);
-+};
-+
-+/*
-+ * functions MUST be listed in the increasing order of
-+ * their index (see permfon.h)
-+ */
-+#define PFM_CMD(name)  \
-+	{ .cmd_func = name,  \
-+	}
-+#define PFM_CMD_NONE		\
-+	{ .cmd_func = NULL   \
-+	}
-+
-+static struct pfm_cmd_desc pfm_cmd_tab[] = {
-+/* 0  */PFM_CMD_NONE,
-+/* 1  */PFM_CMD(pfm_write_pmcs_old),
-+/* 2  */PFM_CMD(pfm_write_pmds_old),
-+/* 3  */PFM_CMD(pfm_read_pmds_old),
-+/* 4  */PFM_CMD(pfm_stop_old),
-+/* 5  */PFM_CMD(pfm_start_old),
-+/* 6  */PFM_CMD_NONE,
-+/* 7  */PFM_CMD_NONE,
-+/* 8  */PFM_CMD(pfm_create_context_old),
-+/* 9  */PFM_CMD_NONE,
-+/* 10 */PFM_CMD(pfm_restart_old),
-+/* 11 */PFM_CMD_NONE,
-+/* 12 */PFM_CMD(pfm_get_features_old),
-+/* 13 */PFM_CMD(pfm_debug_old),
-+/* 14 */PFM_CMD_NONE,
-+/* 15 */PFM_CMD(pfm_get_default_pmcs_old),
-+/* 16 */PFM_CMD(pfm_load_context_old),
-+/* 17 */PFM_CMD(pfm_unload_context_old),
-+/* 18 */PFM_CMD_NONE,
-+/* 19 */PFM_CMD_NONE,
-+/* 20 */PFM_CMD_NONE,
-+/* 21 */PFM_CMD_NONE,
-+/* 22 */PFM_CMD_NONE,
-+/* 23 */PFM_CMD_NONE,
-+/* 24 */PFM_CMD_NONE,
-+/* 25 */PFM_CMD_NONE,
-+/* 26 */PFM_CMD_NONE,
-+/* 27 */PFM_CMD_NONE,
-+/* 28 */PFM_CMD_NONE,
-+/* 29 */PFM_CMD_NONE,
-+/* 30 */PFM_CMD_NONE,
-+/* 31 */PFM_CMD_NONE,
-+/* 32 */PFM_CMD(pfm_write_ibrs_old),
-+/* 33 */PFM_CMD(pfm_write_dbrs_old),
-+};
-+#define PFM_CMD_COUNT ARRAY_SIZE(pfm_cmd_tab)
-+
-+/*
-+ * system-call entry point (must return long)
-+ */
-+asmlinkage long sys_perfmonctl(int fd, int cmd, void __user *arg, int count)
-+{
-+	if (perfmon_disabled)
-+		return -ENOSYS;
-+
-+	if (unlikely(cmd < 0 || cmd >= PFM_CMD_COUNT
-+		     || pfm_cmd_tab[cmd].cmd_func == NULL)) {
-+		PFM_DBG("invalid cmd=%d", cmd);
-+		return -EINVAL;
-+	}
-+	return (long)pfm_cmd_tab[cmd].cmd_func(fd, arg, count);
-+}
-+
-+/*
-+ * Called from pfm_read() for a perfmon v2.0 context.
-+ *
-+ * compatibility mode pfm_read() routine. We need a separate
-+ * routine because the definition of the message has changed.
-+ * The pfm_msg and pfarg_msg structures are different.
-+ *
-+ * return: sizeof(pfm_msg_t) on success, -errno otherwise
-+ */
-+ssize_t pfm_arch_compat_read(struct pfm_context *ctx,
-+			     char __user *buf,
-+			     int non_block,
-+			     size_t size)
-+{
-+	union pfarg_msg msg_buf;
-+	pfm_msg_t old_msg_buf;
-+	pfm_ovfl_msg_t *o_msg;
-+	struct pfarg_ovfl_msg *n_msg;
-+	int ret;
-+
-+	PFM_DBG("msg=%p size=%zu", buf, size);
-+
-+	/*
-+	 * cannot extract partial messages.
-+	 * check even when there is no message
-+	 *
-+	 * cannot extract more than one message per call. Bytes
-+	 * above sizeof(msg) are ignored.
-+	 */
-+	if (size < sizeof(old_msg_buf)) {
-+		PFM_DBG("message is too small size=%zu must be >=%zu)",
-+			size,
-+			sizeof(old_msg_buf));
-+		return -EINVAL;
-+	}
-+
-+	ret =  __pfm_read(ctx, &msg_buf, non_block);
-+	if (ret < 1)
-+		return ret;
-+
-+	/*
-+	 * force return value to old message size
-+	 */
-+	ret = sizeof(old_msg_buf);
-+
-+	o_msg = &old_msg_buf.pfm_ovfl_msg;
-+	n_msg = &msg_buf.pfm_ovfl_msg;
-+
-+	switch (msg_buf.type) {
-+	case PFM_MSG_OVFL:
-+		o_msg->msg_type   = PFM_MSG_OVFL;
-+		o_msg->msg_ctx_fd = 0;
-+		o_msg->msg_active_set = n_msg->msg_active_set;
-+		o_msg->msg_tstamp = 0;
-+
-+		o_msg->msg_ovfl_pmds[0] = n_msg->msg_ovfl_pmds[0];
-+		o_msg->msg_ovfl_pmds[1] = n_msg->msg_ovfl_pmds[1];
-+		o_msg->msg_ovfl_pmds[2] = n_msg->msg_ovfl_pmds[2];
-+		o_msg->msg_ovfl_pmds[3] = n_msg->msg_ovfl_pmds[3];
-+		break;
-+	case PFM_MSG_END:
-+		o_msg->msg_type = PFM_MSG_END;
-+		o_msg->msg_ctx_fd = 0;
-+		o_msg->msg_tstamp = 0;
-+		break;
-+	default:
-+		PFM_DBG("unknown msg type=%d", msg_buf.type);
-+	}
-+	if (copy_to_user(buf, &old_msg_buf, sizeof(old_msg_buf)))
-+		ret = -EFAULT;
-+	PFM_DBG_ovfl("ret=%d", ret);
-+	return ret;
-+}
-+
-+/*
-+ * legacy /proc/perfmon simplified interface (we only maintain the
-+ * global information (no more per-cpu stats, use
-+ * /sys/devices/system/cpu/cpuXX/perfmon
-+ */
-+static struct proc_dir_entry 	*perfmon_proc;
-+
-+static void *pfm_proc_start(struct seq_file *m, loff_t *pos)
-+{
-+	if (*pos == 0)
-+		return (void *)1;
-+
-+	return NULL;
-+}
-+
-+static void *pfm_proc_next(struct seq_file *m, void *v, loff_t *pos)
-+{
-+	++*pos;
-+	return pfm_proc_start(m, pos);
-+}
-+
-+static void pfm_proc_stop(struct seq_file *m, void *v)
-+{
-+}
-+
-+/*
-+ * this is a simplified version of the legacy /proc/perfmon.
-+ * We have retained ONLY the key information that tools are actually
-+ * using
-+ */
-+static void pfm_proc_show_header(struct seq_file *m)
-+{
-+	char buf[128];
-+
-+	pfm_sysfs_res_show(buf, sizeof(buf), 3);
-+
-+	seq_printf(m, "perfmon version            : %u.%u\n",
-+		PFM_VERSION_MAJ, PFM_VERSION_MIN);
-+
-+	seq_printf(m, "model                      : %s", buf);
-+}
-+
-+static int pfm_proc_show(struct seq_file *m, void *v)
-+{
-+	pfm_proc_show_header(m);
-+	return 0;
-+}
-+
-+struct seq_operations pfm_proc_seq_ops = {
-+	.start = pfm_proc_start,
-+	.next =	pfm_proc_next,
-+	.stop =	pfm_proc_stop,
-+	.show =	pfm_proc_show
-+};
-+
-+static int pfm_proc_open(struct inode *inode, struct file *file)
-+{
-+	return seq_open(file, &pfm_proc_seq_ops);
-+}
-+
-+
-+static struct file_operations pfm_proc_fops = {
-+	.open = pfm_proc_open,
-+	.read = seq_read,
-+	.llseek	= seq_lseek,
-+	.release = seq_release,
-+};
-+
-+/*
-+ * called from pfm_arch_init(), global initialization, called once
-+ */
-+int __init pfm_ia64_compat_init(void)
-+{
-+	/*
-+	 * create /proc/perfmon
-+	 */
-+	perfmon_proc = create_proc_entry("perfmon", S_IRUGO, NULL);
-+	if (perfmon_proc == NULL) {
-+		PFM_ERR("cannot create /proc entry, perfmon disabled");
-+		return -1;
-+	}
-+	perfmon_proc->proc_fops = &pfm_proc_fops;
-+	return 0;
-+}
-diff --git a/arch/ia64/perfmon/perfmon_default_smpl.c b/arch/ia64/perfmon/perfmon_default_smpl.c
-new file mode 100644
-index 0000000..b408a13
---- /dev/null
-+++ b/arch/ia64/perfmon/perfmon_default_smpl.c
-@@ -0,0 +1,273 @@
-+/*
-+ * Copyright (c) 2002-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This file implements the old default sampling buffer format
-+ * for the Linux/ia64 perfmon-2 subsystem. This is for backward
-+ * compatibility only. use the new default format in perfmon/
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+  */
-+#include <linux/kernel.h>
-+#include <linux/types.h>
-+#include <linux/module.h>
-+#include <linux/init.h>
-+#include <linux/delay.h>
-+#include <linux/smp.h>
-+#include <linux/sysctl.h>
-+
-+#ifdef MODULE
-+#define FMT_FLAGS	0
-+#else
-+#define FMT_FLAGS	PFM_FMTFL_IS_BUILTIN
-+#endif
-+
-+#include <linux/perfmon_kern.h>
-+#include <asm/perfmon_default_smpl.h>
-+
-+MODULE_AUTHOR("Stephane Eranian <eranian@hpl.hp.com>");
-+MODULE_DESCRIPTION("perfmon old default sampling format");
-+MODULE_LICENSE("GPL");
-+
-+static int pfm_default_fmt_validate(u32 flags, u16 npmds, void *data)
-+{
-+	struct pfm_default_smpl_arg *arg = data;
-+	size_t min_buf_size;
-+
-+	if (data == NULL) {
-+		PFM_DBG("no argument passed");
-+		return -EINVAL;
-+	}
-+
-+	/*
-+	 * compute min buf size. All PMD are manipulated as 64bit entities
-+	 */
-+	min_buf_size = sizeof(struct pfm_default_smpl_hdr)
-+	     + (sizeof(struct pfm_default_smpl_entry) + (npmds*sizeof(u64)));
-+
-+	PFM_DBG("validate flags=0x%x npmds=%u min_buf_size=%lu "
-+		  "buf_size=%lu CPU%d", flags, npmds, min_buf_size,
-+		  arg->buf_size, smp_processor_id());
-+
-+	/*
-+	 * must hold at least the buffer header + one minimally sized entry
-+	 */
-+	if (arg->buf_size < min_buf_size)
-+		return -EINVAL;
-+
-+	return 0;
-+}
-+
-+static int pfm_default_fmt_get_size(unsigned int flags, void *data,
-+				    size_t *size)
-+{
-+	struct pfm_default_smpl_arg *arg = data;
-+
-+	/*
-+	 * size has been validated in default_validate
-+	 */
-+	*size = arg->buf_size;
-+
-+	return 0;
-+}
-+
-+static int pfm_default_fmt_init(struct pfm_context *ctx, void *buf,
-+				u32 flags, u16 npmds, void *data)
-+{
-+	struct pfm_default_smpl_hdr *hdr;
-+	struct pfm_default_smpl_arg *arg = data;
-+
-+	hdr = buf;
-+
-+	hdr->hdr_version      = PFM_DEFAULT_SMPL_VERSION;
-+	hdr->hdr_buf_size     = arg->buf_size;
-+	hdr->hdr_cur_offs     = sizeof(*hdr);
-+	hdr->hdr_overflows    = 0;
-+	hdr->hdr_count        = 0;
-+
-+	PFM_DBG("buffer=%p buf_size=%lu hdr_size=%lu "
-+		  "hdr_version=%u cur_offs=%lu",
-+		  buf,
-+		  hdr->hdr_buf_size,
-+		  sizeof(*hdr),
-+		  hdr->hdr_version,
-+		  hdr->hdr_cur_offs);
-+
-+	return 0;
-+}
-+
-+static int pfm_default_fmt_handler(struct pfm_context *ctx,
-+				   unsigned long ip, u64 tstamp, void *data)
-+{
-+	struct pfm_default_smpl_hdr *hdr;
-+	struct pfm_default_smpl_entry *ent;
-+	void *cur, *last, *buf;
-+	u64 *e;
-+	size_t entry_size;
-+	u16 npmds, i, ovfl_pmd;
-+	struct pfm_ovfl_arg *arg;
-+
-+	hdr = ctx->smpl_addr;
-+	arg = &ctx->ovfl_arg;
-+
-+	buf = hdr;
-+	cur = buf+hdr->hdr_cur_offs;
-+	last = buf+hdr->hdr_buf_size;
-+	ovfl_pmd = arg->ovfl_pmd;
-+
-+	/*
-+	 * precheck for sanity
-+	 */
-+	if ((last - cur) < PFM_DEFAULT_MAX_ENTRY_SIZE)
-+		goto full;
-+
-+	npmds = arg->num_smpl_pmds;
-+
-+	ent = cur;
-+
-+	prefetch(arg->smpl_pmds_values);
-+
-+	entry_size = sizeof(*ent) + (npmds << 3);
-+
-+	/* position for first pmd */
-+	e = (unsigned long *)(ent+1);
-+
-+	hdr->hdr_count++;
-+
-+	PFM_DBG_ovfl("count=%lu cur=%p last=%p free_bytes=%lu "
-+		       "ovfl_pmd=%d npmds=%u",
-+		       hdr->hdr_count,
-+		       cur, last,
-+		       last-cur,
-+		       ovfl_pmd,
-+		       npmds);
-+
-+	/*
-+	 * current = task running at the time of the overflow.
-+	 *
-+	 * per-task mode:
-+	 * 	- this is ususally the task being monitored.
-+	 * 	  Under certain conditions, it might be a different task
-+	 *
-+	 * system-wide:
-+	 * 	- this is not necessarily the task controlling the session
-+	 */
-+	ent->pid            = current->pid;
-+	ent->ovfl_pmd  	    = ovfl_pmd;
-+	ent->last_reset_val = arg->pmd_last_reset;
-+
-+	/*
-+	 * where did the fault happen (includes slot number)
-+	 */
-+	ent->ip = ip;
-+
-+	ent->tstamp    = tstamp;
-+	ent->cpu       = smp_processor_id();
-+	ent->set       = arg->active_set;
-+	ent->tgid      = current->tgid;
-+
-+	/*
-+	 * selectively store PMDs in increasing index number
-+	 */
-+	if (npmds) {
-+		u64 *val = arg->smpl_pmds_values;
-+		for (i = 0; i < npmds; i++)
-+			*e++ = *val++;
-+	}
-+
-+	/*
-+	 * update position for next entry
-+	 */
-+	hdr->hdr_cur_offs += entry_size;
-+	cur               += entry_size;
-+
-+	/*
-+	 * post check to avoid losing the last sample
-+	 */
-+	if ((last - cur) < PFM_DEFAULT_MAX_ENTRY_SIZE)
-+		goto full;
-+
-+	/*
-+	 * reset before returning from interrupt handler
-+	 */
-+	arg->ovfl_ctrl = PFM_OVFL_CTRL_RESET;
-+	return 0;
-+full:
-+	PFM_DBG_ovfl("smpl buffer full free=%lu, count=%lu",
-+		       last-cur, hdr->hdr_count);
-+
-+	/*
-+	 * increment number of buffer overflow.
-+	 * important to detect duplicate set of samples.
-+	 */
-+	hdr->hdr_overflows++;
-+
-+	/*
-+	 * request notification and masking of monitoring.
-+	 * Notification is still subject to the overflowed
-+	 */
-+	arg->ovfl_ctrl = PFM_OVFL_CTRL_NOTIFY | PFM_OVFL_CTRL_MASK;
-+
-+	return -ENOBUFS; /* we are full, sorry */
-+}
-+
-+static int pfm_default_fmt_restart(int is_active, u32 *ovfl_ctrl, void *buf)
-+{
-+	struct pfm_default_smpl_hdr *hdr;
-+
-+	hdr = buf;
-+
-+	hdr->hdr_count    = 0;
-+	hdr->hdr_cur_offs = sizeof(*hdr);
-+
-+	*ovfl_ctrl = PFM_OVFL_CTRL_RESET;
-+
-+	return 0;
-+}
-+
-+static int pfm_default_fmt_exit(void *buf)
-+{
-+	return 0;
-+}
-+
-+static struct pfm_smpl_fmt default_fmt = {
-+	.fmt_name = "default-old",
-+	.fmt_version = 0x10000,
-+	.fmt_arg_size = sizeof(struct pfm_default_smpl_arg),
-+	.fmt_validate = pfm_default_fmt_validate,
-+	.fmt_getsize = pfm_default_fmt_get_size,
-+	.fmt_init = pfm_default_fmt_init,
-+	.fmt_handler = pfm_default_fmt_handler,
-+	.fmt_restart = pfm_default_fmt_restart,
-+	.fmt_exit = pfm_default_fmt_exit,
-+	.fmt_flags = FMT_FLAGS,
-+	.owner = THIS_MODULE
-+};
-+
-+static int pfm_default_fmt_init_module(void)
-+{
-+	int ret;
-+
-+	return pfm_fmt_register(&default_fmt);
-+	return ret;
-+}
-+
-+static void pfm_default_fmt_cleanup_module(void)
-+{
-+	pfm_fmt_unregister(&default_fmt);
-+}
-+
-+module_init(pfm_default_fmt_init_module);
-+module_exit(pfm_default_fmt_cleanup_module);
-diff --git a/arch/ia64/perfmon/perfmon_generic.c b/arch/ia64/perfmon/perfmon_generic.c
-new file mode 100644
-index 0000000..47b1870
---- /dev/null
-+++ b/arch/ia64/perfmon/perfmon_generic.c
-@@ -0,0 +1,148 @@
-+/*
-+ * This file contains the generic PMU register description tables
-+ * and pmc checker used by perfmon.c.
-+ *
-+ * Copyright (c) 2002-2006 Hewlett-Packard Development Company, L.P.
-+ * contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+  */
-+#include <linux/module.h>
-+#include <linux/perfmon_kern.h>
-+#include <asm/pal.h>
-+
-+MODULE_AUTHOR("Stephane Eranian <eranian@hpl.hp.com>");
-+MODULE_DESCRIPTION("Generic IA-64 PMU description tables");
-+MODULE_LICENSE("GPL");
-+
-+#define RDEP(x)	(1UL << (x))
-+
-+#define PFM_IA64GEN_MASK_PMCS	(RDEP(4)|RDEP(5)|RDEP(6)|RDEP(7))
-+#define PFM_IA64GEN_RSVD	(0xffffffffffff0080UL)
-+#define PFM_IA64GEN_NO64	(1UL<<5)
-+
-+/* forward declaration */
-+static struct pfm_pmu_config pfm_ia64gen_pmu_conf;
-+
-+static struct pfm_arch_pmu_info pfm_ia64gen_pmu_info = {
-+	.mask_pmcs = {PFM_IA64GEN_MASK_PMCS,},
-+};
-+
-+static struct pfm_regmap_desc pfm_ia64gen_pmc_desc[] = {
-+/* pmc0  */ PMX_NA,
-+/* pmc1  */ PMX_NA,
-+/* pmc2  */ PMX_NA,
-+/* pmc3  */ PMX_NA,
-+/* pmc4  */ PMC_D(PFM_REG_W64, "PMC4", 0x0, PFM_IA64GEN_RSVD, PFM_IA64GEN_NO64, 4),
-+/* pmc5  */ PMC_D(PFM_REG_W64, "PMC5", 0x0, PFM_IA64GEN_RSVD, PFM_IA64GEN_NO64, 5),
-+/* pmc6  */ PMC_D(PFM_REG_W64, "PMC6", 0x0, PFM_IA64GEN_RSVD, PFM_IA64GEN_NO64, 6),
-+/* pmc7  */ PMC_D(PFM_REG_W64, "PMC7", 0x0, PFM_IA64GEN_RSVD, PFM_IA64GEN_NO64, 7)
-+};
-+#define PFM_IA64GEN_NUM_PMCS ARRAY_SIZE(pfm_ia64gen_pmc_desc)
-+
-+static struct pfm_regmap_desc pfm_ia64gen_pmd_desc[] = {
-+/* pmd0  */ PMX_NA,
-+/* pmd1  */ PMX_NA,
-+/* pmd2  */ PMX_NA,
-+/* pmd3  */ PMX_NA,
-+/* pmd4  */ PMD_DP(PFM_REG_C, "PMD4", 4, 1ull << 4),
-+/* pmd5  */ PMD_DP(PFM_REG_C, "PMD5", 5, 1ull << 5),
-+/* pmd6  */ PMD_DP(PFM_REG_C, "PMD6", 6, 1ull << 6),
-+/* pmd7  */ PMD_DP(PFM_REG_C, "PMD7", 7, 1ull << 7)
-+};
-+#define PFM_IA64GEN_NUM_PMDS ARRAY_SIZE(pfm_ia64gen_pmd_desc)
-+
-+static int pfm_ia64gen_pmc_check(struct pfm_context *ctx,
-+				 struct pfm_event_set *set,
-+				 struct pfarg_pmc *req)
-+{
-+#define PFM_IA64GEN_PMC_PM_POS6	(1UL<<6)
-+	u64 tmpval;
-+	int is_system;
-+
-+	is_system = ctx->flags.system;
-+	tmpval = req->reg_value;
-+
-+	switch (req->reg_num) {
-+	case  4:
-+	case  5:
-+	case  6:
-+	case  7:
-+		/* set pmc.oi for 64-bit emulation */
-+		tmpval |= 1UL << 5;
-+
-+		if (is_system)
-+			tmpval |= PFM_IA64GEN_PMC_PM_POS6;
-+		else
-+			tmpval &= ~PFM_IA64GEN_PMC_PM_POS6;
-+		break;
-+
-+	}
-+	req->reg_value = tmpval;
-+
-+	return 0;
-+}
-+
-+/*
-+ * matches anything
-+ */
-+static int pfm_ia64gen_probe_pmu(void)
-+{
-+	u64 pm_buffer[16];
-+	pal_perf_mon_info_u_t pm_info;
-+
-+	/*
-+	 * call PAL_PERFMON_INFO to retrieve counter width which
-+	 * is implementation specific
-+	 */
-+	if (ia64_pal_perf_mon_info(pm_buffer, &pm_info))
-+		return -1;
-+
-+	pfm_ia64gen_pmu_conf.counter_width = pm_info.pal_perf_mon_info_s.width;
-+
-+	return 0;
-+}
-+
-+/*
-+ * impl_pmcs, impl_pmds are computed at runtime to minimize errors!
-+ */
-+static struct pfm_pmu_config pfm_ia64gen_pmu_conf = {
-+	.pmu_name = "Generic IA-64",
-+	.counter_width = 0, /* computed from PAL_PERFMON_INFO */
-+	.pmd_desc = pfm_ia64gen_pmd_desc,
-+	.pmc_desc = pfm_ia64gen_pmc_desc,
-+	.probe_pmu = pfm_ia64gen_probe_pmu,
-+	.num_pmc_entries = PFM_IA64GEN_NUM_PMCS,
-+	.num_pmd_entries = PFM_IA64GEN_NUM_PMDS,
-+	.pmc_write_check = pfm_ia64gen_pmc_check,
-+	.version = "1.0",
-+	.flags = PFM_PMU_BUILTIN_FLAG,
-+	.owner = THIS_MODULE,
-+	.pmu_info = &pfm_ia64gen_pmu_info
-+	/* no read/write checkers */
-+};
-+
-+static int __init pfm_gen_pmu_init_module(void)
-+{
-+	return pfm_pmu_register(&pfm_ia64gen_pmu_conf);
-+}
-+
-+static void __exit pfm_gen_pmu_cleanup_module(void)
-+{
-+	pfm_pmu_unregister(&pfm_ia64gen_pmu_conf);
-+}
-+
-+module_init(pfm_gen_pmu_init_module);
-+module_exit(pfm_gen_pmu_cleanup_module);
-diff --git a/arch/ia64/perfmon/perfmon_itanium.c b/arch/ia64/perfmon/perfmon_itanium.c
-new file mode 100644
-index 0000000..094b31b
---- /dev/null
-+++ b/arch/ia64/perfmon/perfmon_itanium.c
-@@ -0,0 +1,232 @@
-+/*
-+ * This file contains the Itanium PMU register description tables
-+ * and pmc checker used by perfmon.c.
-+ *
-+ * Copyright (c) 2002-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+  */
-+#include <linux/module.h>
-+#include <linux/perfmon_kern.h>
-+
-+MODULE_AUTHOR("Stephane Eranian <eranian@hpl.hp.com>");
-+MODULE_DESCRIPTION("Itanium (Merced) PMU description tables");
-+MODULE_LICENSE("GPL");
-+
-+#define RDEP(x)	(1ULL << (x))
-+
-+#define PFM_ITA_MASK_PMCS (RDEP(4)|RDEP(5)|RDEP(6)|RDEP(7)|RDEP(10)|RDEP(11)|\
-+			   RDEP(12))
-+
-+#define PFM_ITA_NO64	(1ULL<<5)
-+
-+static struct pfm_arch_pmu_info pfm_ita_pmu_info = {
-+	.mask_pmcs = {PFM_ITA_MASK_PMCS,},
-+};
-+/* reserved bits are 1 in the mask */
-+#define PFM_ITA_RSVD 0xfffffffffc8000a0UL
-+/*
-+ * For debug registers, writing xBR(y) means we use also xBR(y+1). Hence using
-+ * PMC256+y means we use PMC256+y+1.  Yet, we do not have dependency information
-+ * but this is fine because they are handled separately in the IA-64 specific
-+ * code.
-+ */
-+static struct pfm_regmap_desc pfm_ita_pmc_desc[] = {
-+/* pmc0  */ PMX_NA,
-+/* pmc1  */ PMX_NA,
-+/* pmc2  */ PMX_NA,
-+/* pmc3  */ PMX_NA,
-+/* pmc4  */ PMC_D(PFM_REG_W64, "PMC4" , 0x20, PFM_ITA_RSVD, PFM_ITA_NO64, 4),
-+/* pmc5  */ PMC_D(PFM_REG_W64, "PMC5" , 0x20, PFM_ITA_RSVD, PFM_ITA_NO64, 5),
-+/* pmc6  */ PMC_D(PFM_REG_W64, "PMC6" , 0x20, PFM_ITA_RSVD, PFM_ITA_NO64, 6),
-+/* pmc7  */ PMC_D(PFM_REG_W64, "PMC7" , 0x20, PFM_ITA_RSVD, PFM_ITA_NO64, 7),
-+/* pmc8  */ PMC_D(PFM_REG_W  , "PMC8" , 0xfffffffe3ffffff8UL, 0xfff00000001c0000UL, 0, 8),
-+/* pmc9  */ PMC_D(PFM_REG_W  , "PMC9" , 0xfffffffe3ffffff8UL, 0xfff00000001c0000UL, 0, 9),
-+/* pmc10 */ PMC_D(PFM_REG_W  , "PMC10", 0x0, 0xfffffffff3f0ff30UL, 0, 10),
-+/* pmc11 */ PMC_D(PFM_REG_W  , "PMC11", 0x10000000UL, 0xffffffffecf0ff30UL, 0, 11),
-+/* pmc12 */ PMC_D(PFM_REG_W  , "PMC12", 0x0, 0xffffffffffff0030UL, 0, 12),
-+/* pmc13 */ PMC_D(PFM_REG_W  , "PMC13", 0x3ffff00000001UL, 0xfffffffffffffffeUL, 0, 13),
-+/* pmc14 */ PMX_NA,
-+/* pmc15 */ PMX_NA,
-+/* pmc16 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc24 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc32 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc40 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc48 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc56 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc64 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc72 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc80 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc88 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc96 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc104 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc112 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc120 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc128 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc136 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc144 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc152 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc160 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc168 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc176 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc184 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc192 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc200 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc208 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc216 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc224 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc232 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc240 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc248 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc256 */ PMC_D(PFM_REG_W  , "IBR0", 0x0, 0, 0, 0),
-+/* pmc257 */ PMC_D(PFM_REG_W  , "IBR1", 0x0, 0x8000000000000000UL, 0, 1),
-+/* pmc258 */ PMC_D(PFM_REG_W  , "IBR2", 0x0, 0, 0, 2),
-+/* pmc259 */ PMC_D(PFM_REG_W  , "IBR3", 0x0, 0x8000000000000000UL, 0, 3),
-+/* pmc260 */ PMC_D(PFM_REG_W  , "IBR4", 0x0, 0, 0, 4),
-+/* pmc261 */ PMC_D(PFM_REG_W  , "IBR5", 0x0, 0x8000000000000000UL, 0, 5),
-+/* pmc262 */ PMC_D(PFM_REG_W  , "IBR6", 0x0, 0, 0, 6),
-+/* pmc263 */ PMC_D(PFM_REG_W  , "IBR7", 0x0, 0x8000000000000000UL, 0, 7),
-+/* pmc264 */ PMC_D(PFM_REG_W  , "DBR0", 0x0, 0, 0, 0),
-+/* pmc265 */ PMC_D(PFM_REG_W  , "DBR1", 0x0, 0xc000000000000000UL, 0, 1),
-+/* pmc266 */ PMC_D(PFM_REG_W  , "DBR2", 0x0, 0, 0, 2),
-+/* pmc267 */ PMC_D(PFM_REG_W  , "DBR3", 0x0, 0xc000000000000000UL, 0, 3),
-+/* pmc268 */ PMC_D(PFM_REG_W  , "DBR4", 0x0, 0, 0, 4),
-+/* pmc269 */ PMC_D(PFM_REG_W  , "DBR5", 0x0, 0xc000000000000000UL, 0, 5),
-+/* pmc270 */ PMC_D(PFM_REG_W  , "DBR6", 0x0, 0, 0, 6),
-+/* pmc271 */ PMC_D(PFM_REG_W  , "DBR7", 0x0, 0xc000000000000000UL, 0, 7)
-+};
-+#define PFM_ITA_NUM_PMCS ARRAY_SIZE(pfm_ita_pmc_desc)
-+
-+static struct pfm_regmap_desc pfm_ita_pmd_desc[] = {
-+/* pmd0  */ PMD_DP(PFM_REG_I , "PMD0", 0, 1ull << 10),
-+/* pmd1  */ PMD_DP(PFM_REG_I , "PMD1", 1, 1ull << 10),
-+/* pmd2  */ PMD_DP(PFM_REG_I , "PMD2", 2, 1ull << 11),
-+/* pmd3  */ PMD_DP(PFM_REG_I , "PMD3", 3, 1ull << 11),
-+/* pmd4  */ PMD_DP(PFM_REG_C , "PMD4", 4, 1ull << 4),
-+/* pmd5  */ PMD_DP(PFM_REG_C , "PMD5", 5, 1ull << 5),
-+/* pmd6  */ PMD_DP(PFM_REG_C , "PMD6", 6, 1ull << 6),
-+/* pmd7  */ PMD_DP(PFM_REG_C , "PMD7", 7, 1ull << 7),
-+/* pmd8  */ PMD_DP(PFM_REG_I , "PMD8", 8, 1ull << 12),
-+/* pmd9  */ PMD_DP(PFM_REG_I , "PMD9", 9, 1ull << 12),
-+/* pmd10 */ PMD_DP(PFM_REG_I , "PMD10", 10, 1ull << 12),
-+/* pmd11 */ PMD_DP(PFM_REG_I , "PMD11", 11, 1ull << 12),
-+/* pmd12 */ PMD_DP(PFM_REG_I , "PMD12", 12, 1ull << 12),
-+/* pmd13 */ PMD_DP(PFM_REG_I , "PMD13", 13, 1ull << 12),
-+/* pmd14 */ PMD_DP(PFM_REG_I , "PMD14", 14, 1ull << 12),
-+/* pmd15 */ PMD_DP(PFM_REG_I , "PMD15", 15, 1ull << 12),
-+/* pmd16 */ PMD_DP(PFM_REG_I , "PMD16", 16, 1ull << 12),
-+/* pmd17 */ PMD_DP(PFM_REG_I , "PMD17", 17, 1ull << 11)
-+};
-+#define PFM_ITA_NUM_PMDS ARRAY_SIZE(pfm_ita_pmd_desc)
-+
-+static int pfm_ita_pmc_check(struct pfm_context *ctx,
-+			     struct pfm_event_set *set,
-+			     struct pfarg_pmc *req)
-+{
-+#define PFM_ITA_PMC_PM_POS6	(1UL<<6)
-+	struct pfm_arch_context *ctx_arch;
-+	u64 tmpval;
-+	u16 cnum;
-+	int ret = 0, is_system;
-+
-+	tmpval = req->reg_value;
-+	cnum   = req->reg_num;
-+	ctx_arch = pfm_ctx_arch(ctx);
-+	is_system = ctx->flags.system;
-+
-+	switch (cnum) {
-+	case  4:
-+	case  5:
-+	case  6:
-+	case  7:
-+	case 10:
-+	case 11:
-+	case 12:
-+		if (is_system)
-+			tmpval |= PFM_ITA_PMC_PM_POS6;
-+		else
-+			tmpval &= ~PFM_ITA_PMC_PM_POS6;
-+		break;
-+	}
-+
-+	/*
-+	 * we must clear the (instruction) debug registers if pmc13.ta bit is
-+	 * cleared before they are written (fl_using_dbreg==0) to avoid
-+	 * picking up stale information.
-+	 */
-+	if (cnum == 13 && ((tmpval & 0x1) == 0)
-+		&& ctx_arch->flags.use_dbr == 0) {
-+		PFM_DBG("pmc13 has pmc13.ta cleared, clearing ibr");
-+		ret = pfm_ia64_mark_dbregs_used(ctx, set);
-+		if (ret)
-+			return ret;
-+	}
-+
-+	/*
-+	 * we must clear the (data) debug registers if pmc11.pt bit is cleared
-+	 * before they are written (fl_using_dbreg==0) to avoid picking up
-+	 * stale information.
-+	 */
-+	if (cnum == 11 && ((tmpval >> 28) & 0x1) == 0
-+		&& ctx_arch->flags.use_dbr == 0) {
-+		PFM_DBG("pmc11 has pmc11.pt cleared, clearing dbr");
-+		ret = pfm_ia64_mark_dbregs_used(ctx, set);
-+		if (ret)
-+			return ret;
-+	}
-+
-+	req->reg_value = tmpval;
-+
-+	return 0;
-+}
-+
-+static int pfm_ita_probe_pmu(void)
-+{
-+	return local_cpu_data->family == 0x7 && !ia64_platform_is("hpsim")
-+		? 0 : -1;
-+}
-+
-+/*
-+ * impl_pmcs, impl_pmds are computed at runtime to minimize errors!
-+ */
-+static struct pfm_pmu_config pfm_ita_pmu_conf = {
-+	.pmu_name = "Itanium",
-+	.counter_width = 32,
-+	.pmd_desc = pfm_ita_pmd_desc,
-+	.pmc_desc = pfm_ita_pmc_desc,
-+	.pmc_write_check = pfm_ita_pmc_check,
-+	.num_pmc_entries = PFM_ITA_NUM_PMCS,
-+	.num_pmd_entries = PFM_ITA_NUM_PMDS,
-+	.probe_pmu = pfm_ita_probe_pmu,
-+	.version = "1.0",
-+	.flags = PFM_PMU_BUILTIN_FLAG,
-+	.owner = THIS_MODULE,
-+	.pmu_info = &pfm_ita_pmu_info
-+};
-+
-+static int __init pfm_ita_pmu_init_module(void)
-+{
-+	return pfm_pmu_register(&pfm_ita_pmu_conf);
-+}
-+
-+static void __exit pfm_ita_pmu_cleanup_module(void)
-+{
-+	pfm_pmu_unregister(&pfm_ita_pmu_conf);
-+}
-+
-+module_init(pfm_ita_pmu_init_module);
-+module_exit(pfm_ita_pmu_cleanup_module);
-+
-diff --git a/arch/ia64/perfmon/perfmon_mckinley.c b/arch/ia64/perfmon/perfmon_mckinley.c
-new file mode 100644
-index 0000000..dc59092
---- /dev/null
-+++ b/arch/ia64/perfmon/perfmon_mckinley.c
-@@ -0,0 +1,290 @@
-+/*
-+ * This file contains the McKinley PMU register description tables
-+ * and pmc checker used by perfmon.c.
-+ *
-+ * Copyright (c) 2002-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+  */
-+#include <linux/module.h>
-+#include <linux/perfmon_kern.h>
-+
-+MODULE_AUTHOR("Stephane Eranian <eranian@hpl.hp.com>");
-+MODULE_DESCRIPTION("Itanium 2 (McKinley) PMU description tables");
-+MODULE_LICENSE("GPL");
-+
-+#define RDEP(x)	(1UL << (x))
-+
-+#define PFM_MCK_MASK_PMCS (RDEP(4)|RDEP(5)|RDEP(6)|RDEP(7)|RDEP(10)|RDEP(11)|\
-+			   RDEP(12))
-+
-+#define PFM_MCK_NO64	(1UL<<5)
-+
-+static struct pfm_arch_pmu_info pfm_mck_pmu_info = {
-+	.mask_pmcs = {PFM_MCK_MASK_PMCS,},
-+};
-+
-+/* reserved bits are 1 in the mask */
-+#define PFM_ITA2_RSVD 0xfffffffffc8000a0UL
-+
-+/*
-+ * For debug registers, writing xBR(y) means we use also xBR(y+1). Hence using
-+ * PMC256+y means we use PMC256+y+1.  Yet, we do not have dependency information
-+ * but this is fine because they are handled separately in the IA-64 specific
-+ * code.
-+ */
-+static struct pfm_regmap_desc pfm_mck_pmc_desc[] = {
-+/* pmc0  */ PMX_NA,
-+/* pmc1  */ PMX_NA,
-+/* pmc2  */ PMX_NA,
-+/* pmc3  */ PMX_NA,
-+/* pmc4  */ PMC_D(PFM_REG_W64, "PMC4" , 0x800020UL, 0xfffffffffc8000a0, PFM_MCK_NO64, 4),
-+/* pmc5  */ PMC_D(PFM_REG_W64, "PMC5" , 0x20UL, PFM_ITA2_RSVD, PFM_MCK_NO64, 5),
-+/* pmc6  */ PMC_D(PFM_REG_W64, "PMC6" , 0x20UL, PFM_ITA2_RSVD, PFM_MCK_NO64, 6),
-+/* pmc7  */ PMC_D(PFM_REG_W64, "PMC7" , 0x20UL, PFM_ITA2_RSVD, PFM_MCK_NO64, 7),
-+/* pmc8  */ PMC_D(PFM_REG_W  , "PMC8" , 0xffffffff3fffffffUL, 0xc0000004UL, 0, 8),
-+/* pmc9  */ PMC_D(PFM_REG_W  , "PMC9" , 0xffffffff3ffffffcUL, 0xc0000004UL, 0, 9),
-+/* pmc10 */ PMC_D(PFM_REG_W  , "PMC10", 0x0, 0xffffffffffff0000UL, 0, 10),
-+/* pmc11 */ PMC_D(PFM_REG_W  , "PMC11", 0x0, 0xfffffffffcf0fe30UL, 0, 11),
-+/* pmc12 */ PMC_D(PFM_REG_W  , "PMC12", 0x0, 0xffffffffffff0000UL, 0, 12),
-+/* pmc13 */ PMC_D(PFM_REG_W  , "PMC13", 0x2078fefefefeUL, 0xfffe1fffe7e7e7e7UL, 0, 13),
-+/* pmc14 */ PMC_D(PFM_REG_W  , "PMC14", 0x0db60db60db60db6UL, 0xffffffffffffdb6dUL, 0, 14),
-+/* pmc15 */ PMC_D(PFM_REG_W  , "PMC15", 0xfffffff0UL, 0xfffffffffffffff0UL, 0, 15),
-+/* pmc16 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc24 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc32 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc40 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc48 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc56 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc64 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc72 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc80 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc88 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc96 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc104 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc112 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc120 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc128 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc136 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc144 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc152 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc160 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc168 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc176 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc184 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc192 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc200 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc208 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc216 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc224 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc232 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc240 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc248 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc256 */ PMC_D(PFM_REG_W  , "IBR0", 0x0, 0, 0, 0),
-+/* pmc257 */ PMC_D(PFM_REG_W  , "IBR1", 0x0, 0x8000000000000000UL, 0, 1),
-+/* pmc258 */ PMC_D(PFM_REG_W  , "IBR2", 0x0, 0, 0, 2),
-+/* pmc259 */ PMC_D(PFM_REG_W  , "IBR3", 0x0, 0x8000000000000000UL, 0, 3),
-+/* pmc260 */ PMC_D(PFM_REG_W  , "IBR4", 0x0, 0, 0, 4),
-+/* pmc261 */ PMC_D(PFM_REG_W  , "IBR5", 0x0, 0x8000000000000000UL, 0, 5),
-+/* pmc262 */ PMC_D(PFM_REG_W  , "IBR6", 0x0, 0, 0, 6),
-+/* pmc263 */ PMC_D(PFM_REG_W  , "IBR7", 0x0, 0x8000000000000000UL, 0, 7),
-+/* pmc264 */ PMC_D(PFM_REG_W  , "DBR0", 0x0, 0, 0, 0),
-+/* pmc265 */ PMC_D(PFM_REG_W  , "DBR1", 0x0, 0xc000000000000000UL, 0, 1),
-+/* pmc266 */ PMC_D(PFM_REG_W  , "DBR2", 0x0, 0, 0, 2),
-+/* pmc267 */ PMC_D(PFM_REG_W  , "DBR3", 0x0, 0xc000000000000000UL, 0, 3),
-+/* pmc268 */ PMC_D(PFM_REG_W  , "DBR4", 0x0, 0, 0, 4),
-+/* pmc269 */ PMC_D(PFM_REG_W  , "DBR5", 0x0, 0xc000000000000000UL, 0, 5),
-+/* pmc270 */ PMC_D(PFM_REG_W  , "DBR6", 0x0, 0, 0, 6),
-+/* pmc271 */ PMC_D(PFM_REG_W  , "DBR7", 0x0, 0xc000000000000000UL, 0, 7)
-+};
-+#define PFM_MCK_NUM_PMCS ARRAY_SIZE(pfm_mck_pmc_desc)
-+
-+static struct pfm_regmap_desc pfm_mck_pmd_desc[] = {
-+/* pmd0  */ PMD_DP(PFM_REG_I, "PMD0", 0, 1ull << 10),
-+/* pmd1  */ PMD_DP(PFM_REG_I, "PMD1", 1, 1ull << 10),
-+/* pmd2  */ PMD_DP(PFM_REG_I, "PMD2", 2, 1ull << 11),
-+/* pmd3  */ PMD_DP(PFM_REG_I, "PMD3", 3, 1ull << 11),
-+/* pmd4  */ PMD_DP(PFM_REG_C, "PMD4", 4, 1ull << 4),
-+/* pmd5  */ PMD_DP(PFM_REG_C, "PMD5", 5, 1ull << 5),
-+/* pmd6  */ PMD_DP(PFM_REG_C, "PMD6", 6, 1ull << 6),
-+/* pmd7  */ PMD_DP(PFM_REG_C, "PMD7", 7, 1ull << 7),
-+/* pmd8  */ PMD_DP(PFM_REG_I, "PMD8", 8, 1ull << 12),
-+/* pmd9  */ PMD_DP(PFM_REG_I, "PMD9", 9, 1ull << 12),
-+/* pmd10 */ PMD_DP(PFM_REG_I, "PMD10", 10, 1ull << 12),
-+/* pmd11 */ PMD_DP(PFM_REG_I, "PMD11", 11, 1ull << 12),
-+/* pmd12 */ PMD_DP(PFM_REG_I, "PMD12", 12, 1ull << 12),
-+/* pmd13 */ PMD_DP(PFM_REG_I, "PMD13", 13, 1ull << 12),
-+/* pmd14 */ PMD_DP(PFM_REG_I, "PMD14", 14, 1ull << 12),
-+/* pmd15 */ PMD_DP(PFM_REG_I, "PMD15", 15, 1ull << 12),
-+/* pmd16 */ PMD_DP(PFM_REG_I, "PMD16", 16, 1ull << 12),
-+/* pmd17 */ PMD_DP(PFM_REG_I, "PMD17", 17, 1ull << 11)
-+};
-+#define PFM_MCK_NUM_PMDS ARRAY_SIZE(pfm_mck_pmd_desc)
-+
-+static int pfm_mck_pmc_check(struct pfm_context *ctx,
-+			     struct pfm_event_set *set,
-+			     struct pfarg_pmc *req)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+	u64 val8 = 0, val14 = 0, val13 = 0;
-+	u64 tmpval;
-+	u16 cnum;
-+	int ret = 0, check_case1 = 0;
-+	int is_system;
-+
-+	tmpval = req->reg_value;
-+	cnum = req->reg_num;
-+	ctx_arch = pfm_ctx_arch(ctx);
-+	is_system = ctx->flags.system;
-+
-+#define PFM_MCK_PMC_PM_POS6	(1UL<<6)
-+#define PFM_MCK_PMC_PM_POS4	(1UL<<4)
-+
-+	switch (cnum) {
-+	case  4:
-+	case  5:
-+	case  6:
-+	case  7:
-+	case 11:
-+	case 12:
-+		if (is_system)
-+			tmpval |= PFM_MCK_PMC_PM_POS6;
-+		else
-+			tmpval &= ~PFM_MCK_PMC_PM_POS6;
-+		break;
-+
-+	case  8:
-+		val8 = tmpval;
-+		val13 = set->pmcs[13];
-+		val14 = set->pmcs[14];
-+		check_case1 = 1;
-+		break;
-+
-+	case 10:
-+		if (is_system)
-+			tmpval |= PFM_MCK_PMC_PM_POS4;
-+		else
-+			tmpval &= ~PFM_MCK_PMC_PM_POS4;
-+		break;
-+
-+	case 13:
-+		val8 = set->pmcs[8];
-+		val13 = tmpval;
-+		val14 = set->pmcs[14];
-+		check_case1 = 1;
-+		break;
-+
-+	case 14:
-+		val8 = set->pmcs[8];
-+		val13 = set->pmcs[13];
-+		val14 = tmpval;
-+		check_case1 = 1;
-+		break;
-+	}
-+
-+	/*
-+	 * check illegal configuration which can produce inconsistencies
-+	 * in tagging i-side events in L1D and L2 caches
-+	 */
-+	if (check_case1) {
-+		ret = (((val13 >> 45) & 0xf) == 0 && ((val8 & 0x1) == 0))
-+			&& ((((val14>>1) & 0x3) == 0x2 || ((val14>>1) & 0x3) == 0x0)
-+			|| (((val14>>4) & 0x3) == 0x2 || ((val14>>4) & 0x3) == 0x0));
-+
-+		if (ret) {
-+			PFM_DBG("perfmon: invalid config pmc8=0x%lx "
-+				"pmc13=0x%lx pmc14=0x%lx",
-+				val8, val13, val14);
-+			return -EINVAL;
-+		}
-+	}
-+
-+	/*
-+	 * check if configuration implicitely activates the use of
-+	 * the debug registers. If true, then we ensure that this is
-+	 * possible and that we do not pick up stale value in the HW
-+	 * registers.
-+	 *
-+	 * We postpone the checks of pmc13 and pmc14 to avoid side effects
-+	 * in case of errors
-+	 */
-+
-+	/*
-+	 * pmc13 is "active" if:
-+	 * 	one of the pmc13.cfg_dbrpXX field is different from 0x3
-+	 * AND
-+	 * 	at the corresponding pmc13.ena_dbrpXX is set.
-+	 */
-+	if (cnum == 13 && (tmpval & 0x1e00000000000UL)
-+	    && (tmpval & 0x18181818UL) != 0x18181818UL
-+		&& ctx_arch->flags.use_dbr == 0) {
-+		PFM_DBG("pmc13=0x%lx active", tmpval);
-+		ret = pfm_ia64_mark_dbregs_used(ctx, set);
-+		if (ret)
-+			return ret;
-+	}
-+
-+	/*
-+	 *  if any pmc14.ibrpX bit is enabled we must clear the ibrs
-+	 */
-+	if (cnum == 14 && ((tmpval & 0x2222UL) != 0x2222UL)
-+		&& ctx_arch->flags.use_dbr == 0) {
-+		PFM_DBG("pmc14=0x%lx active", tmpval);
-+		ret = pfm_ia64_mark_dbregs_used(ctx, set);
-+		if (ret)
-+			return ret;
-+	}
-+
-+	req->reg_value = tmpval;
-+
-+	return 0;
-+}
-+
-+static int pfm_mck_probe_pmu(void)
-+{
-+	return local_cpu_data->family == 0x1f ? 0 : -1;
-+}
-+
-+/*
-+ * impl_pmcs, impl_pmds are computed at runtime to minimize errors!
-+ */
-+static struct pfm_pmu_config pfm_mck_pmu_conf = {
-+	.pmu_name = "Itanium 2",
-+	.counter_width = 47,
-+	.pmd_desc = pfm_mck_pmd_desc,
-+	.pmc_desc = pfm_mck_pmc_desc,
-+	.pmc_write_check = pfm_mck_pmc_check,
-+	.num_pmc_entries = PFM_MCK_NUM_PMCS,
-+	.num_pmd_entries = PFM_MCK_NUM_PMDS,
-+	.probe_pmu = pfm_mck_probe_pmu,
-+	.version = "1.0",
-+	.flags = PFM_PMU_BUILTIN_FLAG,
-+	.owner = THIS_MODULE,
-+	.pmu_info = &pfm_mck_pmu_info,
-+};
-+
-+static int __init pfm_mck_pmu_init_module(void)
-+{
-+	return pfm_pmu_register(&pfm_mck_pmu_conf);
-+}
-+
-+static void __exit pfm_mck_pmu_cleanup_module(void)
-+{
-+	pfm_pmu_unregister(&pfm_mck_pmu_conf);
-+}
-+
-+module_init(pfm_mck_pmu_init_module);
-+module_exit(pfm_mck_pmu_cleanup_module);
-diff --git a/arch/ia64/perfmon/perfmon_montecito.c b/arch/ia64/perfmon/perfmon_montecito.c
-new file mode 100644
-index 0000000..3f76f73
---- /dev/null
-+++ b/arch/ia64/perfmon/perfmon_montecito.c
-@@ -0,0 +1,412 @@
-+/*
-+ * This file contains the McKinley PMU register description tables
-+ * and pmc checker used by perfmon.c.
-+ *
-+ * Copyright (c) 2005-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+  */
-+#include <linux/module.h>
-+#include <linux/smp.h>
-+#include <linux/perfmon_kern.h>
-+
-+MODULE_AUTHOR("Stephane Eranian <eranian@hpl.hp.com>");
-+MODULE_DESCRIPTION("Dual-Core Itanium 2 (Montecito) PMU description table");
-+MODULE_LICENSE("GPL");
-+
-+#define RDEP(x)	(1UL << (x))
-+
-+#define PFM_MONT_MASK_PMCS (RDEP(4)|RDEP(5)|RDEP(6)|RDEP(7)|\
-+			    RDEP(8)|RDEP(9)|RDEP(10)|RDEP(11)|\
-+			    RDEP(12)|RDEP(13)|RDEP(14)|RDEP(15)|\
-+			    RDEP(37)|RDEP(39)|RDEP(40)|RDEP(42))
-+
-+#define PFM_MONT_NO64	(1UL<<5)
-+
-+static struct pfm_arch_pmu_info pfm_mont_pmu_info = {
-+	.mask_pmcs = {PFM_MONT_MASK_PMCS,},
-+};
-+
-+#define PFM_MONT_RSVD 0xffffffff838000a0UL
-+/*
-+ *
-+ * For debug registers, writing xBR(y) means we use also xBR(y+1). Hence using
-+ * PMC256+y means we use PMC256+y+1.  Yet, we do not have dependency information
-+ * but this is fine because they are handled separately in the IA-64 specific
-+ * code.
-+ *
-+ * For PMC4-PMC15, PMC40: we force pmc.ism=2 (IA-64 mode only)
-+ */
-+static struct pfm_regmap_desc pfm_mont_pmc_desc[] = {
-+/* pmc0  */ PMX_NA,
-+/* pmc1  */ PMX_NA,
-+/* pmc2  */ PMX_NA,
-+/* pmc3  */ PMX_NA,
-+/* pmc4  */ PMC_D(PFM_REG_W64, "PMC4" , 0x2000020UL, PFM_MONT_RSVD, PFM_MONT_NO64, 4),
-+/* pmc5  */ PMC_D(PFM_REG_W64, "PMC5" , 0x2000020UL, PFM_MONT_RSVD, PFM_MONT_NO64, 5),
-+/* pmc6  */ PMC_D(PFM_REG_W64, "PMC6" , 0x2000020UL, PFM_MONT_RSVD, PFM_MONT_NO64, 6),
-+/* pmc7  */ PMC_D(PFM_REG_W64, "PMC7" , 0x2000020UL, PFM_MONT_RSVD, PFM_MONT_NO64, 7),
-+/* pmc8  */ PMC_D(PFM_REG_W64, "PMC8" , 0x2000020UL, PFM_MONT_RSVD, PFM_MONT_NO64, 8),
-+/* pmc9  */ PMC_D(PFM_REG_W64, "PMC9" , 0x2000020UL, PFM_MONT_RSVD, PFM_MONT_NO64, 9),
-+/* pmc10 */ PMC_D(PFM_REG_W64, "PMC10", 0x2000020UL, PFM_MONT_RSVD, PFM_MONT_NO64, 10),
-+/* pmc11 */ PMC_D(PFM_REG_W64, "PMC11", 0x2000020UL, PFM_MONT_RSVD, PFM_MONT_NO64, 11),
-+/* pmc12 */ PMC_D(PFM_REG_W64, "PMC12", 0x2000020UL, PFM_MONT_RSVD, PFM_MONT_NO64, 12),
-+/* pmc13 */ PMC_D(PFM_REG_W64, "PMC13", 0x2000020UL, PFM_MONT_RSVD, PFM_MONT_NO64, 13),
-+/* pmc14 */ PMC_D(PFM_REG_W64, "PMC14", 0x2000020UL, PFM_MONT_RSVD, PFM_MONT_NO64, 14),
-+/* pmc15 */ PMC_D(PFM_REG_W64, "PMC15", 0x2000020UL, PFM_MONT_RSVD, PFM_MONT_NO64, 15),
-+/* pmc16 */ PMX_NA,
-+/* pmc17 */ PMX_NA,
-+/* pmc18 */ PMX_NA,
-+/* pmc19 */ PMX_NA,
-+/* pmc20 */ PMX_NA,
-+/* pmc21 */ PMX_NA,
-+/* pmc22 */ PMX_NA,
-+/* pmc23 */ PMX_NA,
-+/* pmc24 */ PMX_NA,
-+/* pmc25 */ PMX_NA,
-+/* pmc26 */ PMX_NA,
-+/* pmc27 */ PMX_NA,
-+/* pmc28 */ PMX_NA,
-+/* pmc29 */ PMX_NA,
-+/* pmc30 */ PMX_NA,
-+/* pmc31 */ PMX_NA,
-+/* pmc32 */ PMC_D(PFM_REG_W , "PMC32", 0x30f01ffffffffffUL, 0xfcf0fe0000000000UL, 0, 32),
-+/* pmc33 */ PMC_D(PFM_REG_W , "PMC33", 0x0, 0xfffffe0000000000UL, 0, 33),
-+/* pmc34 */ PMC_D(PFM_REG_W , "PMC34", 0xf01ffffffffffUL, 0xfff0fe0000000000UL, 0, 34),
-+/* pmc35 */ PMC_D(PFM_REG_W , "PMC35", 0x0,  0x1ffffffffffUL, 0, 35),
-+/* pmc36 */ PMC_D(PFM_REG_W , "PMC36", 0xfffffff0UL, 0xfffffffffffffff0UL, 0, 36),
-+/* pmc37 */ PMC_D(PFM_REG_W , "PMC37", 0x0, 0xffffffffffffc000UL, 0, 37),
-+/* pmc38 */ PMC_D(PFM_REG_W , "PMC38", 0xdb6UL, 0xffffffffffffdb6dUL, 0, 38),
-+/* pmc39 */ PMC_D(PFM_REG_W , "PMC39", 0x0, 0xffffffffffff0030UL, 0, 39),
-+/* pmc40 */ PMC_D(PFM_REG_W , "PMC40", 0x2000000UL, 0xfffffffffff0fe30UL, 0, 40),
-+/* pmc41 */ PMC_D(PFM_REG_W , "PMC41", 0x00002078fefefefeUL, 0xfffe1fffe7e7e7e7UL, 0, 41),
-+/* pmc42 */ PMC_D(PFM_REG_W , "PMC42", 0x0, 0xfff800b0UL, 0, 42),
-+/* pmc43 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc48 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc56 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc64 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc72 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc80 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc88 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc96 */  PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc104 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc112 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc120 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc128 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc136 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc144 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc152 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc160 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc168 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc176 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc184 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc192 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc200 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc208 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc216 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc224 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc232 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc240 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc248 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc256 */ PMC_D(PFM_REG_W, "IBR0", 0x0, 0, 0, 0),
-+/* pmc257 */ PMC_D(PFM_REG_W, "IBR1", 0x0, 0x8000000000000000UL, 0, 1),
-+/* pmc258 */ PMC_D(PFM_REG_W, "IBR2", 0x0, 0, 0, 2),
-+/* pmc259 */ PMC_D(PFM_REG_W, "IBR3", 0x0, 0x8000000000000000UL, 0, 3),
-+/* pmc260 */ PMC_D(PFM_REG_W, "IBR4", 0x0, 0, 0, 4),
-+/* pmc261 */ PMC_D(PFM_REG_W, "IBR5", 0x0, 0x8000000000000000UL, 0, 5),
-+/* pmc262 */ PMC_D(PFM_REG_W, "IBR6", 0x0, 0, 0, 6),
-+/* pmc263 */ PMC_D(PFM_REG_W, "IBR7", 0x0, 0x8000000000000000UL, 0, 7),
-+/* pmc264 */ PMC_D(PFM_REG_W, "DBR0", 0x0, 0, 0, 0),
-+/* pmc265 */ PMC_D(PFM_REG_W, "DBR1", 0x0, 0xc000000000000000UL, 0, 1),
-+/* pmc266 */ PMC_D(PFM_REG_W, "DBR2", 0x0, 0, 0, 2),
-+/* pmc267 */ PMC_D(PFM_REG_W, "DBR3", 0x0, 0xc000000000000000UL, 0, 3),
-+/* pmc268 */ PMC_D(PFM_REG_W, "DBR4", 0x0, 0, 0, 4),
-+/* pmc269 */ PMC_D(PFM_REG_W, "DBR5", 0x0, 0xc000000000000000UL, 0, 5),
-+/* pmc270 */ PMC_D(PFM_REG_W, "DBR6", 0x0, 0, 0, 6),
-+/* pmc271 */ PMC_D(PFM_REG_W, "DBR7", 0x0, 0xc000000000000000UL, 0, 7)
-+};
-+#define PFM_MONT_NUM_PMCS ARRAY_SIZE(pfm_mont_pmc_desc)
-+
-+static struct pfm_regmap_desc pfm_mont_pmd_desc[] = {
-+/* pmd0  */ PMX_NA,
-+/* pmd1  */ PMX_NA,
-+/* pmd2  */ PMX_NA,
-+/* pmd3  */ PMX_NA,
-+/* pmd4  */ PMD_DP(PFM_REG_C, "PMD4", 4, 1ull << 4),
-+/* pmd5  */ PMD_DP(PFM_REG_C, "PMD5", 5, 1ull << 5),
-+/* pmd6  */ PMD_DP(PFM_REG_C, "PMD6", 6, 1ull << 6),
-+/* pmd7  */ PMD_DP(PFM_REG_C, "PMD7", 7, 1ull << 7),
-+/* pmd8  */ PMD_DP(PFM_REG_C, "PMD8", 8, 1ull << 8),
-+/* pmd9  */ PMD_DP(PFM_REG_C, "PMD9", 9, 1ull << 9),
-+/* pmd10 */ PMD_DP(PFM_REG_C, "PMD10", 10, 1ull << 10),
-+/* pmd11 */ PMD_DP(PFM_REG_C, "PMD11", 11, 1ull << 11),
-+/* pmd12 */ PMD_DP(PFM_REG_C, "PMD12", 12, 1ull << 12),
-+/* pmd13 */ PMD_DP(PFM_REG_C, "PMD13", 13, 1ull << 13),
-+/* pmd14 */ PMD_DP(PFM_REG_C, "PMD14", 14, 1ull << 14),
-+/* pmd15 */ PMD_DP(PFM_REG_C, "PMD15", 15, 1ull << 15),
-+/* pmd16 */ PMX_NA,
-+/* pmd17 */ PMX_NA,
-+/* pmd18 */ PMX_NA,
-+/* pmd19 */ PMX_NA,
-+/* pmd20 */ PMX_NA,
-+/* pmd21 */ PMX_NA,
-+/* pmd22 */ PMX_NA,
-+/* pmd23 */ PMX_NA,
-+/* pmd24 */ PMX_NA,
-+/* pmd25 */ PMX_NA,
-+/* pmd26 */ PMX_NA,
-+/* pmd27 */ PMX_NA,
-+/* pmd28 */ PMX_NA,
-+/* pmd29 */ PMX_NA,
-+/* pmd30 */ PMX_NA,
-+/* pmd31 */ PMX_NA,
-+/* pmd32 */ PMD_DP(PFM_REG_I, "PMD32", 32, 1ull << 40),
-+/* pmd33 */ PMD_DP(PFM_REG_I, "PMD33", 33, 1ull << 40),
-+/* pmd34 */ PMD_DP(PFM_REG_I, "PMD34", 34, 1ull << 37),
-+/* pmd35 */ PMD_DP(PFM_REG_I, "PMD35", 35, 1ull << 37),
-+/* pmd36 */ PMD_DP(PFM_REG_I, "PMD36", 36, 1ull << 40),
-+/* pmd37 */ PMX_NA,
-+/* pmd38 */ PMD_DP(PFM_REG_I, "PMD38", 38, (1ull<<39)|(1ull<<42)),
-+/* pmd39 */ PMD_DP(PFM_REG_I, "PMD39", 39, (1ull<<39)|(1ull<<42)),
-+/* pmd40 */ PMX_NA,
-+/* pmd41 */ PMX_NA,
-+/* pmd42 */ PMX_NA,
-+/* pmd43 */ PMX_NA,
-+/* pmd44 */ PMX_NA,
-+/* pmd45 */ PMX_NA,
-+/* pmd46 */ PMX_NA,
-+/* pmd47 */ PMX_NA,
-+/* pmd48 */ PMD_DP(PFM_REG_I, "PMD48", 48, (1ull<<39)|(1ull<<42)),
-+/* pmd49 */ PMD_DP(PFM_REG_I, "PMD49", 49, (1ull<<39)|(1ull<<42)),
-+/* pmd50 */ PMD_DP(PFM_REG_I, "PMD50", 50, (1ull<<39)|(1ull<<42)),
-+/* pmd51 */ PMD_DP(PFM_REG_I, "PMD51", 51, (1ull<<39)|(1ull<<42)),
-+/* pmd52 */ PMD_DP(PFM_REG_I, "PMD52", 52, (1ull<<39)|(1ull<<42)),
-+/* pmd53 */ PMD_DP(PFM_REG_I, "PMD53", 53, (1ull<<39)|(1ull<<42)),
-+/* pmd54 */ PMD_DP(PFM_REG_I, "PMD54", 54, (1ull<<39)|(1ull<<42)),
-+/* pmd55 */ PMD_DP(PFM_REG_I, "PMD55", 55, (1ull<<39)|(1ull<<42)),
-+/* pmd56 */ PMD_DP(PFM_REG_I, "PMD56", 56, (1ull<<39)|(1ull<<42)),
-+/* pmd57 */ PMD_DP(PFM_REG_I, "PMD57", 57, (1ull<<39)|(1ull<<42)),
-+/* pmd58 */ PMD_DP(PFM_REG_I, "PMD58", 58, (1ull<<39)|(1ull<<42)),
-+/* pmd59 */ PMD_DP(PFM_REG_I, "PMD59", 59, (1ull<<39)|(1ull<<42)),
-+/* pmd60 */ PMD_DP(PFM_REG_I, "PMD60", 60, (1ull<<39)|(1ull<<42)),
-+/* pmd61 */ PMD_DP(PFM_REG_I, "PMD61", 61, (1ull<<39)|(1ull<<42)),
-+/* pmd62 */ PMD_DP(PFM_REG_I, "PMD62", 62, (1ull<<39)|(1ull<<42)),
-+/* pmd63 */ PMD_DP(PFM_REG_I, "PMD63", 63, (1ull<<39)|(1ull<<42))
-+};
-+#define PFM_MONT_NUM_PMDS ARRAY_SIZE(pfm_mont_pmd_desc)
-+
-+static int pfm_mont_has_ht;
-+
-+static int pfm_mont_pmc_check(struct pfm_context *ctx,
-+			      struct pfm_event_set *set,
-+			      struct pfarg_pmc *req)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+	u64 val32 = 0, val38 = 0, val41 = 0;
-+	u64 tmpval;
-+	u16 cnum;
-+	int ret = 0, check_case1 = 0;
-+	int is_system;
-+
-+	tmpval = req->reg_value;
-+	cnum = req->reg_num;
-+	ctx_arch = pfm_ctx_arch(ctx);
-+	is_system = ctx->flags.system;
-+
-+#define PFM_MONT_PMC_PM_POS6	(1UL<<6)
-+#define PFM_MONT_PMC_PM_POS4	(1UL<<4)
-+
-+	switch (cnum) {
-+	case  4:
-+	case  5:
-+	case  6:
-+	case  7:
-+	case  8:
-+	case  9:
-+		if (is_system)
-+			tmpval |= PFM_MONT_PMC_PM_POS6;
-+		else
-+			tmpval &= ~PFM_MONT_PMC_PM_POS6;
-+		break;
-+	case 10:
-+	case 11:
-+	case 12:
-+	case 13:
-+	case 14:
-+	case 15:
-+		if ((req->reg_flags & PFM_REGFL_NO_EMUL64) == 0) {
-+			if (pfm_mont_has_ht) {
-+				PFM_INFO("perfmon: Errata 121 PMD10/PMD15 cannot be used to overflow"
-+					 "when threads on on");
-+				return -EINVAL;
-+			}
-+		}
-+		if (is_system)
-+			tmpval |= PFM_MONT_PMC_PM_POS6;
-+		else
-+			tmpval &= ~PFM_MONT_PMC_PM_POS6;
-+		break;
-+	case 39:
-+	case 40:
-+	case 42:
-+		if (pfm_mont_has_ht && ((req->reg_value >> 8) & 0x7) == 4) {
-+			PFM_INFO("perfmon: Errata 120: IP-EAR not available when threads are on");
-+			return -EINVAL;
-+		}
-+		if (is_system)
-+			tmpval |= PFM_MONT_PMC_PM_POS6;
-+		else
-+			tmpval &= ~PFM_MONT_PMC_PM_POS6;
-+		break;
-+
-+	case  32:
-+		val32 = tmpval;
-+		val38 = set->pmcs[38];
-+		val41 = set->pmcs[41];
-+		check_case1 = 1;
-+		break;
-+
-+	case  37:
-+		if (is_system)
-+			tmpval |= PFM_MONT_PMC_PM_POS4;
-+		else
-+			tmpval &= ~PFM_MONT_PMC_PM_POS4;
-+		break;
-+
-+	case  38:
-+		val38 = tmpval;
-+		val32 = set->pmcs[32];
-+		val41 = set->pmcs[41];
-+		check_case1 = 1;
-+		break;
-+	case  41:
-+		val41 = tmpval;
-+		val32 = set->pmcs[32];
-+		val38 = set->pmcs[38];
-+		check_case1 = 1;
-+		break;
-+	}
-+
-+	if (check_case1) {
-+		ret = (((val41 >> 45) & 0xf) == 0 && ((val32>>57) & 0x1) == 0)
-+		     && ((((val38>>1) & 0x3) == 0x2 || ((val38>>1) & 0x3) == 0)
-+		     || (((val38>>4) & 0x3) == 0x2 || ((val38>>4) & 0x3) == 0));
-+		if (ret) {
-+			PFM_DBG("perfmon: invalid config pmc38=0x%lx "
-+				"pmc41=0x%lx pmc32=0x%lx",
-+				val38, val41, val32);
-+			return -EINVAL;
-+		}
-+	}
-+
-+	/*
-+	 * check if configuration implicitely activates the use of the
-+	 * debug registers. If true, then we ensure that this is possible
-+	 * and that we do not pick up stale value in the HW registers.
-+	 */
-+
-+	/*
-+	 *
-+	 * pmc41 is "active" if:
-+	 * 	one of the pmc41.cfgdtagXX field is different from 0x3
-+	 * AND
-+	 * 	the corsesponding pmc41.en_dbrpXX is set.
-+	 * AND
-+	 *	ctx_fl_use_dbr (dbr not yet used)
-+	 */
-+	if (cnum == 41
-+	    && (tmpval & 0x1e00000000000)
-+		&& (tmpval & 0x18181818) != 0x18181818
-+		&& ctx_arch->flags.use_dbr == 0) {
-+		PFM_DBG("pmc41=0x%lx active, clearing dbr", tmpval);
-+		ret = pfm_ia64_mark_dbregs_used(ctx, set);
-+		if (ret)
-+			return ret;
-+	}
-+	/*
-+	 * we must clear the (instruction) debug registers if:
-+	 * 	pmc38.ig_ibrpX is 0 (enabled)
-+	 * and
-+	 * 	fl_use_dbr == 0 (dbr not yet used)
-+	 */
-+	if (cnum == 38 && ((tmpval & 0x492) != 0x492)
-+		&& ctx_arch->flags.use_dbr == 0) {
-+		PFM_DBG("pmc38=0x%lx active pmc38, clearing ibr", tmpval);
-+		ret = pfm_ia64_mark_dbregs_used(ctx, set);
-+		if (ret)
-+			return ret;
-+
-+	}
-+	req->reg_value = tmpval;
-+	return 0;
-+}
-+
-+static void pfm_handle_errata(void)
-+{
-+	pfm_mont_has_ht = 1;
-+
-+	PFM_INFO("activating workaround for errata 120 "
-+		 "(Disable IP-EAR when threads are on)");
-+
-+	PFM_INFO("activating workaround for Errata 121 "
-+		 "(PMC10-PMC15 cannot be used to overflow"
-+		 " when threads are on");
-+}
-+static int pfm_mont_probe_pmu(void)
-+{
-+	if (local_cpu_data->family != 0x20)
-+		return -1;
-+
-+	/*
-+	 * the 2 errata must be activated when
-+	 * threads are/can be enabled
-+	 */
-+	if (is_multithreading_enabled())
-+		pfm_handle_errata();
-+
-+	return 0;
-+}
-+
-+/*
-+ * impl_pmcs, impl_pmds are computed at runtime to minimize errors!
-+ */
-+static struct pfm_pmu_config pfm_mont_pmu_conf = {
-+	.pmu_name = "Montecito",
-+	.counter_width = 47,
-+	.pmd_desc = pfm_mont_pmd_desc,
-+	.pmc_desc = pfm_mont_pmc_desc,
-+	.num_pmc_entries = PFM_MONT_NUM_PMCS,
-+	.num_pmd_entries = PFM_MONT_NUM_PMDS,
-+	.pmc_write_check = pfm_mont_pmc_check,
-+	.probe_pmu = pfm_mont_probe_pmu,
-+	.version = "1.0",
-+	.pmu_info = &pfm_mont_pmu_info,
-+	.flags = PFM_PMU_BUILTIN_FLAG,
-+	.owner = THIS_MODULE
-+};
-+
-+static int __init pfm_mont_pmu_init_module(void)
-+{
-+	return pfm_pmu_register(&pfm_mont_pmu_conf);
-+}
-+
-+static void __exit pfm_mont_pmu_cleanup_module(void)
-+{
-+	pfm_pmu_unregister(&pfm_mont_pmu_conf);
-+}
-+
-+module_init(pfm_mont_pmu_init_module);
-+module_exit(pfm_mont_pmu_cleanup_module);
-diff --git a/arch/mips/Kconfig b/arch/mips/Kconfig
-index 1e06d23..b87f445 100644
---- a/arch/mips/Kconfig
-+++ b/arch/mips/Kconfig
-@@ -1857,6 +1857,8 @@ config SECCOMP
- 
- 	  If unsure, say Y. Only embedded should say N here.
- 
-+source "arch/mips/perfmon/Kconfig"
-+
- endmenu
- 
- config RWSEM_GENERIC_SPINLOCK
-diff --git a/arch/mips/Makefile b/arch/mips/Makefile
-index 9aab51c..712acf7 100644
---- a/arch/mips/Makefile
-+++ b/arch/mips/Makefile
-@@ -154,6 +154,12 @@ endif
- endif
- 
- #
-+# Perfmon support
-+#
-+
-+core-$(CONFIG_PERFMON)		+= arch/mips/perfmon/
-+
-+#
- # Firmware support
- #
- libs-$(CONFIG_ARC)		+= arch/mips/fw/arc/
-diff --git a/arch/mips/kernel/process.c b/arch/mips/kernel/process.c
-index 22fc19b..4467361 100644
---- a/arch/mips/kernel/process.c
-+++ b/arch/mips/kernel/process.c
-@@ -27,6 +27,7 @@
- #include <linux/completion.h>
- #include <linux/kallsyms.h>
- #include <linux/random.h>
-+#include <linux/perfmon_kern.h>
- 
- #include <asm/asm.h>
- #include <asm/bootinfo.h>
-@@ -94,6 +95,7 @@ void start_thread(struct pt_regs * regs, unsigned long pc, unsigned long sp)
- 
- void exit_thread(void)
- {
-+  pfm_exit_thread();
- }
- 
- void flush_thread(void)
-@@ -162,6 +164,8 @@ int copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
- 	if (clone_flags & CLONE_SETTLS)
- 		ti->tp_value = regs->regs[7];
- 
-+	pfm_copy_thread(p);
-+
- 	return 0;
- }
- 
-diff --git a/arch/mips/kernel/scall32-o32.S b/arch/mips/kernel/scall32-o32.S
-index 5e75a31..e96ddd6 100644
---- a/arch/mips/kernel/scall32-o32.S
-+++ b/arch/mips/kernel/scall32-o32.S
-@@ -653,6 +653,18 @@ einval:	li	v0, -EINVAL
- 	sys	sys_dup3		3
- 	sys	sys_pipe2		2
- 	sys	sys_inotify_init1	1
-+	sys	sys_pfm_create_context	4	/* 4330 */
-+	sys	sys_pfm_write_pmcs	3
-+	sys	sys_pfm_write_pmds	4
-+	sys	sys_pfm_read_pmds	3
-+	sys	sys_pfm_load_context	2
-+	sys	sys_pfm_start		2	/* 4335 */
-+	sys	sys_pfm_stop		1
-+	sys	sys_pfm_restart		1
-+	sys	sys_pfm_create_evtsets	3
-+	sys	sys_pfm_getinfo_evtsets 3
-+	sys	sys_pfm_delete_evtsets	3	/* 4340 */
-+	sys	sys_pfm_unload_context	1
- 	.endm
- 
- 	/* We pre-compute the number of _instruction_ bytes needed to
-diff --git a/arch/mips/kernel/scall64-64.S b/arch/mips/kernel/scall64-64.S
-index 3d58204..adb2ba9 100644
---- a/arch/mips/kernel/scall64-64.S
-+++ b/arch/mips/kernel/scall64-64.S
-@@ -487,4 +487,16 @@ sys_call_table:
- 	PTR	sys_dup3
- 	PTR	sys_pipe2
- 	PTR	sys_inotify_init1
-+	PTR	sys_pfm_create_context
-+	PTR	sys_pfm_write_pmcs		/* 5290 */
-+	PTR	sys_pfm_write_pmds
-+	PTR	sys_pfm_read_pmds
-+	PTR	sys_pfm_load_context
-+	PTR	sys_pfm_start
-+	PTR	sys_pfm_stop			/* 5295 */
-+	PTR	sys_pfm_restart
-+	PTR	sys_pfm_create_evtsets
-+	PTR	sys_pfm_getinfo_evtsets
-+	PTR	sys_pfm_delete_evtsets
-+	PTR	sys_pfm_unload_context		/* 5300 */
- 	.size	sys_call_table,.-sys_call_table
-diff --git a/arch/mips/kernel/scall64-n32.S b/arch/mips/kernel/scall64-n32.S
-index da7f1b6..6d12095 100644
---- a/arch/mips/kernel/scall64-n32.S
-+++ b/arch/mips/kernel/scall64-n32.S
-@@ -400,12 +400,12 @@ EXPORT(sysn32_call_table)
- 	PTR	sys_ioprio_set
- 	PTR	sys_ioprio_get
- 	PTR	compat_sys_utimensat
--	PTR	compat_sys_signalfd		/* 5280 */
-+	PTR	compat_sys_signalfd		/* 6280 */
- 	PTR	sys_ni_syscall
- 	PTR	sys_eventfd
- 	PTR	sys_fallocate
- 	PTR	sys_timerfd_create
--	PTR	sys_timerfd_gettime		/* 5285 */
-+	PTR	sys_timerfd_gettime		/* 6285 */
- 	PTR	sys_timerfd_settime
- 	PTR	sys_signalfd4
- 	PTR	sys_eventfd2
-@@ -413,4 +413,16 @@ EXPORT(sysn32_call_table)
- 	PTR	sys_dup3			/* 5290 */
- 	PTR	sys_pipe2
- 	PTR	sys_inotify_init1
-+	PTR	sys_pfm_create_context
-+	PTR	sys_pfm_write_pmcs
-+	PTR	sys_pfm_write_pmds		/* 6295 */
-+	PTR	sys_pfm_read_pmds
-+	PTR	sys_pfm_load_context
-+	PTR	sys_pfm_start
-+	PTR	sys_pfm_stop
-+	PTR	sys_pfm_restart			/* 6300 */
-+	PTR	sys_pfm_create_evtsets
-+	PTR	sys_pfm_getinfo_evtsets
-+	PTR	sys_pfm_delete_evtsets
-+	PTR	sys_pfm_unload_context
- 	.size	sysn32_call_table,.-sysn32_call_table
-diff --git a/arch/mips/kernel/scall64-o32.S b/arch/mips/kernel/scall64-o32.S
-index d7cd1aa..e77f55a 100644
---- a/arch/mips/kernel/scall64-o32.S
-+++ b/arch/mips/kernel/scall64-o32.S
-@@ -535,4 +535,16 @@ sys_call_table:
- 	PTR	sys_dup3
- 	PTR	sys_pipe2
- 	PTR	sys_inotify_init1
-+	PTR	sys_pfm_create_context		/* 4330 */
-+	PTR	sys_pfm_write_pmcs
-+	PTR	sys_pfm_write_pmds
-+	PTR	sys_pfm_read_pmds
-+	PTR	sys_pfm_load_context
-+	PTR	sys_pfm_start			/* 4335 */
-+	PTR	sys_pfm_stop
-+	PTR	sys_pfm_restart
-+	PTR	sys_pfm_create_evtsets
-+	PTR	sys_pfm_getinfo_evtsets
-+	PTR	sys_pfm_delete_evtsets		/* 4340 */
-+	PTR	sys_pfm_unload_context
- 	.size	sys_call_table,.-sys_call_table
-diff --git a/arch/mips/kernel/signal.c b/arch/mips/kernel/signal.c
-index a4e106c..6a7e60c 100644
---- a/arch/mips/kernel/signal.c
-+++ b/arch/mips/kernel/signal.c
-@@ -20,6 +20,7 @@
- #include <linux/unistd.h>
- #include <linux/compiler.h>
- #include <linux/uaccess.h>
-+#include <linux/perfmon_kern.h>
- 
- #include <asm/abi.h>
- #include <asm/asm.h>
-@@ -694,8 +695,11 @@ static void do_signal(struct pt_regs *regs)
-  * - triggered by the TIF_WORK_MASK flags
-  */
- asmlinkage void do_notify_resume(struct pt_regs *regs, void *unused,
--	__u32 thread_info_flags)
-+				 __u32 thread_info_flags)
- {
-+	if (thread_info_flags & _TIF_PERFMON_WORK)
-+		pfm_handle_work(regs);
-+
- 	/* deal with pending signal delivery */
- 	if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
- 		do_signal(regs);
-diff --git a/arch/mips/kernel/time.c b/arch/mips/kernel/time.c
-index 1f467d5..163dfe4 100644
---- a/arch/mips/kernel/time.c
-+++ b/arch/mips/kernel/time.c
-@@ -49,10 +49,11 @@ int update_persistent_clock(struct timespec now)
- 	return rtc_mips_set_mmss(now.tv_sec);
- }
- 
--static int null_perf_irq(void)
-+int null_perf_irq(void)
- {
- 	return 0;
- }
-+EXPORT_SYMBOL(null_perf_irq);
- 
- int (*perf_irq)(void) = null_perf_irq;
- 
-diff --git a/arch/mips/kernel/traps.c b/arch/mips/kernel/traps.c
-index b602ac6..9cbd75f 100644
---- a/arch/mips/kernel/traps.c
-+++ b/arch/mips/kernel/traps.c
-@@ -92,17 +92,15 @@ static void show_raw_backtrace(unsigned long reg29)
- #ifdef CONFIG_KALLSYMS
- 	printk("\n");
- #endif
--	while (!kstack_end(sp)) {
--		unsigned long __user *p =
--			(unsigned long __user *)(unsigned long)sp++;
--		if (__get_user(addr, p)) {
--			printk(" (Bad stack address)");
--			break;
-+#define IS_KVA01(a) ((((unsigned long)a) & 0xc0000000) == 0x80000000)
-+	if (IS_KVA01(sp)) {
-+		while (!kstack_end(sp)) {
-+			addr = *sp++;
-+			if (__kernel_text_address(addr))
-+				print_ip_sym(addr);
- 		}
--		if (__kernel_text_address(addr))
--			print_ip_sym(addr);
-+		printk("\n");
- 	}
--	printk("\n");
- }
- 
- #ifdef CONFIG_KALLSYMS
-diff --git a/arch/mips/mti-malta/malta-time.c b/arch/mips/mti-malta/malta-time.c
-index 0b97d47..d8f36b5 100644
---- a/arch/mips/mti-malta/malta-time.c
-+++ b/arch/mips/mti-malta/malta-time.c
-@@ -27,6 +27,7 @@
- #include <linux/time.h>
- #include <linux/timex.h>
- #include <linux/mc146818rtc.h>
-+#include <linux/perfmon_kern.h>
- 
- #include <asm/mipsregs.h>
- #include <asm/mipsmtregs.h>
-diff --git a/arch/mips/perfmon/Kconfig b/arch/mips/perfmon/Kconfig
-new file mode 100644
-index 0000000..b426eea
---- /dev/null
-+++ b/arch/mips/perfmon/Kconfig
-@@ -0,0 +1,61 @@
-+menu "Hardware Performance Monitoring support"
-+config PERFMON
-+	bool "Perfmon2 performance monitoring interface"
-+	default n
-+	help
-+	Enables the perfmon2 interface to access the hardware
-+	performance counters. See <http://perfmon2.sf.net/> for
-+	more details.
-+
-+config PERFMON_DEBUG
-+	bool "Perfmon debugging"
-+	default n
-+	depends on PERFMON
-+	help
-+	Enables perfmon debugging support
-+
-+config PERFMON_DEBUG_FS
-+	bool "Enable perfmon statistics reporting via debugfs"
-+	default y
-+	depends on PERFMON && DEBUG_FS
-+	help
-+	Enable collection and reporting of perfmon timing statistics under
-+	debugfs. This is used for debugging and performance analysis of the
-+	subsystem. The debugfs filesystem must be mounted.
-+
-+config PERFMON_FLUSH
-+	bool "Flush sampling buffer when modified"
-+	depends on PERFMON
-+	default n
-+	help
-+	On some MIPS models, cache aliasing may cause invalid
-+	data to be read from the perfmon sampling buffer. Use this option
-+	to flush the buffer when it is modified to ensure valid data is
-+	visible at the user level.
-+
-+config PERFMON_ALIGN
-+	bool "Align sampling buffer to avoid cache aliasing"
-+	depends on PERFMON
-+	default n
-+	help
-+	On some MIPS models, cache aliasing may cause invalid
-+	data to be read from the perfmon sampling buffer. By forcing a bigger
-+	page alignment (4-page), one can guarantee the buffer virtual address
-+	will conflict in the cache with the user level mapping of the buffer
-+	thereby ensuring a consistent view by user programs.
-+
-+config PERFMON_DEBUG
-+	bool "Perfmon debugging"
-+	depends on PERFMON
-+	default n
-+	depends on PERFMON
-+	help
-+	Enables perfmon debugging support
-+
-+config PERFMON_MIPS64
-+	tristate "Support for MIPS64 hardware performance counters"
-+	depends on PERFMON
-+	default n
-+	help
-+	Enables support for the MIPS64 hardware performance counters"
-+endmenu
-diff --git a/arch/mips/perfmon/Makefile b/arch/mips/perfmon/Makefile
-new file mode 100644
-index 0000000..153b83f
---- /dev/null
-+++ b/arch/mips/perfmon/Makefile
-@@ -0,0 +1,2 @@
-+obj-$(CONFIG_PERFMON)		+= perfmon.o
-+obj-$(CONFIG_PERFMON_MIPS64)	+= perfmon_mips64.o
-diff --git a/arch/mips/perfmon/perfmon.c b/arch/mips/perfmon/perfmon.c
-new file mode 100644
-index 0000000..6615a77
---- /dev/null
-+++ b/arch/mips/perfmon/perfmon.c
-@@ -0,0 +1,313 @@
-+/*
-+ * This file implements the MIPS64 specific
-+ * support for the perfmon2 interface
-+ *
-+ * Copyright (c) 2005 Philip J. Mucci
-+ *
-+ * based on versions for other architectures:
-+ * Copyright (c) 2005 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@htrpl.hp.com>
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+  */
-+#include <linux/interrupt.h>
-+#include <linux/module.h>
-+#include <linux/perfmon_kern.h>
-+
-+/*
-+ * collect pending overflowed PMDs. Called from pfm_ctxsw()
-+ * and from PMU interrupt handler. Must fill in set->povfl_pmds[]
-+ * and set->npend_ovfls. Interrupts are masked
-+ */
-+static void __pfm_get_ovfl_pmds(struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	u64 new_val, wmask;
-+	u64 *used_mask, *intr_pmds;
-+	u64 mask[PFM_PMD_BV];
-+	unsigned int i, max;
-+
-+	max = ctx->regs.max_intr_pmd;
-+	intr_pmds = ctx->regs.intr_pmds;
-+	used_mask = set->used_pmds;
-+
-+	wmask = 1ULL << pfm_pmu_conf->counter_width;
-+
-+	bitmap_and(cast_ulp(mask),
-+		   cast_ulp(intr_pmds),
-+		   cast_ulp(used_mask),
-+		   max);
-+
-+	/*
-+	 * check all PMD that can generate interrupts
-+	 * (that includes counters)
-+	 */
-+	for (i = 0; i < max; i++) {
-+		if (test_bit(i, mask)) {
-+			new_val = pfm_arch_read_pmd(ctx, i);
-+
-+			PFM_DBG_ovfl("pmd%u new_val=0x%llx bit=%d\n",
-+				     i, (unsigned long long)new_val,
-+				     (new_val&wmask) ? 1 : 0);
-+
-+			if (new_val & wmask) {
-+				__set_bit(i, set->povfl_pmds);
-+				set->npend_ovfls++;
-+			}
-+		}
-+	}
-+}
-+
-+static void pfm_stop_active(struct task_struct *task, struct pfm_context *ctx,
-+			    struct pfm_event_set *set)
-+{
-+	unsigned int i, max;
-+
-+	max = ctx->regs.max_pmc;
-+
-+	/*
-+	 * clear enable bits, assume all pmcs are enable pmcs
-+	 */
-+	for (i = 0; i < max; i++) {
-+		if (test_bit(i, set->used_pmcs))
-+			pfm_arch_write_pmc(ctx, i, 0);
-+	}
-+
-+	if (set->npend_ovfls)
-+		return;
-+
-+	__pfm_get_ovfl_pmds(ctx, set);
-+}
-+
-+/*
-+ * Called from pfm_ctxsw(). Task is guaranteed to be current.
-+ * Context is locked. Interrupts are masked. Monitoring is active.
-+ * PMU access is guaranteed. PMC and PMD registers are live in PMU.
-+ *
-+ * for per-thread:
-+ * 	must stop monitoring for the task
-+ *
-+ * Return:
-+ * 	non-zero : did not save PMDs (as part of stopping the PMU)
-+ * 	       0 : saved PMDs (no need to save them in caller)
-+ */
-+int pfm_arch_ctxswout_thread(struct task_struct *task, struct pfm_context *ctx)
-+{
-+	/*
-+	 * disable lazy restore of PMC registers.
-+	 */
-+	ctx->active_set->priv_flags |= PFM_SETFL_PRIV_MOD_PMCS;
-+
-+	/*
-+	 * if masked, monitoring is stopped, thus there is no
-+	 * need to stop the PMU again and there is no need to
-+	 * check for pending overflows. This is not just an
-+	 * optimization, this is also for correctness as you
-+	 * may end up detecting overflows twice.
-+	 */
-+	if (ctx->state == PFM_CTX_MASKED)
-+		return 1;
-+
-+	pfm_stop_active(task, ctx, ctx->active_set);
-+
-+	return 1;
-+}
-+
-+/*
-+ * Called from pfm_stop() and pfm_ctxsw()
-+ * Interrupts are masked. Context is locked. Set is the active set.
-+ *
-+ * For per-thread:
-+ *   task is not necessarily current. If not current task, then
-+ *   task is guaranteed stopped and off any cpu. Access to PMU
-+ *   is not guaranteed. Interrupts are masked. Context is locked.
-+ *   Set is the active set.
-+ *
-+ * For system-wide:
-+ * 	task is current
-+ *
-+ * must disable active monitoring. ctx cannot be NULL
-+ */
-+void pfm_arch_stop(struct task_struct *task, struct pfm_context *ctx)
-+{
-+	/*
-+	 * no need to go through stop_save()
-+	 * if we are already stopped
-+	 */
-+	if (!ctx->flags.started || ctx->state == PFM_CTX_MASKED)
-+		return;
-+
-+	/*
-+	 * stop live registers and collect pending overflow
-+	 */
-+	if (task == current)
-+		pfm_stop_active(task, ctx, ctx->active_set);
-+}
-+
-+/*
-+ * called from pfm_start() or pfm_ctxsw() when idle task and
-+ * EXCL_IDLE is on.
-+ *
-+ * Interrupts are masked. Context is locked. Set is the active set.
-+ *
-+ * For per-trhead:
-+ * 	Task is not necessarily current. If not current task, then task
-+ * 	is guaranteed stopped and off any cpu. Access to PMU is not guaranteed.
-+ *
-+ * For system-wide:
-+ * 	task is always current
-+ *
-+ * must enable active monitoring.
-+ */
-+void pfm_arch_start(struct task_struct *task, struct pfm_context *ctx)
-+{
-+	struct pfm_event_set *set;
-+	unsigned int i, max_pmc;
-+
-+	if (task != current)
-+		return;
-+
-+	set = ctx->active_set;
-+	max_pmc = ctx->regs.max_pmc;
-+
-+	for (i = 0; i < max_pmc; i++) {
-+		if (test_bit(i, set->used_pmcs))
-+			pfm_arch_write_pmc(ctx, i, set->pmcs[i]);
-+	}
-+}
-+
-+/*
-+ * function called from pfm_switch_sets(), pfm_context_load_thread(),
-+ * pfm_context_load_sys(), pfm_ctxsw(), pfm_switch_sets()
-+ * context is locked. Interrupts are masked. set cannot be NULL.
-+ * Access to the PMU is guaranteed.
-+ *
-+ * function must restore all PMD registers from set.
-+ */
-+void pfm_arch_restore_pmds(struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	u64 ovfl_mask, val;
-+	u64 *impl_pmds;
-+	unsigned int i;
-+	unsigned int max_pmd;
-+
-+	max_pmd = ctx->regs.max_pmd;
-+	ovfl_mask = pfm_pmu_conf->ovfl_mask;
-+	impl_pmds = ctx->regs.pmds;
-+
-+	/*
-+	 * must restore all pmds to avoid leaking
-+	 * information to user.
-+	 */
-+	for (i = 0; i < max_pmd; i++) {
-+
-+		if (test_bit(i, impl_pmds) == 0)
-+			continue;
-+
-+		val = set->pmds[i].value;
-+
-+		/*
-+		 * set upper bits for counter to ensure
-+		 * overflow will trigger
-+		 */
-+		val &= ovfl_mask;
-+
-+		pfm_arch_write_pmd(ctx, i, val);
-+	}
-+}
-+
-+/*
-+ * function called from pfm_switch_sets(), pfm_context_load_thread(),
-+ * pfm_context_load_sys(), pfm_ctxsw().
-+ * Context is locked. Interrupts are masked. set cannot be NULL.
-+ * Access to the PMU is guaranteed.
-+ *
-+ * function must restore all PMC registers from set, if needed.
-+ */
-+void pfm_arch_restore_pmcs(struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	u64 *impl_pmcs;
-+	unsigned int i, max_pmc;
-+
-+	max_pmc = ctx->regs.max_pmc;
-+	impl_pmcs = ctx->regs.pmcs;
-+
-+	/*
-+	 * - by default no PMCS measures anything
-+	 * - on ctxswout, all used PMCs are disabled (cccr enable bit cleared)
-+	 * hence when masked we do not need to restore anything
-+	 */
-+	if (ctx->state == PFM_CTX_MASKED || ctx->flags.started == 0)
-+		return;
-+
-+	/*
-+	 * restore all pmcs
-+	 */
-+	for (i = 0; i < max_pmc; i++)
-+		if (test_bit(i, impl_pmcs))
-+			pfm_arch_write_pmc(ctx, i, set->pmcs[i]);
-+}
-+
-+char *pfm_arch_get_pmu_module_name(void)
-+{
-+	switch (cpu_data->cputype) {
-+#ifndef CONFIG_SMP
-+	case CPU_34K:
-+#if defined(CPU_74K)
-+	case CPU_74K:
-+#endif
-+#endif
-+	case CPU_SB1:
-+	case CPU_SB1A:
-+	case CPU_R12000:
-+	case CPU_25KF:
-+	case CPU_24K:
-+	case CPU_20KC:
-+	case CPU_5KC:
-+		return "perfmon_mips64";
-+	default:
-+		return NULL;
-+	}
-+	return NULL;
-+}
-+
-+int perfmon_perf_irq(void)
-+{
-+	/* BLATANTLY STOLEN FROM OPROFILE, then modified */
-+	struct pt_regs *regs;
-+	unsigned int counters = pfm_pmu_conf->regs_all.max_pmc;
-+	unsigned int control;
-+	unsigned int counter;
-+
-+	regs = get_irq_regs();
-+	switch (counters) {
-+#define HANDLE_COUNTER(n)						\
-+	case n + 1:							\
-+		control = read_c0_perfctrl ## n();			\
-+		counter = read_c0_perfcntr ## n();			\
-+		if ((control & MIPS64_PMC_INT_ENABLE_MASK) &&		\
-+		    (counter & MIPS64_PMD_INTERRUPT)) {			\
-+			pfm_interrupt_handler(instruction_pointer(regs),\
-+					      regs);			\
-+			return(1);					\
-+		}
-+		HANDLE_COUNTER(3)
-+		HANDLE_COUNTER(2)
-+		HANDLE_COUNTER(1)
-+		HANDLE_COUNTER(0)
-+	}
-+
-+	return 0;
-+}
-+EXPORT_SYMBOL(perfmon_perf_irq);
-diff --git a/arch/mips/perfmon/perfmon_mips64.c b/arch/mips/perfmon/perfmon_mips64.c
-new file mode 100644
-index 0000000..78cb43d
---- /dev/null
-+++ b/arch/mips/perfmon/perfmon_mips64.c
-@@ -0,0 +1,218 @@
-+/*
-+ * This file contains the MIPS64 and decendent PMU register description tables
-+ * and pmc checker used by perfmon.c.
-+ *
-+ * Copyright (c) 2005 Philip Mucci
-+ *
-+ * Based on perfmon_p6.c:
-+ * Copyright (c) 2005-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/module.h>
-+#include <linux/perfmon_kern.h>
-+
-+MODULE_AUTHOR("Philip Mucci <mucci@cs.utk.edu>");
-+MODULE_DESCRIPTION("MIPS64 PMU description tables");
-+MODULE_LICENSE("GPL");
-+
-+/*
-+ * reserved:
-+ * 	- bit 63-9
-+ * RSVD: reserved bits must be 1
-+ */
-+#define PFM_MIPS64_PMC_RSVD 0xfffffffffffff810ULL
-+#define PFM_MIPS64_PMC_VAL  (1ULL<<4)
-+
-+extern int null_perf_irq(struct pt_regs *regs);
-+extern int (*perf_irq)(struct pt_regs *regs);
-+extern int perfmon_perf_irq(struct pt_regs *regs);
-+
-+static struct pfm_arch_pmu_info pfm_mips64_pmu_info;
-+
-+static struct pfm_regmap_desc pfm_mips64_pmc_desc[] = {
-+/* pmc0 */  PMC_D(PFM_REG_I64, "CP0_25_0", PFM_MIPS64_PMC_VAL, PFM_MIPS64_PMC_RSVD, 0, 0),
-+/* pmc1 */  PMC_D(PFM_REG_I64, "CP0_25_1", PFM_MIPS64_PMC_VAL, PFM_MIPS64_PMC_RSVD, 0, 1),
-+/* pmc2 */  PMC_D(PFM_REG_I64, "CP0_25_2", PFM_MIPS64_PMC_VAL, PFM_MIPS64_PMC_RSVD, 0, 2),
-+/* pmc3 */  PMC_D(PFM_REG_I64, "CP0_25_3", PFM_MIPS64_PMC_VAL, PFM_MIPS64_PMC_RSVD, 0, 3)
-+};
-+#define PFM_MIPS64_NUM_PMCS ARRAY_SIZE(pfm_mips64_pmc_desc)
-+
-+static struct pfm_regmap_desc pfm_mips64_pmd_desc[] = {
-+/* pmd0 */ PMD_D(PFM_REG_C, "CP0_25_0", 0),
-+/* pmd1 */ PMD_D(PFM_REG_C, "CP0_25_1", 1),
-+/* pmd2 */ PMD_D(PFM_REG_C, "CP0_25_2", 2),
-+/* pmd3 */ PMD_D(PFM_REG_C, "CP0_25_3", 3)
-+};
-+#define PFM_MIPS64_NUM_PMDS ARRAY_SIZE(pfm_mips64_pmd_desc)
-+
-+static int pfm_mips64_probe_pmu(void)
-+{
-+	struct cpuinfo_mips *c = &current_cpu_data;
-+
-+	switch (c->cputype) {
-+#ifndef CONFIG_SMP
-+	case CPU_34K:
-+#if defined(CPU_74K)
-+	case CPU_74K:
-+#endif
-+#endif
-+	case CPU_SB1:
-+	case CPU_SB1A:
-+	case CPU_R12000:
-+	case CPU_25KF:
-+	case CPU_24K:
-+	case CPU_20KC:
-+	case CPU_5KC:
-+		return 0;
-+		break;
-+	default:
-+		PFM_INFO("Unknown cputype 0x%x", c->cputype);
-+	}
-+	return -1;
-+}
-+
-+/*
-+ * impl_pmcs, impl_pmds are computed at runtime to minimize errors!
-+ */
-+static struct pfm_pmu_config pfm_mips64_pmu_conf = {
-+	.pmu_name = "MIPS", /* placeholder */
-+	.counter_width = 31,
-+	.pmd_desc = pfm_mips64_pmd_desc,
-+	.pmc_desc = pfm_mips64_pmc_desc,
-+	.num_pmc_entries = PFM_MIPS64_NUM_PMCS,
-+	.num_pmd_entries = PFM_MIPS64_NUM_PMDS,
-+	.probe_pmu = pfm_mips64_probe_pmu,
-+	.flags = PFM_PMU_BUILTIN_FLAG,
-+	.owner = THIS_MODULE,
-+	.pmu_info = &pfm_mips64_pmu_info
-+};
-+
-+static inline int n_counters(void)
-+{
-+	if (!(read_c0_config1() & MIPS64_CONFIG_PMC_MASK))
-+		return 0;
-+	if (!(read_c0_perfctrl0() & MIPS64_PMC_CTR_MASK))
-+		return 1;
-+	if (!(read_c0_perfctrl1() & MIPS64_PMC_CTR_MASK))
-+		return 2;
-+	if (!(read_c0_perfctrl2() & MIPS64_PMC_CTR_MASK))
-+		return 3;
-+	return 4;
-+}
-+
-+static int __init pfm_mips64_pmu_init_module(void)
-+{
-+	struct cpuinfo_mips *c = &current_cpu_data;
-+	int i, ret, num;
-+	u64 temp_mask;
-+
-+	switch (c->cputype) {
-+	case CPU_5KC:
-+		pfm_mips64_pmu_conf.pmu_name = "MIPS5KC";
-+		break;
-+	case CPU_R12000:
-+		pfm_mips64_pmu_conf.pmu_name = "MIPSR12000";
-+		break;
-+	case CPU_20KC:
-+		pfm_mips64_pmu_conf.pmu_name = "MIPS20KC";
-+		break;
-+	case CPU_24K:
-+		pfm_mips64_pmu_conf.pmu_name = "MIPS24K";
-+		break;
-+	case CPU_25KF:
-+		pfm_mips64_pmu_conf.pmu_name = "MIPS25KF";
-+		break;
-+	case CPU_SB1:
-+		pfm_mips64_pmu_conf.pmu_name = "SB1";
-+		break;
-+	case CPU_SB1A:
-+	pfm_mips64_pmu_conf.pmu_name = "SB1A";
-+		break;
-+#ifndef CONFIG_SMP
-+	case CPU_34K:
-+		pfm_mips64_pmu_conf.pmu_name = "MIPS34K";
-+		break;
-+#if defined(CPU_74K)
-+	case CPU_74K:
-+		pfm_mips64_pmu_conf.pmu_name = "MIPS74K";
-+		break;
-+#endif
-+#endif
-+	default:
-+		PFM_INFO("Unknown cputype 0x%x", c->cputype);
-+		return -1;
-+	}
-+
-+	/* The R14k and older performance counters have to          */
-+	/* be hard-coded, as there is no support for auto-detection */
-+	if ((c->cputype == CPU_R12000) || (c->cputype == CPU_R14000))
-+		num = 4;
-+	else if (c->cputype == CPU_R10000)
-+		num = 2;
-+	else
-+		num = n_counters();
-+
-+	if (num == 0) {
-+		PFM_INFO("cputype 0x%x has no counters", c->cputype);
-+		return -1;
-+	}
-+	/* mark remaining counters unavailable */
-+	for (i = num; i < PFM_MIPS64_NUM_PMCS; i++)
-+		pfm_mips64_pmc_desc[i].type = PFM_REG_NA;
-+
-+	for (i = num; i < PFM_MIPS64_NUM_PMDS; i++)
-+		pfm_mips64_pmd_desc[i].type = PFM_REG_NA;
-+
-+	/* set the PMC_RSVD mask */
-+	switch (c->cputype) {
-+	case CPU_5KC:
-+	case CPU_R10000:
-+	case CPU_20KC:
-+	   /* 4-bits for event */
-+	   temp_mask = 0xfffffffffffffe10ULL;
-+	   break;
-+	case CPU_R12000:
-+	case CPU_R14000:
-+	   /* 5-bits for event */
-+	   temp_mask = 0xfffffffffffffc10ULL;
-+	   break;
-+	default:
-+	   /* 6-bits for event */
-+	   temp_mask = 0xfffffffffffff810ULL;
-+	}
-+	for (i = 0; i < PFM_MIPS64_NUM_PMCS; i++)
-+		pfm_mips64_pmc_desc[i].rsvd_msk = temp_mask;
-+
-+	pfm_mips64_pmu_conf.num_pmc_entries = num;
-+	pfm_mips64_pmu_conf.num_pmd_entries = num;
-+
-+	pfm_mips64_pmu_info.pmu_style = c->cputype;
-+
-+	ret = pfm_pmu_register(&pfm_mips64_pmu_conf);
-+	if (ret == 0)
-+		perf_irq = perfmon_perf_irq;
-+	return ret;
-+}
-+
-+static void __exit pfm_mips64_pmu_cleanup_module(void)
-+{
-+	pfm_pmu_unregister(&pfm_mips64_pmu_conf);
-+	perf_irq = null_perf_irq;
-+}
-+
-+module_init(pfm_mips64_pmu_init_module);
-+module_exit(pfm_mips64_pmu_cleanup_module);
-diff --git a/arch/powerpc/Kconfig b/arch/powerpc/Kconfig
-index 587da5e..a411389 100644
---- a/arch/powerpc/Kconfig
-+++ b/arch/powerpc/Kconfig
-@@ -230,6 +230,8 @@ source "init/Kconfig"
- source "arch/powerpc/sysdev/Kconfig"
- source "arch/powerpc/platforms/Kconfig"
- 
-+source "arch/powerpc/perfmon/Kconfig"
-+
- menu "Kernel options"
- 
- config HIGHMEM
-diff --git a/arch/powerpc/Makefile b/arch/powerpc/Makefile
-index c6be19e..7ea20cb 100644
---- a/arch/powerpc/Makefile
-+++ b/arch/powerpc/Makefile
-@@ -146,6 +146,7 @@ core-y				+= arch/powerpc/kernel/ \
- 				   arch/powerpc/platforms/
- core-$(CONFIG_MATH_EMULATION)	+= arch/powerpc/math-emu/
- core-$(CONFIG_XMON)		+= arch/powerpc/xmon/
-+core-$(CONFIG_PERFMON)		+= arch/powerpc/perfmon/
- core-$(CONFIG_KVM) 		+= arch/powerpc/kvm/
- 
- drivers-$(CONFIG_OPROFILE)	+= arch/powerpc/oprofile/
-diff --git a/arch/powerpc/include/asm/Kbuild b/arch/powerpc/include/asm/Kbuild
-index 5ab7d7f..88cb533 100644
---- a/arch/powerpc/include/asm/Kbuild
-+++ b/arch/powerpc/include/asm/Kbuild
-@@ -21,6 +21,7 @@ header-y += resource.h
- header-y += sigcontext.h
- header-y += statfs.h
- header-y += ps3fb.h
-+header-y += perfmon.h
- 
- unifdef-y += bootx.h
- unifdef-y += byteorder.h
-diff --git a/arch/powerpc/include/asm/cell-pmu.h b/arch/powerpc/include/asm/cell-pmu.h
-index 8066eed..981db26 100644
---- a/arch/powerpc/include/asm/cell-pmu.h
-+++ b/arch/powerpc/include/asm/cell-pmu.h
-@@ -61,6 +61,11 @@
- 
- /* Macros for the pm_status register. */
- #define CBE_PM_CTR_OVERFLOW_INTR(ctr)      (1 << (31 - ((ctr) & 7)))
-+#define CBE_PM_OVERFLOW_CTRS(pm_status)    (((pm_status) >> 24) & 0xff)
-+#define CBE_PM_ALL_OVERFLOW_INTR           0xff000000
-+#define CBE_PM_INTERVAL_INTR               0x00800000
-+#define CBE_PM_TRACE_BUFFER_FULL_INTR      0x00400000
-+#define CBE_PM_TRACE_BUFFER_UNDERFLOW_INTR 0x00200000
- 
- enum pm_reg_name {
- 	group_control,
-diff --git a/arch/powerpc/include/asm/cell-regs.h b/arch/powerpc/include/asm/cell-regs.h
-index fd6fd00..580786d 100644
---- a/arch/powerpc/include/asm/cell-regs.h
-+++ b/arch/powerpc/include/asm/cell-regs.h
-@@ -117,8 +117,9 @@ struct cbe_pmd_regs {
- 	u8	pad_0x0c1c_0x0c20 [4];				/* 0x0c1c */
- #define CBE_PMD_FIR_MODE_M8		0x00800
- 	u64	fir_enable_mask;				/* 0x0c20 */
--
--	u8	pad_0x0c28_0x0ca8 [0x0ca8 - 0x0c28];		/* 0x0c28 */
-+	u8	pad_0x0c28_0x0c98 [0x0c98 - 0x0c28];		/* 0x0c28 */
-+	u64	on_ramp_trace;					/* 0x0c98 */
-+	u64	pad_0x0ca0;					/* 0x0ca0 */
- 	u64	ras_esc_0;					/* 0x0ca8 */
- 	u8	pad_0x0cb0_0x1000 [0x1000 - 0x0cb0];		/* 0x0cb0 */
- };
-@@ -218,7 +219,11 @@ extern struct cbe_iic_regs __iomem *cbe_get_cpu_iic_regs(int cpu);
- 
- 
- struct cbe_mic_tm_regs {
--	u8	pad_0x0000_0x0040[0x0040 - 0x0000];		/* 0x0000 */
-+	u8	pad_0x0000_0x0010[0x0010 - 0x0000];		/* 0x0000 */
-+
-+	u64	MBL_debug;					/* 0x0010 */
-+
-+	u8	pad_0x0018_0x0040[0x0040 - 0x0018];		/* 0x0018 */
- 
- 	u64	mic_ctl_cnfg2;					/* 0x0040 */
- #define CBE_MIC_ENABLE_AUX_TRC		0x8000000000000000LL
-@@ -303,6 +308,25 @@ struct cbe_mic_tm_regs {
- extern struct cbe_mic_tm_regs __iomem *cbe_get_mic_tm_regs(struct device_node *np);
- extern struct cbe_mic_tm_regs __iomem *cbe_get_cpu_mic_tm_regs(int cpu);
- 
-+/*
-+ *
-+ *  PPE Privileged MMIO Registers definition. (offset 0x500000 - 0x500fff)
-+ *
-+ */
-+struct cbe_ppe_priv_regs {
-+	u8	pad_0x0000_0x0858[0x0858 - 0x0000];		/* 0x0000 */
-+
-+	u64	L2_debug1;					/* 0x0858 */
-+
-+	u8	pad_0x0860_0x0958[0x0958 - 0x0860];		/* 0x0860 */
-+
-+	u64	ciu_dr1;					/* 0x0958 */
-+
-+	u8	pad_0x0960_0x1000[0x1000 - 0x0960];		/* 0x0960 */
-+};
-+
-+extern struct cbe_ppe_priv_regs __iomem *cbe_get_cpu_ppe_priv_regs(int cpu);
-+
- /* some utility functions to deal with SMT */
- extern u32 cbe_get_hw_thread_id(int cpu);
- extern u32 cbe_cpu_to_node(int cpu);
-diff --git a/arch/powerpc/include/asm/paca.h b/arch/powerpc/include/asm/paca.h
-index 6493a39..ba9ead4 100644
---- a/arch/powerpc/include/asm/paca.h
-+++ b/arch/powerpc/include/asm/paca.h
-@@ -97,6 +97,10 @@ struct paca_struct {
- 	u8 soft_enabled;		/* irq soft-enable flag */
- 	u8 hard_enabled;		/* set if irqs are enabled in MSR */
- 	u8 io_sync;			/* writel() needs spin_unlock sync */
-+#ifdef CONFIG_PERFMON
-+	u8 pmu_except_pending;          /* PMU exception occurred while soft
-+					 * disabled */
-+#endif
- 
- 	/* Stuff for accurate time accounting */
- 	u64 user_time;			/* accumulated usermode TB ticks */
-diff --git a/arch/powerpc/include/asm/perfmon.h b/arch/powerpc/include/asm/perfmon.h
-new file mode 100644
-index 0000000..da0ae3b
---- /dev/null
-+++ b/arch/powerpc/include/asm/perfmon.h
-@@ -0,0 +1,33 @@
-+/*
-+ * Copyright (c) 2007 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This file contains powerpc specific definitions for the perfmon
-+ * interface.
-+ *
-+ * This file MUST never be included directly. Use linux/perfmon.h.
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#ifndef _ASM_POWERPC_PERFMON_H_
-+#define _ASM_POWERPC_PERFMON_H_
-+
-+/*
-+ * arch-specific user visible interface definitions
-+ */
-+#define PFM_ARCH_MAX_PMCS	(256+64) /* 256 HW 64 SW */
-+#define PFM_ARCH_MAX_PMDS	(256+64) /* 256 HW 64 SW */
-+
-+#endif /* _ASM_POWERPC_PERFMON_H_ */
-diff --git a/arch/powerpc/include/asm/perfmon_kern.h b/arch/powerpc/include/asm/perfmon_kern.h
-new file mode 100644
-index 0000000..65ec984
---- /dev/null
-+++ b/arch/powerpc/include/asm/perfmon_kern.h
-@@ -0,0 +1,390 @@
-+/*
-+ * Copyright (c) 2005 David Gibson, IBM Corporation.
-+ *
-+ * Based on other versions:
-+ * Copyright (c) 2005 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This file contains powerpc specific definitions for the perfmon
-+ * interface.
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#ifndef _ASM_POWERPC_PERFMON_KERN_H_
-+#define _ASM_POWERPC_PERFMON_KERN_H_
-+
-+#ifdef __KERNEL__
-+
-+#ifdef CONFIG_PERFMON
-+
-+#include <asm/pmc.h>
-+#include <asm/unistd.h>
-+
-+#define HID0_PMC5_6_GR_MODE (1UL << (63 - 40))
-+
-+enum powerpc_pmu_type {
-+	PFM_POWERPC_PMU_NONE,
-+	PFM_POWERPC_PMU_604,
-+	PFM_POWERPC_PMU_604e,
-+	PFM_POWERPC_PMU_750,	/* XXX: Minor event set diffs between IBM and Moto. */
-+	PFM_POWERPC_PMU_7400,
-+	PFM_POWERPC_PMU_7450,
-+	PFM_POWERPC_PMU_POWER4,
-+	PFM_POWERPC_PMU_POWER5,
-+	PFM_POWERPC_PMU_POWER5p,
-+	PFM_POWERPC_PMU_POWER6,
-+	PFM_POWERPC_PMU_CELL,
-+};
-+
-+struct pfm_arch_pmu_info {
-+	enum powerpc_pmu_type pmu_style;
-+
-+	void (*write_pmc)(unsigned int cnum, u64 value);
-+	void (*write_pmd)(unsigned int cnum, u64 value);
-+
-+	u64 (*read_pmd)(unsigned int cnum);
-+
-+	void (*enable_counters)(struct pfm_context *ctx,
-+				struct pfm_event_set *set);
-+	void (*disable_counters)(struct pfm_context *ctx,
-+				 struct pfm_event_set *set);
-+
-+	void (*irq_handler)(struct pt_regs *regs, struct pfm_context *ctx);
-+	void (*get_ovfl_pmds)(struct pfm_context *ctx,
-+			      struct pfm_event_set *set);
-+
-+	/* The following routines are optional. */
-+	void (*restore_pmcs)(struct pfm_context *ctx,
-+			     struct pfm_event_set *set);
-+	void (*restore_pmds)(struct pfm_context *ctx,
-+			     struct pfm_event_set *set);
-+
-+	int  (*ctxswout_thread)(struct task_struct *task,
-+				struct pfm_context *ctx,
-+				struct pfm_event_set *set);
-+	void (*ctxswin_thread)(struct task_struct *task,
-+			       struct pfm_context *ctx,
-+			       struct pfm_event_set *set);
-+	int  (*load_context)(struct pfm_context *ctx);
-+	void (*unload_context)(struct pfm_context *ctx);
-+	int  (*acquire_pmu)(u64 *unavail_pmcs, u64 *unavail_pmds);
-+	void (*release_pmu)(void);
-+	void *platform_info;
-+	void (*resend_irq)(struct pfm_context *ctx);
-+};
-+
-+#ifdef CONFIG_PPC32
-+#define PFM_ARCH_PMD_STK_ARG	6 /* conservative value */
-+#define PFM_ARCH_PMC_STK_ARG	6 /* conservative value */
-+#else
-+#define PFM_ARCH_PMD_STK_ARG	8 /* conservative value */
-+#define PFM_ARCH_PMC_STK_ARG	8 /* conservative value */
-+#endif
-+
-+static inline void pfm_arch_resend_irq(struct pfm_context *ctx)
-+{
-+	struct pfm_arch_pmu_info *arch_info;
-+
-+	arch_info = pfm_pmu_info();
-+	arch_info->resend_irq(ctx);
-+}
-+
-+static inline void pfm_arch_serialize(void)
-+{}
-+
-+static inline void pfm_arch_write_pmc(struct pfm_context *ctx,
-+				      unsigned int cnum,
-+				      u64 value)
-+{
-+	struct pfm_arch_pmu_info *arch_info;
-+
-+	arch_info =  pfm_pmu_info();
-+
-+	/*
-+	 * we only write to the actual register when monitoring is
-+	 * active (pfm_start was issued)
-+	 */
-+	if (ctx && ctx->flags.started == 0)
-+		return;
-+
-+	BUG_ON(!arch_info->write_pmc);
-+
-+	arch_info->write_pmc(cnum, value);
-+}
-+
-+static inline void pfm_arch_write_pmd(struct pfm_context *ctx,
-+				      unsigned int cnum, u64 value)
-+{
-+	struct pfm_arch_pmu_info *arch_info;
-+
-+	arch_info = pfm_pmu_info();
-+
-+	value &= pfm_pmu_conf->ovfl_mask;
-+
-+	BUG_ON(!arch_info->write_pmd);
-+
-+	arch_info->write_pmd(cnum, value);
-+}
-+
-+static inline u64 pfm_arch_read_pmd(struct pfm_context *ctx, unsigned int cnum)
-+{
-+	struct pfm_arch_pmu_info *arch_info;
-+
-+	arch_info = pfm_pmu_info();
-+
-+	BUG_ON(!arch_info->read_pmd);
-+
-+	return arch_info->read_pmd(cnum);
-+}
-+
-+/*
-+ * For some CPUs, the upper bits of a counter must be set in order for the
-+ * overflow interrupt to happen. On overflow, the counter has wrapped around,
-+ * and the upper bits are cleared. This function may be used to set them back.
-+ */
-+static inline void pfm_arch_ovfl_reset_pmd(struct pfm_context *ctx,
-+					   unsigned int cnum)
-+{
-+	u64 val = pfm_arch_read_pmd(ctx, cnum);
-+
-+	/* This masks out overflow bit 31 */
-+	pfm_arch_write_pmd(ctx, cnum, val);
-+}
-+
-+/*
-+ * At certain points, perfmon needs to know if monitoring has been
-+ * explicitely started/stopped by user via pfm_start/pfm_stop. The
-+ * information is tracked in flags.started. However on certain
-+ * architectures, it may be possible to start/stop directly from
-+ * user level with a single assembly instruction bypassing
-+ * the kernel. This function must be used to determine by
-+ * an arch-specific mean if monitoring is actually started/stopped.
-+ */
-+static inline int pfm_arch_is_active(struct pfm_context *ctx)
-+{
-+	return ctx->flags.started;
-+}
-+
-+static inline void pfm_arch_ctxswout_sys(struct task_struct *task,
-+					 struct pfm_context *ctx)
-+{}
-+
-+static inline void pfm_arch_ctxswin_sys(struct task_struct *task,
-+					struct pfm_context *ctx)
-+{}
-+
-+void pfm_arch_init_percpu(void);
-+int  pfm_arch_is_monitoring_active(struct pfm_context *ctx);
-+int  pfm_arch_ctxswout_thread(struct task_struct *task, struct pfm_context *ctx);
-+void pfm_arch_ctxswin_thread(struct task_struct *task, struct pfm_context *ctx);
-+void pfm_arch_stop(struct task_struct *task, struct pfm_context *ctx);
-+void pfm_arch_start(struct task_struct *task, struct pfm_context *ctx);
-+void pfm_arch_restore_pmds(struct pfm_context *ctx, struct pfm_event_set *set);
-+void pfm_arch_restore_pmcs(struct pfm_context *ctx, struct pfm_event_set *set);
-+void pfm_arch_clear_pmd_ovfl_cond(struct pfm_context *ctx, struct pfm_event_set *set);
-+int  pfm_arch_get_ovfl_pmds(struct pfm_context *ctx,
-+			    struct pfm_event_set *set);
-+char *pfm_arch_get_pmu_module_name(void);
-+/*
-+ * called from __pfm_interrupt_handler(). ctx is not NULL.
-+ * ctx is locked. PMU interrupt is masked.
-+ *
-+ * must stop all monitoring to ensure handler has consistent view.
-+ * must collect overflowed PMDs bitmask  into povfls_pmds and
-+ * npend_ovfls. If no interrupt detected then npend_ovfls
-+ * must be set to zero.
-+ */
-+static inline void pfm_arch_intr_freeze_pmu(struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	pfm_arch_stop(current, ctx);
-+}
-+
-+void powerpc_irq_handler(struct pt_regs *regs);
-+
-+/*
-+ * unfreeze PMU from pfm_do_interrupt_handler()
-+ * ctx may be NULL for spurious
-+ */
-+static inline void pfm_arch_intr_unfreeze_pmu(struct pfm_context *ctx)
-+{
-+	struct pfm_arch_pmu_info *arch_info;
-+
-+	if (!ctx)
-+		return;
-+
-+	PFM_DBG_ovfl("state=%d", ctx->state);
-+
-+	ctx->flags.started = 1;
-+
-+	if (ctx->state == PFM_CTX_MASKED)
-+		return;
-+
-+	arch_info = pfm_pmu_info();
-+	BUG_ON(!arch_info->enable_counters);
-+	arch_info->enable_counters(ctx, ctx->active_set);
-+}
-+
-+/*
-+ * PowerPC does not save the PMDs during pfm_arch_intr_freeze_pmu(), thus
-+ * this routine needs to do it when switching sets on overflow
-+ */
-+static inline void pfm_arch_save_pmds_from_intr(struct pfm_context *ctx,
-+					   struct pfm_event_set *set)
-+{
-+	pfm_save_pmds(ctx, set);
-+}
-+
-+/*
-+ * this function is called from the PMU interrupt handler ONLY.
-+ * On PPC, the PMU is frozen via arch_stop, masking would be implemented
-+ * via arch-stop as well. Given that the PMU is already stopped when
-+ * entering the interrupt handler, we do not need to stop it again, so
-+ * this function is a nop.
-+ */
-+static inline void pfm_arch_mask_monitoring(struct pfm_context *ctx,
-+					    struct pfm_event_set *set)
-+{}
-+
-+/*
-+ * Simply need to start the context in order to unmask.
-+ */
-+static inline void pfm_arch_unmask_monitoring(struct pfm_context *ctx,
-+					      struct pfm_event_set *set)
-+{
-+	pfm_arch_start(current, ctx);
-+}
-+
-+
-+static inline int pfm_arch_pmu_config_init(struct pfm_pmu_config *cfg)
-+{
-+	return 0;
-+}
-+
-+static inline int pfm_arch_context_create(struct pfm_context *ctx,
-+					  u32 ctx_flags)
-+{
-+	return 0;
-+}
-+
-+static inline void pfm_arch_context_free(struct pfm_context *ctx)
-+{}
-+
-+/* not necessary on PowerPC */
-+static inline void pfm_cacheflush(void *addr, unsigned int len)
-+{}
-+
-+/*
-+ * function called from pfm_setfl_sane(). Context is locked
-+ * and interrupts are masked.
-+ * The value of flags is the value of ctx_flags as passed by
-+ * user.
-+ *
-+ * function must check arch-specific set flags.
-+ * Return:
-+ * 	1 when flags are valid
-+ *      0 on error
-+ */
-+static inline int pfm_arch_setfl_sane(struct pfm_context *ctx, u32 flags)
-+{
-+	return 0;
-+}
-+
-+static inline int pfm_arch_init(void)
-+{
-+	return 0;
-+}
-+
-+static inline int pfm_arch_load_context(struct pfm_context *ctx)
-+{
-+	struct pfm_arch_pmu_info *arch_info;
-+	int rc = 0;
-+
-+	arch_info = pfm_pmu_info();
-+	if (arch_info->load_context)
-+		rc = arch_info->load_context(ctx);
-+
-+	return rc;
-+}
-+
-+static inline void pfm_arch_unload_context(struct pfm_context *ctx)
-+{
-+	struct pfm_arch_pmu_info *arch_info;
-+
-+	arch_info = pfm_pmu_info();
-+	if (arch_info->unload_context)
-+		arch_info->unload_context(ctx);
-+}
-+
-+static inline int pfm_arch_pmu_acquire(u64 *unavail_pmcs, u64 *unavail_pmds)
-+{
-+	struct pfm_arch_pmu_info *arch_info;
-+	int rc = 0;
-+
-+	arch_info = pfm_pmu_info();
-+	if (arch_info->acquire_pmu) {
-+		rc = arch_info->acquire_pmu(unavail_pmcs, unavail_pmds);
-+		if (rc)
-+			return rc;
-+	}
-+
-+	return reserve_pmc_hardware(powerpc_irq_handler);
-+}
-+
-+static inline void pfm_arch_pmu_release(void)
-+{
-+	struct pfm_arch_pmu_info *arch_info;
-+
-+	arch_info = pfm_pmu_info();
-+	if (arch_info->release_pmu)
-+		arch_info->release_pmu();
-+
-+	release_pmc_hardware();
-+}
-+
-+static inline void pfm_arch_arm_handle_work(struct task_struct *task)
-+{}
-+
-+static inline void pfm_arch_disarm_handle_work(struct task_struct *task)
-+{}
-+
-+static inline int pfm_arch_get_base_syscall(void)
-+{
-+	return __NR_pfm_create_context;
-+}
-+
-+struct pfm_arch_context {
-+	/* Cell: Most recent value of the pm_status
-+	 * register read by the interrupt handler.
-+	 *
-+	 * Interrupt handler sets last_read_updated if it
-+	 * just read and updated last_read_pm_status
-+	 */
-+	u32 last_read_pm_status;
-+	u32 last_read_updated;
-+	u64 powergs_pmc5, powergs_pmc6;
-+	u64 delta_tb, delta_tb_start;
-+	u64 delta_purr, delta_purr_start;
-+};
-+
-+#define PFM_ARCH_CTX_SIZE sizeof(struct pfm_arch_context)
-+/*
-+ * PowerPC does not need extra alignment requirements for the sampling buffer
-+ */
-+#define PFM_ARCH_SMPL_ALIGN_SIZE	0
-+
-+#endif /* CONFIG_PERFMON */
-+
-+#endif /* __KERNEL__ */
-+#endif /* _ASM_POWERPC_PERFMON_KERN_H_ */
-diff --git a/arch/powerpc/include/asm/reg.h b/arch/powerpc/include/asm/reg.h
-index c6d1ab6..a9f3ad0 100644
---- a/arch/powerpc/include/asm/reg.h
-+++ b/arch/powerpc/include/asm/reg.h
-@@ -698,6 +698,7 @@
- #define PV_POWER5	0x003A
- #define PV_POWER5p	0x003B
- #define PV_970FX	0x003C
-+#define PV_POWER6	0x003E
- #define PV_630		0x0040
- #define PV_630p	0x0041
- #define PV_970MP	0x0044
-diff --git a/arch/powerpc/include/asm/systbl.h b/arch/powerpc/include/asm/systbl.h
-index f6cc7a4..0164841 100644
---- a/arch/powerpc/include/asm/systbl.h
-+++ b/arch/powerpc/include/asm/systbl.h
-@@ -322,3 +322,15 @@ SYSCALL_SPU(epoll_create1)
- SYSCALL_SPU(dup3)
- SYSCALL_SPU(pipe2)
- SYSCALL(inotify_init1)
-+SYSCALL(pfm_create_context)
-+SYSCALL(pfm_write_pmcs)
-+SYSCALL(pfm_write_pmds)
-+SYSCALL(pfm_read_pmds)
-+SYSCALL(pfm_load_context)
-+SYSCALL(pfm_start)
-+SYSCALL(pfm_stop)
-+SYSCALL(pfm_restart)
-+SYSCALL(pfm_create_evtsets)
-+SYSCALL(pfm_getinfo_evtsets)
-+SYSCALL(pfm_delete_evtsets)
-+SYSCALL(pfm_unload_context)
-diff --git a/arch/powerpc/include/asm/thread_info.h b/arch/powerpc/include/asm/thread_info.h
-index 9665a26..6cda9f9 100644
---- a/arch/powerpc/include/asm/thread_info.h
-+++ b/arch/powerpc/include/asm/thread_info.h
-@@ -130,10 +130,12 @@ static inline struct thread_info *current_thread_info(void)
- #define _TIF_FREEZE		(1<<TIF_FREEZE)
- #define _TIF_RUNLATCH		(1<<TIF_RUNLATCH)
- #define _TIF_ABI_PENDING	(1<<TIF_ABI_PENDING)
-+#define _TIF_PERFMON_WORK	(1<<TIF_PERFMON_WORK)
-+#define _TIF_PERFMON_CTXSW	(1<<TIF_PERFMON_CTXSW)
- #define _TIF_SYSCALL_T_OR_A	(_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT|_TIF_SECCOMP)
- 
- #define _TIF_USER_WORK_MASK	(_TIF_SIGPENDING | _TIF_NEED_RESCHED | \
--				 _TIF_NOTIFY_RESUME)
-+				 _TIF_NOTIFY_RESUME | _TIF_PERFMON_WORK)
- #define _TIF_PERSYSCALL_MASK	(_TIF_RESTOREALL|_TIF_NOERROR)
- 
- /* Bits in local_flags */
-diff --git a/arch/powerpc/include/asm/unistd.h b/arch/powerpc/include/asm/unistd.h
-index e07d0c7..6226cba 100644
---- a/arch/powerpc/include/asm/unistd.h
-+++ b/arch/powerpc/include/asm/unistd.h
-@@ -341,10 +341,22 @@
- #define __NR_dup3		316
- #define __NR_pipe2		317
- #define __NR_inotify_init1	318
-+#define __NR_pfm_create_context	319
-+#define __NR_pfm_write_pmcs	320
-+#define __NR_pfm_write_pmds	321
-+#define __NR_pfm_read_pmds	322
-+#define __NR_pfm_load_context	323
-+#define __NR_pfm_start		324
-+#define __NR_pfm_stop		325
-+#define __NR_pfm_restart	326
-+#define __NR_pfm_create_evtsets	327
-+#define __NR_pfm_getinfo_evtsets 328
-+#define __NR_pfm_delete_evtsets 329
-+#define __NR_pfm_unload_context	330
- 
- #ifdef __KERNEL__
- 
--#define __NR_syscalls		319
-+#define __NR_syscalls		331
- 
- #define __NR__exit __NR_exit
- #define NR_syscalls	__NR_syscalls
-diff --git a/arch/powerpc/kernel/entry_32.S b/arch/powerpc/kernel/entry_32.S
-index 1cbbf70..198645f 100644
---- a/arch/powerpc/kernel/entry_32.S
-+++ b/arch/powerpc/kernel/entry_32.S
-@@ -39,7 +39,7 @@
-  * MSR_KERNEL is > 0x10000 on 4xx/Book-E since it include MSR_CE.
-  */
- #if MSR_KERNEL >= 0x10000
--#define LOAD_MSR_KERNEL(r, x)	lis r,(x)@h; ori r,r,(x)@l
-+#define LOAD_MSR_KERNEL(r, x)	lis r,(x)@ha; ori r,r,(x)@l
- #else
- #define LOAD_MSR_KERNEL(r, x)	li r,(x)
- #endif
-diff --git a/arch/powerpc/kernel/entry_64.S b/arch/powerpc/kernel/entry_64.S
-index 2d802e9..77a090d 100644
---- a/arch/powerpc/kernel/entry_64.S
-+++ b/arch/powerpc/kernel/entry_64.S
-@@ -643,6 +643,10 @@ user_work:
- 	b	.ret_from_except_lite
- 
- 1:	bl	.save_nvgprs
-+#ifdef CONFIG_PERFMON
-+	addi	r3,r1,STACK_FRAME_OVERHEAD
-+	bl	.pfm_handle_work
-+#endif /* CONFIG_PERFMON */
- 	addi	r3,r1,STACK_FRAME_OVERHEAD
- 	bl	.do_signal
- 	b	.ret_from_except
-diff --git a/arch/powerpc/kernel/irq.c b/arch/powerpc/kernel/irq.c
-index d972dec..b255fba 100644
---- a/arch/powerpc/kernel/irq.c
-+++ b/arch/powerpc/kernel/irq.c
-@@ -104,6 +104,24 @@ static inline notrace void set_soft_enabled(unsigned long enable)
- 	: : "r" (enable), "i" (offsetof(struct paca_struct, soft_enabled)));
- }
- 
-+#ifdef CONFIG_PERFMON
-+static inline unsigned long get_pmu_except_pending(void)
-+{
-+	unsigned long pending;
-+
-+	__asm__ __volatile__("lbz %0,%1(13)"
-+	: "=r" (pending) : "i" (offsetof(struct paca_struct, pmu_except_pending)));
-+
-+	return pending;
-+}
-+
-+static inline void set_pmu_except_pending(unsigned long pending)
-+{
-+	__asm__ __volatile__("stb %0,%1(13)"
-+	: : "r" (pending), "i" (offsetof(struct paca_struct, pmu_except_pending)));
-+}
-+#endif /* CONFIG_PERFMON */
-+
- notrace void raw_local_irq_restore(unsigned long en)
- {
- 	/*
-@@ -162,6 +180,19 @@ notrace void raw_local_irq_restore(unsigned long en)
- 		lv1_get_version_info(&tmp);
- 	}
- 
-+#ifdef CONFIG_PERFMON
-+	/*
-+	 * If a PMU exception occurred while interrupts were soft disabled,
-+	 * force a PMU exception.
-+	 */
-+	if (get_pmu_except_pending()) {
-+		set_pmu_except_pending(0);
-+		/* Make sure we trigger the edge detection circuitry */
-+		mtspr(SPRN_MMCR0, mfspr(SPRN_MMCR0) & ~MMCR0_PMAO);
-+		mtspr(SPRN_MMCR0, mfspr(SPRN_MMCR0) | MMCR0_PMAO);
-+	}
-+#endif /* CONFIG_PERFMON */
-+
- 	__hard_irq_enable();
- }
- EXPORT_SYMBOL(raw_local_irq_restore);
-diff --git a/arch/powerpc/kernel/process.c b/arch/powerpc/kernel/process.c
-index 957bded..32dbc8e 100644
---- a/arch/powerpc/kernel/process.c
-+++ b/arch/powerpc/kernel/process.c
-@@ -33,6 +33,7 @@
- #include <linux/mqueue.h>
- #include <linux/hardirq.h>
- #include <linux/utsname.h>
-+#include <linux/perfmon_kern.h>
- 
- #include <asm/pgtable.h>
- #include <asm/uaccess.h>
-@@ -393,9 +394,14 @@ struct task_struct *__switch_to(struct task_struct *prev,
- 		new_thread->start_tb = current_tb;
- 	}
- #endif
--
- 	local_irq_save(flags);
- 
-+	if (test_tsk_thread_flag(prev, TIF_PERFMON_CTXSW))
-+		pfm_ctxsw_out(prev, new);
-+
-+	if (test_tsk_thread_flag(new, TIF_PERFMON_CTXSW))
-+		pfm_ctxsw_in(prev, new);
-+
- 	account_system_vtime(current);
- 	account_process_vtime(current);
- 	calculate_steal_time();
-@@ -544,6 +550,7 @@ void show_regs(struct pt_regs * regs)
- void exit_thread(void)
- {
- 	discard_lazy_cpu_state();
-+	pfm_exit_thread();
- }
- 
- void flush_thread(void)
-@@ -669,6 +676,7 @@ int copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
- #else
- 	kregs->nip = (unsigned long)ret_from_fork;
- #endif
-+	pfm_copy_thread(p);
- 
- 	return 0;
- }
-diff --git a/arch/powerpc/perfmon/Kconfig b/arch/powerpc/perfmon/Kconfig
-new file mode 100644
-index 0000000..3f4bbf2
---- /dev/null
-+++ b/arch/powerpc/perfmon/Kconfig
-@@ -0,0 +1,67 @@
-+menu "Hardware Performance Monitoring support"
-+config PERFMON
-+	bool "Perfmon2 performance monitoring interface"
-+	default n
-+	help
-+	Enables the perfmon2 interface to access the hardware
-+	performance counters. See <http://perfmon2.sf.net/> for
-+	more details.
-+
-+config PERFMON_DEBUG
-+	bool "Perfmon debugging"
-+	default n
-+	depends on PERFMON
-+	help
-+	Enables perfmon debugging support
-+
-+config PERFMON_DEBUG_FS
-+	bool "Enable perfmon statistics reporting via debugfs"
-+	default y
-+	depends on PERFMON && DEBUG_FS
-+	help
-+	Enable collection and reporting of perfmon timing statistics under
-+	debugfs. This is used for debugging and performance analysis of the
-+	subsystem. The debugfs filesystem must be mounted.
-+
-+config PERFMON_POWER4
-+	tristate "Support for Power4 hardware performance counters"
-+	depends on PERFMON && PPC64
-+	default n
-+	help
-+	Enables support for the Power 4 hardware performance counters
-+	If unsure, say M.
-+
-+config PERFMON_POWER5
-+	tristate "Support for Power5 hardware performance counters"
-+	depends on PERFMON && PPC64
-+	default n
-+	help
-+	Enables support for the Power 5 hardware performance counters
-+	If unsure, say M.
-+
-+config PERFMON_POWER6
-+	tristate "Support for Power6 hardware performance counters"
-+	depends on PERFMON && PPC64
-+	default n
-+	help
-+	Enables support for the Power 6 hardware performance counters
-+	If unsure, say M.
-+
-+config PERFMON_PPC32
-+	tristate "Support for PPC32 hardware performance counters"
-+	depends on PERFMON && PPC32
-+	default n
-+	help
-+	Enables support for the PPC32 hardware performance counters
-+	If unsure, say M.
-+
-+config PERFMON_CELL
-+	tristate "Support for Cell hardware performance counters"
-+	depends on PERFMON && PPC_CELL
-+	select PS3_LPM if PPC_PS3
-+	default n
-+	help
-+	Enables support for the Cell hardware performance counters.
-+	If unsure, say M.
-+
-+endmenu
-diff --git a/arch/powerpc/perfmon/Makefile b/arch/powerpc/perfmon/Makefile
-new file mode 100644
-index 0000000..300661f
---- /dev/null
-+++ b/arch/powerpc/perfmon/Makefile
-@@ -0,0 +1,6 @@
-+obj-$(CONFIG_PERFMON)		+= perfmon.o
-+obj-$(CONFIG_PERFMON_POWER4)	+= perfmon_power4.o
-+obj-$(CONFIG_PERFMON_POWER5)	+= perfmon_power5.o
-+obj-$(CONFIG_PERFMON_POWER6)	+= perfmon_power6.o
-+obj-$(CONFIG_PERFMON_PPC32)	+= perfmon_ppc32.o
-+obj-$(CONFIG_PERFMON_CELL)	+= perfmon_cell.o
-diff --git a/arch/powerpc/perfmon/perfmon.c b/arch/powerpc/perfmon/perfmon.c
-new file mode 100644
-index 0000000..51a8b6a
---- /dev/null
-+++ b/arch/powerpc/perfmon/perfmon.c
-@@ -0,0 +1,334 @@
-+/*
-+ * This file implements the powerpc specific
-+ * support for the perfmon2 interface
-+ *
-+ * Copyright (c) 2005 David Gibson, IBM Corporation.
-+ *
-+ * based on versions for other architectures:
-+ * Copyright (c) 2005-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/interrupt.h>
-+#include <linux/perfmon_kern.h>
-+
-+static void pfm_stop_active(struct task_struct *task,
-+			    struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	struct pfm_arch_pmu_info *arch_info;
-+
-+	arch_info = pfm_pmu_info();
-+	BUG_ON(!arch_info->disable_counters || !arch_info->get_ovfl_pmds);
-+
-+	arch_info->disable_counters(ctx, set);
-+
-+	if (set->npend_ovfls)
-+		return;
-+
-+	arch_info->get_ovfl_pmds(ctx, set);
-+}
-+
-+/*
-+ * Called from pfm_save_pmds(). Interrupts are masked.  Registers are
-+ * already saved away.
-+ */
-+void pfm_arch_clear_pmd_ovfl_cond(struct pfm_context *ctx,
-+				  struct pfm_event_set *set)
-+{
-+	int i, num;
-+	u64 *used_pmds, *intr_pmds;
-+
-+	num = set->nused_pmds;
-+	used_pmds = set->used_pmds;
-+	intr_pmds = ctx->regs.intr_pmds;
-+
-+	for (i = 0; num; i++)
-+		if (likely(test_bit(i, used_pmds))) {
-+			if (likely(test_bit(i, intr_pmds)))
-+				pfm_write_pmd(ctx, i, 0);
-+			num--;
-+		}
-+}
-+
-+/*
-+ * Called from pfm_ctxsw(). Task is guaranteed to be current.
-+ * Context is locked. Interrupts are masked. Monitoring is active.
-+ * PMU access is guaranteed. PMC and PMD registers are live in PMU.
-+ *
-+ * for per-thread:
-+ * 	must stop monitoring for the task
-+ * Return:
-+ * 	non-zero : did not save PMDs (as part of stopping the PMU)
-+ * 	       0 : saved PMDs (no need to save them in caller)
-+ */
-+int pfm_arch_ctxswout_thread(struct task_struct *task, struct pfm_context *ctx)
-+{
-+	struct pfm_arch_pmu_info *arch_info;
-+
-+	arch_info = pfm_pmu_info();
-+	/*
-+	 * disable lazy restore of the PMC/PMD registers.
-+	 */
-+	ctx->active_set->priv_flags |= PFM_SETFL_PRIV_MOD_BOTH;
-+
-+	if (ctx->state == PFM_CTX_MASKED)
-+		return 1;
-+
-+	pfm_stop_active(task, ctx, ctx->active_set);
-+
-+	if (arch_info->ctxswout_thread)
-+		arch_info->ctxswout_thread(task, ctx, ctx->active_set);
-+
-+	return pfm_arch_is_active(ctx);
-+}
-+
-+/*
-+ * Called from pfm_ctxsw
-+ */
-+void pfm_arch_ctxswin_thread(struct task_struct *task, struct pfm_context *ctx)
-+{
-+	struct pfm_arch_pmu_info *arch_info;
-+
-+	arch_info = pfm_pmu_info();
-+	if (ctx->state != PFM_CTX_MASKED && ctx->flags.started == 1) {
-+		BUG_ON(!arch_info->enable_counters);
-+		arch_info->enable_counters(ctx, ctx->active_set);
-+	}
-+
-+	if (arch_info->ctxswin_thread)
-+		arch_info->ctxswin_thread(task, ctx, ctx->active_set);
-+}
-+
-+/*
-+ * Called from pfm_stop() and idle notifier
-+ *
-+ * Interrupts are masked. Context is locked. Set is the active set.
-+ *
-+ * For per-thread:
-+ *   task is not necessarily current. If not current task, then
-+ *   task is guaranteed stopped and off any cpu. Access to PMU
-+ *   is not guaranteed. Interrupts are masked. Context is locked.
-+ *   Set is the active set.
-+ *
-+ * For system-wide:
-+ * 	task is current
-+ *
-+ * must disable active monitoring. ctx cannot be NULL
-+ */
-+void pfm_arch_stop(struct task_struct *task, struct pfm_context *ctx)
-+{
-+	/*
-+	 * no need to go through stop_save()
-+	 * if we are already stopped
-+	 */
-+	if (!ctx->flags.started || ctx->state == PFM_CTX_MASKED)
-+		return;
-+
-+	/*
-+	 * stop live registers and collect pending overflow
-+	 */
-+	if (task == current)
-+		pfm_stop_active(task, ctx, ctx->active_set);
-+}
-+
-+/*
-+ * Enable active monitoring. Called from pfm_start() and
-+ * pfm_arch_unmask_monitoring().
-+ *
-+ * Interrupts are masked. Context is locked. Set is the active set.
-+ *
-+ * For per-thread:
-+ * 	Task is not necessarily current. If not current task, then task
-+ * 	is guaranteed stopped and off any cpu. No access to PMU if task
-+ *	is not current.
-+ *
-+ * For system-wide:
-+ * 	Task is always current
-+ */
-+void pfm_arch_start(struct task_struct *task, struct pfm_context *ctx)
-+{
-+	struct pfm_arch_pmu_info *arch_info;
-+
-+	arch_info = pfm_pmu_info();
-+	if (task != current)
-+		return;
-+
-+	BUG_ON(!arch_info->enable_counters);
-+
-+	arch_info->enable_counters(ctx, ctx->active_set);
-+}
-+
-+/*
-+ * function called from pfm_switch_sets(), pfm_context_load_thread(),
-+ * pfm_context_load_sys(), pfm_ctxsw(), pfm_switch_sets()
-+ * context is locked. Interrupts are masked. set cannot be NULL.
-+ * Access to the PMU is guaranteed.
-+ *
-+ * function must restore all PMD registers from set.
-+ */
-+void pfm_arch_restore_pmds(struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	struct pfm_arch_pmu_info *arch_info;
-+	u64 *used_pmds;
-+	u16 i, num;
-+
-+	arch_info = pfm_pmu_info();
-+
-+	/* The model-specific module can override the default
-+	 * restore-PMD method.
-+	 */
-+	if (arch_info->restore_pmds)
-+		return arch_info->restore_pmds(ctx, set);
-+
-+	num = set->nused_pmds;
-+	used_pmds = set->used_pmds;
-+
-+	for (i = 0; num; i++) {
-+		if (likely(test_bit(i, used_pmds))) {
-+			pfm_write_pmd(ctx, i, set->pmds[i].value);
-+			num--;
-+		}
-+	}
-+}
-+
-+/*
-+ * function called from pfm_switch_sets(), pfm_context_load_thread(),
-+ * pfm_context_load_sys(), pfm_ctxsw(), pfm_switch_sets()
-+ * context is locked. Interrupts are masked. set cannot be NULL.
-+ * Access to the PMU is guaranteed.
-+ *
-+ * function must restore all PMC registers from set, if needed.
-+ */
-+void pfm_arch_restore_pmcs(struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	struct pfm_arch_pmu_info *arch_info;
-+	u64 *impl_pmcs;
-+	unsigned int i, max_pmc, reg;
-+
-+	arch_info = pfm_pmu_info();
-+	/* The model-specific module can override the default
-+	 * restore-PMC method.
-+	 */
-+	if (arch_info->restore_pmcs)
-+		return arch_info->restore_pmcs(ctx, set);
-+
-+	/* The "common" powerpc model's enable the counters simply by writing
-+	 * all the control registers. Therefore, if we're masked or stopped we
-+	 * don't need to bother restoring the PMCs now.
-+	 */
-+	if (ctx->state == PFM_CTX_MASKED || ctx->flags.started == 0)
-+		return;
-+
-+	max_pmc = ctx->regs.max_pmc;
-+	impl_pmcs = ctx->regs.pmcs;
-+
-+	/*
-+	 * Restore all pmcs in reverse order to ensure the counters aren't
-+	 * enabled before their event selectors are set correctly.
-+	 */
-+	reg = max_pmc - 1;
-+	for (i = 0; i < max_pmc; i++) {
-+		if (test_bit(reg, impl_pmcs))
-+			pfm_arch_write_pmc(ctx, reg, set->pmcs[reg]);
-+		reg--;
-+	}
-+}
-+
-+char *pfm_arch_get_pmu_module_name(void)
-+{
-+	unsigned int pvr = mfspr(SPRN_PVR);
-+
-+	switch (PVR_VER(pvr)) {
-+	case 0x0004: /* 604 */
-+	case 0x0009: /* 604e;  */
-+	case 0x000A: /* 604ev */
-+	case 0x0008: /* 750/740 */
-+	case 0x7000: /* 750FX */
-+	case 0x7001:
-+	case 0x7002: /* 750GX */
-+	case 0x000C: /* 7400 */
-+	case 0x800C: /* 7410 */
-+	case 0x8000: /* 7451/7441 */
-+	case 0x8001: /* 7455/7445 */
-+	case 0x8002: /* 7457/7447 */
-+	case 0x8003: /* 7447A */
-+	case 0x8004: /* 7448 */
-+		return("perfmon_ppc32");
-+	case PV_POWER4:
-+	case PV_POWER4p:
-+		return "perfmon_power4";
-+	case PV_POWER5:
-+		return "perfmon_power5";
-+	case PV_POWER5p:
-+		if (PVR_REV(pvr) < 0x300)
-+			/* PMU behaves like POWER5 */
-+			return "perfmon_power5";
-+		else
-+			/* PMU behaves like POWER6 */
-+			return "perfmon_power6";
-+	case PV_POWER6:
-+		return "perfmon_power6";
-+	case PV_970:
-+	case PV_970FX:
-+	case PV_970MP:
-+		return "perfmon_ppc970";
-+	case PV_BE:
-+		return "perfmon_cell";
-+	}
-+	return NULL;
-+}
-+
-+void pfm_arch_init_percpu(void)
-+{
-+#ifdef CONFIG_PPC64
-+	extern void ppc64_enable_pmcs(void);
-+	ppc64_enable_pmcs();
-+#endif
-+}
-+
-+/**
-+ * powerpc_irq_handler
-+ *
-+ * Get the perfmon context that belongs to the current CPU, and call the
-+ * model-specific interrupt handler.
-+ **/
-+void powerpc_irq_handler(struct pt_regs *regs)
-+{
-+	struct pfm_arch_pmu_info *arch_info;
-+	struct pfm_context *ctx;
-+
-+	if (! regs->softe) {
-+		/*
-+		 * We got a PMU interrupt while interrupts were soft
-+		 * disabled.  Disable hardware interrupts by clearing
-+		 * MSR_EE and also clear PMAO because we will need to set
-+		 * that again later when interrupts are re-enabled and
-+		 * raw_local_irq_restore() sees that the pmu_except_pending
-+		 * flag is set.
-+		 */
-+		regs->msr &= ~MSR_EE;
-+		get_paca()->pmu_except_pending = 1;
-+		mtspr(SPRN_MMCR0, mfspr(SPRN_MMCR0) & ~MMCR0_PMAO);
-+		return;
-+	}
-+
-+	arch_info = pfm_pmu_info();
-+	if (arch_info->irq_handler) {
-+		ctx = __get_cpu_var(pmu_ctx);
-+		if (likely(ctx))
-+			arch_info->irq_handler(regs, ctx);
-+	}
-+}
-diff --git a/arch/powerpc/perfmon/perfmon_cell.c b/arch/powerpc/perfmon/perfmon_cell.c
-new file mode 100644
-index 0000000..e1ae12c
---- /dev/null
-+++ b/arch/powerpc/perfmon/perfmon_cell.c
-@@ -0,0 +1,1449 @@
-+/*
-+ * This file contains the Cell PMU register description tables
-+ * and pmc checker used by perfmon.c.
-+ *
-+ * Copyright IBM Corporation 2007
-+ * (C) Copyright 2007 TOSHIBA CORPORATION
-+ *
-+ * Based on other Perfmon2 PMU modules.
-+ * Copyright (c) 2005-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+
-+#include <linux/module.h>
-+#include <linux/perfmon_kern.h>
-+#include <linux/io.h>
-+#include <asm/cell-pmu.h>
-+#include <asm/cell-regs.h>
-+#include <asm/machdep.h>
-+#include <asm/rtas.h>
-+#include <asm/ps3.h>
-+#include <asm/spu.h>
-+
-+MODULE_AUTHOR("Kevin Corry <kevcorry@us.ibm.com>, "
-+	      "Carl Love <carll@us.ibm.com>");
-+MODULE_DESCRIPTION("Cell PMU description table");
-+MODULE_LICENSE("GPL");
-+
-+struct pfm_cell_platform_pmu_info {
-+	u32  (*read_ctr)(u32 cpu, u32 ctr);
-+	void (*write_ctr)(u32 cpu, u32 ctr, u32 val);
-+	void (*write_pm07_control)(u32 cpu, u32 ctr, u32 val);
-+	void (*write_pm)(u32 cpu, enum pm_reg_name reg, u32 val);
-+	void (*enable_pm)(u32 cpu);
-+	void (*disable_pm)(u32 cpu);
-+	void (*enable_pm_interrupts)(u32 cpu, u32 thread, u32 mask);
-+	u32  (*get_and_clear_pm_interrupts)(u32 cpu);
-+	u32  (*get_hw_thread_id)(int cpu);
-+	struct cbe_ppe_priv_regs __iomem *(*get_cpu_ppe_priv_regs)(int cpu);
-+	struct cbe_pmd_regs __iomem *(*get_cpu_pmd_regs)(int cpu);
-+	struct cbe_mic_tm_regs __iomem *(*get_cpu_mic_tm_regs)(int cpu);
-+	int (*rtas_token)(const char *service);
-+	int (*rtas_call)(int token, int param1, int param2, int *param3, ...);
-+};
-+
-+/*
-+ * Mapping from Perfmon logical control registers to Cell hardware registers.
-+ */
-+static struct pfm_regmap_desc pfm_cell_pmc_desc[] = {
-+	/* Per-counter control registers. */
-+	PMC_D(PFM_REG_I, "pm0_control",       0, 0, 0, 0),
-+	PMC_D(PFM_REG_I, "pm1_control",       0, 0, 0, 0),
-+	PMC_D(PFM_REG_I, "pm2_control",       0, 0, 0, 0),
-+	PMC_D(PFM_REG_I, "pm3_control",       0, 0, 0, 0),
-+	PMC_D(PFM_REG_I, "pm4_control",       0, 0, 0, 0),
-+	PMC_D(PFM_REG_I, "pm5_control",       0, 0, 0, 0),
-+	PMC_D(PFM_REG_I, "pm6_control",       0, 0, 0, 0),
-+	PMC_D(PFM_REG_I, "pm7_control",       0, 0, 0, 0),
-+
-+	/* Per-counter RTAS arguments. Each of these registers has three fields.
-+	 *   bits 63-48: debug-bus word
-+	 *   bits 47-32: sub-unit
-+	 *   bits 31-0 : full signal number
-+	 *   (MSB = 63, LSB = 0)
-+	 */
-+	PMC_D(PFM_REG_I, "pm0_event",         0, 0, 0, 0),
-+	PMC_D(PFM_REG_I, "pm1_event",         0, 0, 0, 0),
-+	PMC_D(PFM_REG_I, "pm2_event",         0, 0, 0, 0),
-+	PMC_D(PFM_REG_I, "pm3_event",         0, 0, 0, 0),
-+	PMC_D(PFM_REG_I, "pm4_event",         0, 0, 0, 0),
-+	PMC_D(PFM_REG_I, "pm5_event",         0, 0, 0, 0),
-+	PMC_D(PFM_REG_I, "pm6_event",         0, 0, 0, 0),
-+	PMC_D(PFM_REG_I, "pm7_event",         0, 0, 0, 0),
-+
-+	/* Global control registers. Same order as enum pm_reg_name. */
-+	PMC_D(PFM_REG_I, "group_control",     0, 0, 0, 0),
-+	PMC_D(PFM_REG_I, "debug_bus_control", 0, 0, 0, 0),
-+	PMC_D(PFM_REG_I, "trace_address",     0, 0, 0, 0),
-+	PMC_D(PFM_REG_I, "ext_trace_timer",   0, 0, 0, 0),
-+	PMC_D(PFM_REG_I, "pm_status",         0, 0, 0, 0),
-+	/* set the interrupt overflow bit for the four 32 bit counters
-+	 * that is currently supported.  Will need to fix when 32 and 16
-+	 * bit counters are supported.
-+	 */
-+	PMC_D(PFM_REG_I, "pm_control",        0xF0000000, 0xF0000000, 0, 0),
-+	PMC_D(PFM_REG_I, "pm_interval",       0, 0, 0, 0), /* FIX: Does user-space also need read access to this one? */
-+	PMC_D(PFM_REG_I, "pm_start_stop",     0, 0, 0, 0),
-+};
-+#define PFM_PM_NUM_PMCS	ARRAY_SIZE(pfm_cell_pmc_desc)
-+
-+#define CELL_PMC_GROUP_CONTROL    16
-+#define CELL_PMC_PM_STATUS        20
-+#define CELL_PMC_PM_CONTROL       21
-+#define CELL_PMC_PM_CONTROL_CNTR_MASK   0x01E00000UL
-+#define CELL_PMC_PM_CONTROL_CNTR_16     0x01E00000UL
-+
-+/*
-+ * Mapping from Perfmon logical data counters to Cell hardware counters.
-+ */
-+static struct pfm_regmap_desc pfm_cell_pmd_desc[] = {
-+	PMD_D(PFM_REG_C, "pm0", 0),
-+	PMD_D(PFM_REG_C, "pm1", 0),
-+	PMD_D(PFM_REG_C, "pm2", 0),
-+	PMD_D(PFM_REG_C, "pm3", 0),
-+	PMD_D(PFM_REG_C, "pm4", 0),
-+	PMD_D(PFM_REG_C, "pm5", 0),
-+	PMD_D(PFM_REG_C, "pm6", 0),
-+	PMD_D(PFM_REG_C, "pm7", 0),
-+};
-+#define PFM_PM_NUM_PMDS	ARRAY_SIZE(pfm_cell_pmd_desc)
-+
-+#define PFM_EVENT_PMC_BUS_WORD(x)      (((x) >> 48) & 0x00ff)
-+#define PFM_EVENT_PMC_FULL_SIGNAL_NUMBER(x) ((x) & 0xffffffff)
-+#define PFM_EVENT_PMC_SIGNAL_GROUP(x) (((x) & 0xffffffff) / 100)
-+#define PFM_PM_CTR_INPUT_MUX_BIT(pm07_control) (((pm07_control) >> 26) & 0x1f)
-+#define PFM_PM_CTR_INPUT_MUX_GROUP_INDEX(pm07_control) ((pm07_control) >> 31)
-+#define PFM_GROUP_CONTROL_GROUP0_WORD(grp_ctrl) ((grp_ctrl) >> 30)
-+#define PFM_GROUP_CONTROL_GROUP1_WORD(grp_ctrl) (((grp_ctrl) >> 28) & 0x3)
-+#define PFM_NUM_OF_GROUPS 2
-+#define PFM_PPU_IU1_THREAD1_BASE_BIT 19
-+#define PFM_PPU_XU_THREAD1_BASE_BIT  16
-+#define PFM_COUNTER_CTRL_PMC_PPU_TH0 0x100000000ULL
-+#define PFM_COUNTER_CTRL_PMC_PPU_TH1 0x200000000ULL
-+
-+/*
-+ * Debug-bus signal handling.
-+ *
-+ * Some Cell systems have firmware that can handle the debug-bus signal
-+ * routing. For systems without this firmware, we have a minimal in-kernel
-+ * implementation as well.
-+ */
-+
-+/* The firmware only sees physical CPUs, so divide by 2 if SMT is on. */
-+#ifdef CONFIG_SCHED_SMT
-+#define RTAS_CPU(cpu) ((cpu) / 2)
-+#else
-+#define RTAS_CPU(cpu) (cpu)
-+#endif
-+#define RTAS_BUS_WORD(x)      (u16)(((x) >> 48) & 0x0000ffff)
-+#define RTAS_SUB_UNIT(x)      (u16)(((x) >> 32) & 0x0000ffff)
-+#define RTAS_SIGNAL_NUMBER(x) (s32)( (x)        & 0xffffffff)
-+#define RTAS_SIGNAL_GROUP(x)  (RTAS_SIGNAL_NUMBER(x) / 100)
-+
-+#define subfunc_RESET		1
-+#define subfunc_ACTIVATE	2
-+
-+#define passthru_ENABLE		1
-+#define passthru_DISABLE	2
-+
-+/**
-+ * struct cell_rtas_arg
-+ *
-+ * @cpu: Processor to modify. Linux numbers CPUs based on SMT IDs, but the
-+ *       firmware only sees the physical CPUs. So this value should be the
-+ *       SMT ID (from smp_processor_id() or get_cpu()) divided by 2.
-+ * @sub_unit: Hardware subunit this applies to (if applicable).
-+ * @signal_group: Signal group to enable/disable on the trace bus.
-+ * @bus_word: For signal groups that propagate via the trace bus, this trace
-+ *            bus word will be used. This is a mask of (1 << TraceBusWord).
-+ *            For other signal groups, this specifies the trigger or event bus.
-+ * @bit: Trigger/Event bit, if applicable for the signal group.
-+ *
-+ * An array of these structures are passed to rtas_call() to set up the
-+ * signals on the debug bus.
-+ **/
-+struct cell_rtas_arg {
-+	u16 cpu;
-+	u16 sub_unit;
-+	s16 signal_group;
-+	u8 bus_word;
-+	u8 bit;
-+};
-+
-+/**
-+ * rtas_reset_signals
-+ *
-+ * Use the firmware RTAS call to disable signal pass-thru and to reset the
-+ * debug-bus signals.
-+ **/
-+static int rtas_reset_signals(u32 cpu)
-+{
-+	struct cell_rtas_arg signal;
-+	u64 real_addr = virt_to_phys(&signal);
-+	int rc;
-+	struct pfm_cell_platform_pmu_info *info =
-+		((struct pfm_arch_pmu_info *)
-+		 (pfm_pmu_conf->pmu_info))->platform_info;
-+
-+	memset(&signal, 0, sizeof(signal));
-+	signal.cpu = RTAS_CPU(cpu);
-+	rc = info->rtas_call(info->rtas_token("ibm,cbe-perftools"),
-+		       5, 1, NULL,
-+		       subfunc_RESET,
-+		       passthru_DISABLE,
-+		       real_addr >> 32,
-+		       real_addr & 0xffffffff,
-+		       sizeof(signal));
-+
-+	return rc;
-+}
-+
-+/**
-+ * rtas_activate_signals
-+ *
-+ * Use the firmware RTAS call to enable signal pass-thru and to activate the
-+ * desired signal groups on the debug-bus.
-+ **/
-+static int rtas_activate_signals(struct cell_rtas_arg *signals,
-+				 int num_signals)
-+{
-+	u64 real_addr = virt_to_phys(signals);
-+	int rc;
-+	struct pfm_cell_platform_pmu_info *info =
-+		((struct pfm_arch_pmu_info *)
-+		 (pfm_pmu_conf->pmu_info))->platform_info;
-+
-+	rc = info->rtas_call(info->rtas_token("ibm,cbe-perftools"),
-+		       5, 1, NULL,
-+		       subfunc_ACTIVATE,
-+		       passthru_ENABLE,
-+		       real_addr >> 32,
-+		       real_addr & 0xffffffff,
-+		       num_signals * sizeof(*signals));
-+
-+	return rc;
-+}
-+
-+#define HID1_RESET_MASK			(~0x00000001ffffffffUL)
-+#define PPU_IU1_WORD0_HID1_EN_MASK	(~0x00000001f0c0802cUL)
-+#define PPU_IU1_WORD0_HID1_EN_WORD	( 0x00000001f0400000UL)
-+#define PPU_IU1_WORD1_HID1_EN_MASK	(~0x000000010fc08023UL)
-+#define PPU_IU1_WORD1_HID1_EN_WORD	( 0x000000010f400001UL)
-+#define PPU_XU_WORD0_HID1_EN_MASK	(~0x00000001f038402cUL)
-+#define PPU_XU_WORD0_HID1_EN_WORD	( 0x00000001f0080008UL)
-+#define PPU_XU_WORD1_HID1_EN_MASK	(~0x000000010f074023UL)
-+#define PPU_XU_WORD1_HID1_EN_WORD	( 0x000000010f030002UL)
-+
-+/* The bus_word field in the cell_rtas_arg structure is a bit-mask
-+ * indicating which debug-bus word(s) to use.
-+ */
-+enum {
-+	BUS_WORD_0 = 1,
-+	BUS_WORD_1 = 2,
-+	BUS_WORD_2 = 4,
-+	BUS_WORD_3 = 8,
-+};
-+
-+/* Definitions of the signal-groups that the built-in signal-activation
-+ * code can handle.
-+ */
-+enum {
-+	SIG_GROUP_NONE = 0,
-+
-+	/* 2.x PowerPC Processor Unit (PPU) Signal Groups */
-+	SIG_GROUP_PPU_BASE = 20,
-+	SIG_GROUP_PPU_IU1 = 21,
-+	SIG_GROUP_PPU_XU = 22,
-+
-+	/* 3.x PowerPC Storage Subsystem (PPSS) Signal Groups */
-+	SIG_GROUP_PPSS_BASE = 30,
-+
-+	/* 4.x Synergistic Processor Unit (SPU) Signal Groups */
-+	SIG_GROUP_SPU_BASE = 40,
-+
-+	/* 5.x Memory Flow Controller (MFC) Signal Groups */
-+	SIG_GROUP_MFC_BASE = 50,
-+
-+	/* 6.x Element )nterconnect Bus (EIB) Signal Groups */
-+	SIG_GROUP_EIB_BASE = 60,
-+
-+	/* 7.x Memory Interface Controller (MIC) Signal Groups */
-+	SIG_GROUP_MIC_BASE = 70,
-+
-+	/* 8.x Cell Broadband Engine Interface (BEI) Signal Groups */
-+	SIG_GROUP_BEI_BASE = 80,
-+};
-+
-+/**
-+ * rmw_spr
-+ *
-+ * Read-modify-write for a special-purpose-register.
-+ **/
-+#define rmw_spr(spr_id, a_mask, o_mask) \
-+	do { \
-+		u64 value = mfspr(spr_id); \
-+		value &= (u64)(a_mask); \
-+		value |= (u64)(o_mask); \
-+		mtspr((spr_id), value); \
-+	} while (0)
-+
-+/**
-+ * rmw_mmio_reg64
-+ *
-+ * Read-modify-write for a 64-bit MMIO register.
-+ **/
-+#define rmw_mmio_reg64(mem, a_mask, o_mask) \
-+	do { \
-+		u64 value = in_be64(&(mem)); \
-+		value &= (u64)(a_mask); \
-+		value |= (u64)(o_mask); \
-+		out_be64(&(mem), value); \
-+	} while (0)
-+
-+/**
-+ * rmwb_mmio_reg64
-+ *
-+ * Set or unset a specified bit within a 64-bit MMIO register.
-+ **/
-+#define rmwb_mmio_reg64(mem, bit_num, set_bit) \
-+	rmw_mmio_reg64((mem), ~(1UL << (63 - (bit_num))), \
-+		       ((set_bit) << (63 - (bit_num))))
-+
-+/**
-+ * passthru
-+ *
-+ * Enable or disable passthru mode in all the Cell signal islands.
-+ **/
-+static int passthru(u32 cpu, u64 enable)
-+{
-+	struct cbe_ppe_priv_regs __iomem *ppe_priv_regs;
-+	struct cbe_pmd_regs __iomem *pmd_regs;
-+	struct cbe_mic_tm_regs __iomem *mic_tm_regs;
-+	struct pfm_cell_platform_pmu_info *info =
-+		((struct pfm_arch_pmu_info *)
-+		 (pfm_pmu_conf->pmu_info))->platform_info;
-+
-+	ppe_priv_regs = info->get_cpu_ppe_priv_regs(cpu);
-+	pmd_regs = info->get_cpu_pmd_regs(cpu);
-+	mic_tm_regs = info->get_cpu_mic_tm_regs(cpu);
-+
-+	if (!ppe_priv_regs || !pmd_regs || !mic_tm_regs) {
-+		PFM_ERR("Error getting Cell PPE, PMD, and MIC "
-+			"register maps: 0x%p, 0x%p, 0x%p",
-+			ppe_priv_regs, pmd_regs, mic_tm_regs);
-+		return -EINVAL;
-+	}
-+
-+	rmwb_mmio_reg64(ppe_priv_regs->L2_debug1, 61, enable);
-+	rmwb_mmio_reg64(ppe_priv_regs->ciu_dr1, 5, enable);
-+	rmwb_mmio_reg64(pmd_regs->on_ramp_trace, 39, enable);
-+	rmwb_mmio_reg64(mic_tm_regs->MBL_debug, 20, enable);
-+
-+	return 0;
-+}
-+
-+#define passthru_enable(cpu)  passthru(cpu, 1)
-+#define passthru_disable(cpu) passthru(cpu, 0)
-+
-+static inline void reset_signal_registers(u32 cpu)
-+{
-+	rmw_spr(SPRN_HID1, HID1_RESET_MASK, 0);
-+}
-+
-+/**
-+ * celleb_reset_signals
-+ *
-+ * Non-rtas version of resetting the debug-bus signals.
-+ **/
-+static int celleb_reset_signals(u32 cpu)
-+{
-+	int rc;
-+	rc = passthru_disable(cpu);
-+	if (!rc)
-+		reset_signal_registers(cpu);
-+	return rc;
-+}
-+
-+/**
-+ * ppu_selection
-+ *
-+ * Write the HID1 register to connect the specified PPU signal-group to the
-+ * debug-bus.
-+ **/
-+static int ppu_selection(struct cell_rtas_arg *signal)
-+{
-+	u64 hid1_enable_word = 0;
-+	u64 hid1_enable_mask = 0;
-+
-+	switch (signal->signal_group) {
-+
-+	case SIG_GROUP_PPU_IU1: /* 2.1 PPU Instruction Unit - Group 1 */
-+		switch (signal->bus_word) {
-+		case BUS_WORD_0:
-+			hid1_enable_mask = PPU_IU1_WORD0_HID1_EN_MASK;
-+			hid1_enable_word = PPU_IU1_WORD0_HID1_EN_WORD;
-+			break;
-+		case BUS_WORD_1:
-+			hid1_enable_mask = PPU_IU1_WORD1_HID1_EN_MASK;
-+			hid1_enable_word = PPU_IU1_WORD1_HID1_EN_WORD;
-+			break;
-+		default:
-+			PFM_ERR("Invalid bus-word (0x%x) for signal-group %d.",
-+				signal->bus_word, signal->signal_group);
-+			return -EINVAL;
-+		}
-+		break;
-+
-+	case SIG_GROUP_PPU_XU:  /* 2.2 PPU Execution Unit */
-+		switch (signal->bus_word) {
-+		case BUS_WORD_0:
-+			hid1_enable_mask = PPU_XU_WORD0_HID1_EN_MASK;
-+			hid1_enable_word = PPU_XU_WORD0_HID1_EN_WORD;
-+			break;
-+		case BUS_WORD_1:
-+			hid1_enable_mask = PPU_XU_WORD1_HID1_EN_MASK;
-+			hid1_enable_word = PPU_XU_WORD1_HID1_EN_WORD;
-+			break;
-+		default:
-+			PFM_ERR("Invalid bus-word (0x%x) for signal-group %d.",
-+				signal->bus_word, signal->signal_group);
-+			return -EINVAL;
-+		}
-+		break;
-+
-+	default:
-+		PFM_ERR("Signal-group %d not implemented.",
-+			signal->signal_group);
-+		return -EINVAL;
-+	}
-+
-+	rmw_spr(SPRN_HID1, hid1_enable_mask, hid1_enable_word);
-+
-+	return 0;
-+}
-+
-+/**
-+ * celleb_activate_signals
-+ *
-+ * Non-rtas version of activating the debug-bus signals.
-+ **/
-+static int celleb_activate_signals(struct cell_rtas_arg *signals,
-+				   int num_signals)
-+{
-+	int i, rc = -EINVAL;
-+
-+	for (i = 0; i < num_signals; i++) {
-+		switch (signals[i].signal_group) {
-+
-+		/* 2.x PowerPC Processor Unit (PPU) Signal Selection */
-+		case SIG_GROUP_PPU_IU1:
-+		case SIG_GROUP_PPU_XU:
-+			rc = ppu_selection(signals + i);
-+			if (rc)
-+				return rc;
-+			break;
-+
-+		default:
-+			PFM_ERR("Signal-group %d not implemented.",
-+				signals[i].signal_group);
-+			return -EINVAL;
-+		}
-+	}
-+
-+	if (0 < i)
-+		rc = passthru_enable(signals[0].cpu);
-+
-+	return rc;
-+}
-+
-+/**
-+ * ps3_reset_signals
-+ *
-+ * ps3 version of resetting the debug-bus signals.
-+ **/
-+static int ps3_reset_signals(u32 cpu)
-+{
-+#ifdef CONFIG_PPC_PS3
-+	return ps3_set_signal(0, 0, 0, 0);
-+#else
-+	return 0;
-+#endif
-+}
-+
-+/**
-+ * ps3_activate_signals
-+ *
-+ * ps3 version of activating the debug-bus signals.
-+ **/
-+static int ps3_activate_signals(struct cell_rtas_arg *signals,
-+				int num_signals)
-+{
-+#ifdef CONFIG_PPC_PS3
-+	int i;
-+
-+	for (i = 0; i < num_signals; i++)
-+		ps3_set_signal(signals[i].signal_group, signals[i].bit,
-+			       signals[i].sub_unit, signals[i].bus_word);
-+#endif
-+	return 0;
-+}
-+
-+
-+/**
-+ * reset_signals
-+ *
-+ * Call to the firmware (if available) to reset the debug-bus signals.
-+ * Otherwise call the built-in version.
-+ **/
-+int reset_signals(u32 cpu)
-+{
-+	int rc;
-+
-+	if (machine_is(celleb))
-+		rc = celleb_reset_signals(cpu);
-+	else if (machine_is(ps3))
-+		rc = ps3_reset_signals(cpu);
-+	else
-+		rc = rtas_reset_signals(cpu);
-+
-+	return rc;
-+}
-+
-+/**
-+ * activate_signals
-+ *
-+ * Call to the firmware (if available) to activate the debug-bus signals.
-+ * Otherwise call the built-in version.
-+ **/
-+int activate_signals(struct cell_rtas_arg *signals, int num_signals)
-+{
-+	int rc;
-+
-+	if (machine_is(celleb))
-+		rc = celleb_activate_signals(signals, num_signals);
-+	else if (machine_is(ps3))
-+		rc = ps3_activate_signals(signals, num_signals);
-+	else
-+		rc = rtas_activate_signals(signals, num_signals);
-+
-+	return rc;
-+}
-+
-+/**
-+ *  pfm_cell_pmc_check
-+ *
-+ * Verify that we are going to write a valid value to the specified PMC.
-+ **/
-+int pfm_cell_pmc_check(struct pfm_context *ctx,
-+		       struct pfm_event_set *set,
-+		       struct pfarg_pmc *req)
-+{
-+	u16 cnum, reg_num = req->reg_num;
-+	s16 signal_group = RTAS_SIGNAL_GROUP(req->reg_value);
-+	u8 bus_word = RTAS_BUS_WORD(req->reg_value);
-+
-+	if (reg_num < NR_CTRS || reg_num >= (NR_CTRS * 2))
-+		return -EINVAL;
-+
-+	switch (signal_group) {
-+	case SIG_GROUP_PPU_IU1:
-+	case SIG_GROUP_PPU_XU:
-+		if ((bus_word != 0) && (bus_word != 1)) {
-+			PFM_ERR("Invalid bus word (%d) for signal-group %d",
-+				bus_word, signal_group);
-+			return -EINVAL;
-+		}
-+		break;
-+	default:
-+		PFM_ERR("Signal-group %d not implemented.", signal_group);
-+		return -EINVAL;
-+	}
-+
-+	for (cnum = NR_CTRS; cnum < (NR_CTRS * 2); cnum++) {
-+		if (test_bit(cnum, cast_ulp(set->used_pmcs)) &&
-+		    bus_word == RTAS_BUS_WORD(set->pmcs[cnum]) &&
-+		    signal_group != RTAS_SIGNAL_GROUP(set->pmcs[cnum])) {
-+			PFM_ERR("Impossible signal-group combination: "
-+				"(%u,%u,%d) (%u,%u,%d)",
-+				reg_num, bus_word, signal_group, cnum,
-+				RTAS_BUS_WORD(set->pmcs[cnum]),
-+				RTAS_SIGNAL_GROUP(set->pmcs[cnum]));
-+			return  -EBUSY;
-+		}
-+	}
-+
-+	return 0;
-+}
-+
-+/**
-+ * write_pm07_event
-+ *
-+ * Pull out the RTAS arguments from the 64-bit register value and make the
-+ * RTAS activate-signals call.
-+ **/
-+static void write_pm07_event(int cpu, unsigned int ctr, u64 value)
-+{
-+	struct cell_rtas_arg signal;
-+	s32 signal_number;
-+	int rc;
-+
-+	signal_number = RTAS_SIGNAL_NUMBER(value);
-+	if (!signal_number) {
-+		/* Don't include counters that are counting cycles. */
-+		return;
-+	}
-+
-+	signal.cpu = RTAS_CPU(cpu);
-+	signal.bus_word = 1 << RTAS_BUS_WORD(value);
-+	signal.sub_unit = RTAS_SUB_UNIT(value);
-+	signal.signal_group = signal_number / 100;
-+	signal.bit = abs(signal_number) % 100;
-+
-+	rc = activate_signals(&signal, 1);
-+	if (rc) {
-+		PFM_WARN("%s(%d, %u, %lu): Error calling "
-+			 "activate_signals(): %d\n", __func__,
-+			 cpu, ctr, (unsigned long)value, rc);
-+		/* FIX: Could we change this routine to return an error? */
-+	}
-+}
-+
-+/**
-+ * pfm_cell_probe_pmu
-+ *
-+ * Simply check the processor version register to see if we're currently
-+ * on a Cell system.
-+ **/
-+static int pfm_cell_probe_pmu(void)
-+{
-+	unsigned long pvr = mfspr(SPRN_PVR);
-+
-+	if (PVR_VER(pvr) != PV_BE)
-+		return -1;
-+
-+	return 0;
-+}
-+
-+/**
-+ * pfm_cell_write_pmc
-+ **/
-+static void pfm_cell_write_pmc(unsigned int cnum, u64 value)
-+{
-+	int cpu = smp_processor_id();
-+	struct pfm_cell_platform_pmu_info *info =
-+		((struct pfm_arch_pmu_info *)
-+		 (pfm_pmu_conf->pmu_info))->platform_info;
-+
-+	if (cnum < NR_CTRS) {
-+		info->write_pm07_control(cpu, cnum, value);
-+
-+	} else if (cnum < NR_CTRS * 2) {
-+		write_pm07_event(cpu, cnum - NR_CTRS, value);
-+
-+	} else if (cnum == CELL_PMC_PM_STATUS) {
-+		/* The pm_status register must be treated separately from
-+		 * the other "global" PMCs. This call will ensure that
-+		 * the interrupts are routed to the correct CPU, as well
-+		 * as writing the desired value to the pm_status register.
-+		 */
-+		info->enable_pm_interrupts(cpu, info->get_hw_thread_id(cpu),
-+					   value);
-+
-+	} else if (cnum < PFM_PM_NUM_PMCS) {
-+		info->write_pm(cpu, cnum - (NR_CTRS * 2), value);
-+	}
-+}
-+
-+/**
-+ * pfm_cell_write_pmd
-+ **/
-+static void pfm_cell_write_pmd(unsigned int cnum, u64 value)
-+{
-+	int cpu = smp_processor_id();
-+	struct pfm_cell_platform_pmu_info *info =
-+		((struct pfm_arch_pmu_info *)
-+		 (pfm_pmu_conf->pmu_info))->platform_info;
-+
-+	if (cnum < NR_CTRS)
-+		info->write_ctr(cpu, cnum, value);
-+}
-+
-+/**
-+ * pfm_cell_read_pmd
-+ **/
-+static u64 pfm_cell_read_pmd(unsigned int cnum)
-+{
-+	int cpu = smp_processor_id();
-+	struct pfm_cell_platform_pmu_info *info =
-+		((struct pfm_arch_pmu_info *)
-+		 (pfm_pmu_conf->pmu_info))->platform_info;
-+
-+	if (cnum < NR_CTRS)
-+		return info->read_ctr(cpu, cnum);
-+
-+	return -EINVAL;
-+}
-+
-+/**
-+ * pfm_cell_enable_counters
-+ *
-+ * Just need to turn on the global disable bit in pm_control.
-+ **/
-+static void pfm_cell_enable_counters(struct pfm_context *ctx,
-+				     struct pfm_event_set *set)
-+{
-+	struct pfm_cell_platform_pmu_info *info =
-+		((struct pfm_arch_pmu_info *)
-+		 (pfm_pmu_conf->pmu_info))->platform_info;
-+
-+	info->enable_pm(smp_processor_id());
-+}
-+
-+/**
-+ * pfm_cell_disable_counters
-+ *
-+ * Just need to turn off the global disable bit in pm_control.
-+ **/
-+static void pfm_cell_disable_counters(struct pfm_context *ctx,
-+				      struct pfm_event_set *set)
-+{
-+	struct pfm_cell_platform_pmu_info *info =
-+		((struct pfm_arch_pmu_info *)
-+		 (pfm_pmu_conf->pmu_info))->platform_info;
-+
-+	info->disable_pm(smp_processor_id());
-+	if (machine_is(ps3))
-+		reset_signals(smp_processor_id());
-+}
-+
-+/*
-+ * Return the thread id of the specified ppu signal.
-+ */
-+static inline u32 get_target_ppu_thread_id(u32 group, u32 bit)
-+{
-+	if ((group == SIG_GROUP_PPU_IU1 &&
-+	     bit < PFM_PPU_IU1_THREAD1_BASE_BIT) ||
-+	    (group == SIG_GROUP_PPU_XU &&
-+	     bit < PFM_PPU_XU_THREAD1_BASE_BIT))
-+		return 0;
-+	else
-+		return 1;
-+}
-+
-+/*
-+ * Return whether the specified counter is for PPU signal group.
-+ */
-+static inline int is_counter_for_ppu_sig_grp(u32 counter_control, u32 sig_grp)
-+{
-+	if (!(counter_control & CBE_PM_CTR_INPUT_CONTROL) &&
-+	    (counter_control & CBE_PM_CTR_ENABLE) &&
-+	    ((sig_grp == SIG_GROUP_PPU_IU1) || (sig_grp == SIG_GROUP_PPU_XU)))
-+		return 1;
-+	else
-+		return 0;
-+}
-+
-+/*
-+ * Search ppu signal groups.
-+ */
-+static int get_ppu_signal_groups(struct pfm_event_set *set,
-+				 u32 *ppu_sig_grp0, u32 *ppu_sig_grp1)
-+{
-+	u64 pm_event, *used_pmcs = set->used_pmcs;
-+	int i, j;
-+	u32 grp0_wd, grp1_wd, wd, sig_grp;
-+
-+	*ppu_sig_grp0 = 0;
-+	*ppu_sig_grp1 = 0;
-+	grp0_wd = PFM_GROUP_CONTROL_GROUP0_WORD(
-+		set->pmcs[CELL_PMC_GROUP_CONTROL]);
-+	grp1_wd = PFM_GROUP_CONTROL_GROUP1_WORD(
-+		set->pmcs[CELL_PMC_GROUP_CONTROL]);
-+
-+	for (i = 0, j = 0; (i < NR_CTRS) && (j < PFM_NUM_OF_GROUPS); i++) {
-+		if (test_bit(i + NR_CTRS, used_pmcs)) {
-+			pm_event = set->pmcs[i + NR_CTRS];
-+			wd = PFM_EVENT_PMC_BUS_WORD(pm_event);
-+			sig_grp = PFM_EVENT_PMC_SIGNAL_GROUP(pm_event);
-+			if ((sig_grp == SIG_GROUP_PPU_IU1) ||
-+			    (sig_grp == SIG_GROUP_PPU_XU)) {
-+
-+				if (wd == grp0_wd && *ppu_sig_grp0 == 0) {
-+					*ppu_sig_grp0 = sig_grp;
-+					j++;
-+				} else if (wd == grp1_wd &&
-+					   *ppu_sig_grp1 == 0) {
-+					*ppu_sig_grp1 = sig_grp;
-+					j++;
-+				}
-+			}
-+		}
-+	}
-+	return j;
-+}
-+
-+/**
-+ * pfm_cell_restore_pmcs
-+ *
-+ * Write all control register values that are saved in the specified event
-+ * set. We could use the pfm_arch_write_pmc() function to restore each PMC
-+ * individually (as is done in other architectures), but that results in
-+ * multiple RTAS calls. As an optimization, we will setup the RTAS argument
-+ * array so we can do all event-control registers in one RTAS call.
-+ *
-+ * In per-thread mode,
-+ * The counter enable bit of the pmX_control PMC is enabled while the target
-+ * task runs on the target HW thread.
-+ **/
-+void pfm_cell_restore_pmcs(struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	u64 ctr_ctrl;
-+	u64 *used_pmcs = set->used_pmcs;
-+	int i;
-+	int cpu = smp_processor_id();
-+	u32 current_th_id;
-+	struct pfm_cell_platform_pmu_info *info =
-+		((struct pfm_arch_pmu_info *)
-+		 (pfm_pmu_conf->pmu_info))->platform_info;
-+
-+	for (i = 0; i < NR_CTRS; i++) {
-+		ctr_ctrl = set->pmcs[i];
-+
-+		if (ctr_ctrl & PFM_COUNTER_CTRL_PMC_PPU_TH0) {
-+			current_th_id = info->get_hw_thread_id(cpu);
-+
-+			/*
-+			 * Set the counter enable bit down if the current
-+			 * HW thread is NOT 0
-+			 **/
-+			if (current_th_id)
-+				ctr_ctrl = ctr_ctrl & ~CBE_PM_CTR_ENABLE;
-+
-+		} else if (ctr_ctrl & PFM_COUNTER_CTRL_PMC_PPU_TH1) {
-+			current_th_id = info->get_hw_thread_id(cpu);
-+
-+			/*
-+			 * Set the counter enable bit down if the current
-+			 * HW thread is 0
-+			 **/
-+			if (!current_th_id)
-+				ctr_ctrl = ctr_ctrl & ~CBE_PM_CTR_ENABLE;
-+		}
-+
-+		/* Write the per-counter control register. If the PMC is not
-+		 * in use, then it will simply clear the register, which will
-+		 * disable the associated counter.
-+		 */
-+		info->write_pm07_control(cpu, i, ctr_ctrl);
-+
-+		if (test_bit(i + NR_CTRS, used_pmcs))
-+			write_pm07_event(cpu, 0, set->pmcs[i + NR_CTRS]);
-+	}
-+
-+	/* Write all the global PMCs. Need to call pfm_cell_write_pmc()
-+	 * instead of cbe_write_pm() due to special handling for the
-+	 * pm_status register.
-+	 */
-+	for (i *= 2; i < PFM_PM_NUM_PMCS; i++)
-+		pfm_cell_write_pmc(i, set->pmcs[i]);
-+}
-+
-+/**
-+ * pfm_cell_restore_pmds
-+ *
-+ * Write to pm_control register before writing to counter registers
-+ * so that we can decide the counter width berfore writing to the couters.
-+ **/
-+void pfm_cell_restore_pmds(struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	u64 *used_pmds;
-+	unsigned int i, max_pmd;
-+	int cpu = smp_processor_id();
-+	struct pfm_cell_platform_pmu_info *info =
-+		((struct pfm_arch_pmu_info *)
-+		 (pfm_pmu_conf->pmu_info))->platform_info;
-+
-+	/*
-+	 * Write pm_control register value
-+	 */
-+	info->write_pm(cpu, pm_control,
-+		       set->pmcs[CELL_PMC_PM_CONTROL] &
-+		       ~CBE_PM_ENABLE_PERF_MON);
-+	PFM_DBG("restore pm_control(0x%lx) before restoring pmds",
-+		set->pmcs[CELL_PMC_PM_CONTROL]);
-+
-+	max_pmd = ctx->regs.max_pmd;
-+	used_pmds = set->used_pmds;
-+
-+	for (i = 0; i < max_pmd; i++)
-+		if (test_bit(i, used_pmds) &&
-+		    !(pfm_pmu_conf->pmd_desc[i].type & PFM_REG_RO))
-+			pfm_cell_write_pmd(i, set->pmds[i].value);
-+}
-+
-+/**
-+ * pfm_cell_get_cntr_width
-+ *
-+ * This function check the 16bit counter field in pm_control pmc.
-+ *
-+ * Return value
-+ *  16 : all counters are 16bit width.
-+ *  32 : all counters are 32bit width.
-+ *  0  : several counter width exists.
-+ **/
-+static int pfm_cell_get_cntr_width(struct pfm_context *ctx,
-+				   struct pfm_event_set *s)
-+{
-+	int width = 0;
-+	int tmp = 0;
-+	u64 cntr_field;
-+
-+	if (ctx->flags.switch_ovfl || ctx->flags.switch_time) {
-+		list_for_each_entry(s, &ctx->set_list, list) {
-+			cntr_field = s->pmcs[CELL_PMC_PM_CONTROL] &
-+				CELL_PMC_PM_CONTROL_CNTR_MASK;
-+
-+			if (cntr_field == CELL_PMC_PM_CONTROL_CNTR_16)
-+				tmp = 16;
-+			else if (cntr_field == 0x0)
-+				tmp = 32;
-+			else
-+				return 0;
-+
-+			if (tmp != width && width != 0)
-+				return 0;
-+
-+			width = tmp;
-+		}
-+	} else {
-+		cntr_field = s->pmcs[CELL_PMC_PM_CONTROL] &
-+			CELL_PMC_PM_CONTROL_CNTR_MASK;
-+
-+		if (cntr_field == CELL_PMC_PM_CONTROL_CNTR_16)
-+			width = 16;
-+		else if (cntr_field == 0x0)
-+			width = 32;
-+		else
-+			width = 0;
-+	}
-+	return width;
-+}
-+
-+/**
-+ * pfm_cell_check_cntr_ovfl_mask
-+ *
-+ * Return value
-+ *  1  : cntr_ovfl interrupt is used.
-+ *  0  : cntr_ovfl interrupt is not used.
-+ **/
-+static int pfm_cell_check_cntr_ovfl(struct pfm_context *ctx,
-+				    struct pfm_event_set *s)
-+{
-+	if (ctx->flags.switch_ovfl || ctx->flags.switch_time) {
-+		list_for_each_entry(s, &ctx->set_list, list) {
-+			if (CBE_PM_OVERFLOW_CTRS(s->pmcs[CELL_PMC_PM_STATUS]))
-+				return 1;
-+		}
-+	} else {
-+		if (CBE_PM_OVERFLOW_CTRS(s->pmcs[CELL_PMC_PM_STATUS]))
-+			return 1;
-+	}
-+	return 0;
-+}
-+
-+#ifdef CONFIG_PPC_PS3
-+/**
-+ * update_sub_unit_field
-+ *
-+ **/
-+static inline u64 update_sub_unit_field(u64 pm_event, u64 spe_id)
-+{
-+	return ((pm_event & 0xFFFF0000FFFFFFFF) | (spe_id << 32));
-+}
-+
-+/**
-+ * pfm_get_spe_id
-+ *
-+ **/
-+static u64 pfm_get_spe_id(void *arg)
-+{
-+	struct spu *spu = arg;
-+	u64 spe_id;
-+
-+	if (machine_is(ps3))
-+		spe_id = ps3_get_spe_id(arg);
-+	else
-+		spe_id = spu->spe_id;
-+
-+	return spe_id;
-+}
-+
-+/**
-+ * pfm_spu_number_to_id
-+ *
-+ **/
-+static int pfm_spu_number_to_id(int number, u64 *spe_id)
-+{
-+	struct spu *spu;
-+	int i;
-+
-+	for (i = 0; i < MAX_NUMNODES; i++) {
-+		if (cbe_spu_info[i].n_spus == 0)
-+			continue;
-+
-+		list_for_each_entry(spu, &cbe_spu_info[i].spus, cbe_list)
-+			if (spu->number == number) {
-+				*spe_id = pfm_get_spe_id(spu);
-+				return 0;
-+			}
-+	}
-+	return -ENODEV;
-+}
-+
-+/**
-+ * pfm_update_pmX_event_subunit_field
-+ *
-+ * In system wide mode,
-+ * This function updates the subunit field of SPE pmX_event.
-+ **/
-+static int pfm_update_pmX_event_subunit_field(struct pfm_context *ctx)
-+{
-+	struct pfm_event_set *set;
-+	int i, last_pmc, ret;
-+	u64 signal_group, spe_id;
-+	int sub_unit;
-+	u64 *used_pmcs;
-+
-+	last_pmc = NR_CTRS + 8;
-+	ret = 0;
-+	list_for_each_entry(set, &ctx->set_list, list) {
-+
-+		used_pmcs = set->used_pmcs;
-+		for (i = NR_CTRS; i < last_pmc; i++) {
-+			if (!test_bit(i, used_pmcs))
-+				continue;
-+
-+			signal_group = PFM_EVENT_PMC_SIGNAL_GROUP(set->pmcs[i]);
-+
-+			/*
-+			 * If the target event is a SPE signal group event,
-+			 * The sub_unit field in pmX_event pmc is changed to the
-+			 * specified spe_id.
-+			 */
-+			if (SIG_GROUP_SPU_BASE < signal_group &&
-+			    signal_group < SIG_GROUP_EIB_BASE) {
-+				sub_unit = RTAS_SUB_UNIT(set->pmcs[i]);
-+
-+				ret = pfm_spu_number_to_id(sub_unit, &spe_id);
-+				if (ret)
-+					return ret;
-+
-+				set->pmcs[i] = update_sub_unit_field(
-+					set->pmcs[i], spe_id);
-+			}
-+		}
-+	}
-+	return 0;
-+}
-+#endif
-+
-+/**
-+ * pfm_cell_load_context
-+ *
-+ * In per-thread mode,
-+ *  The pmX_control PMCs which are used for PPU IU/XU event are marked with
-+ *  the thread id(PFM_COUNTER_CTRL_PMC_PPU_TH0/TH1).
-+ **/
-+static int pfm_cell_load_context(struct pfm_context *ctx)
-+{
-+	int i;
-+	u32 ppu_sig_grp[PFM_NUM_OF_GROUPS] = {SIG_GROUP_NONE, SIG_GROUP_NONE};
-+	u32 bit;
-+	int index;
-+	u32 target_th_id;
-+	int ppu_sig_num = 0;
-+	struct pfm_event_set *s;
-+	int cntr_width = 32;
-+	int ret = 0;
-+
-+	if (pfm_cell_check_cntr_ovfl(ctx, ctx->active_set)) {
-+		cntr_width = pfm_cell_get_cntr_width(ctx, ctx->active_set);
-+
-+		/*
-+		 * Counter overflow interrupt works with only 32bit counter,
-+		 * because perfmon core uses pfm_cell_pmu_conf.counter_width
-+		 * to deal with the counter overflow. we can't change the
-+		 * counter width here.
-+		 */
-+		if (cntr_width != 32)
-+			return -EINVAL;
-+	}
-+
-+	if (ctx->flags.system) {
-+#ifdef CONFIG_PPC_PS3
-+		if (machine_is(ps3))
-+			ret = pfm_update_pmX_event_subunit_field(ctx);
-+#endif
-+		return ret;
-+	}
-+
-+	list_for_each_entry(s, &ctx->set_list, list) {
-+		ppu_sig_num = get_ppu_signal_groups(s, &ppu_sig_grp[0],
-+						    &ppu_sig_grp[1]);
-+
-+		for (i = 0; i < NR_CTRS; i++) {
-+			index = PFM_PM_CTR_INPUT_MUX_GROUP_INDEX(s->pmcs[i]);
-+			if (ppu_sig_num &&
-+			    (ppu_sig_grp[index] != SIG_GROUP_NONE) &&
-+			    is_counter_for_ppu_sig_grp(s->pmcs[i],
-+						       ppu_sig_grp[index])) {
-+
-+				bit = PFM_PM_CTR_INPUT_MUX_BIT(s->pmcs[i]);
-+				target_th_id = get_target_ppu_thread_id(
-+					ppu_sig_grp[index], bit);
-+				if (!target_th_id)
-+					s->pmcs[i] |=
-+						PFM_COUNTER_CTRL_PMC_PPU_TH0;
-+				else
-+					s->pmcs[i] |=
-+						PFM_COUNTER_CTRL_PMC_PPU_TH1;
-+				PFM_DBG("set:%d mark ctr:%d target_thread:%d",
-+					s->id, i, target_th_id);
-+			}
-+		}
-+	}
-+
-+	return ret;
-+}
-+
-+/**
-+ * pfm_cell_unload_context
-+ *
-+ * For system-wide contexts and self-monitored contexts, make the RTAS call
-+ * to reset the debug-bus signals.
-+ *
-+ * For non-self-monitored contexts, the monitored thread will already have
-+ * been taken off the CPU and we don't need to do anything additional.
-+ **/
-+static void pfm_cell_unload_context(struct pfm_context *ctx)
-+{
-+	if (ctx->task == current || ctx->flags.system)
-+		reset_signals(smp_processor_id());
-+}
-+
-+/**
-+ * pfm_cell_ctxswout_thread
-+ *
-+ * When a monitored thread is switched out (self-monitored or externally
-+ * monitored) we need to reset the debug-bus signals so the next context that
-+ * gets switched in can start from a clean set of signals.
-+ **/
-+int pfm_cell_ctxswout_thread(struct task_struct *task,
-+			     struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	reset_signals(smp_processor_id());
-+	return 0;
-+}
-+
-+/**
-+ * pfm_cell_get_ovfl_pmds
-+ *
-+ * Determine which counters in this set have overflowed and fill in the
-+ * set->povfl_pmds mask and set->npend_ovfls count. On Cell, the pm_status
-+ * register contains a bit for each counter to indicate overflow. However,
-+ * those 8 bits are in the reverse order than what Perfmon2 is expecting,
-+ * so we need to reverse the order of the overflow bits.
-+ **/
-+static void pfm_cell_get_ovfl_pmds(struct pfm_context *ctx,
-+				   struct pfm_event_set *set)
-+{
-+	struct pfm_arch_context *ctx_arch = pfm_ctx_arch(ctx);
-+	u32 pm_status, ovfl_ctrs;
-+	u64 povfl_pmds = 0;
-+	int i;
-+	struct pfm_cell_platform_pmu_info *info =
-+		((struct pfm_arch_pmu_info *)
-+		 (pfm_pmu_conf->pmu_info))->platform_info;
-+
-+	if (!ctx_arch->last_read_updated)
-+		/* This routine was not called via the interrupt handler.
-+		 * Need to start by getting interrupts and updating
-+		 * last_read_pm_status.
-+		 */
-+		ctx_arch->last_read_pm_status =
-+ info->get_and_clear_pm_interrupts(smp_processor_id());
-+
-+	/* Reset the flag that the interrupt handler last read pm_status. */
-+	ctx_arch->last_read_updated = 0;
-+
-+	pm_status = ctx_arch->last_read_pm_status &
-+		    set->pmcs[CELL_PMC_PM_STATUS];
-+	ovfl_ctrs = CBE_PM_OVERFLOW_CTRS(pm_status);
-+
-+	/* Reverse the order of the bits in ovfl_ctrs
-+	 * and store the result in povfl_pmds.
-+	 */
-+	for (i = 0; i < PFM_PM_NUM_PMDS; i++) {
-+		povfl_pmds = (povfl_pmds << 1) | (ovfl_ctrs & 1);
-+		ovfl_ctrs >>= 1;
-+	}
-+
-+	/* Mask povfl_pmds with set->used_pmds to get set->povfl_pmds.
-+	 * Count the bits set in set->povfl_pmds to get set->npend_ovfls.
-+	 */
-+	bitmap_and(set->povfl_pmds, &povfl_pmds,
-+		   set->used_pmds, PFM_PM_NUM_PMDS);
-+	set->npend_ovfls = bitmap_weight(set->povfl_pmds, PFM_PM_NUM_PMDS);
-+}
-+
-+/**
-+ * pfm_cell_acquire_pmu
-+ *
-+ * acquire PMU resource.
-+ * This acquisition is done when the first context is created.
-+ **/
-+int pfm_cell_acquire_pmu(u64 *unavail_pmcs, u64 *unavail_pmds)
-+{
-+#ifdef CONFIG_PPC_PS3
-+	int ret;
-+
-+	if (machine_is(ps3)) {
-+		PFM_DBG("");
-+		ret = ps3_lpm_open(PS3_LPM_TB_TYPE_INTERNAL, NULL, 0);
-+		if (ret) {
-+			PFM_ERR("Can't create PS3 lpm. error:%d", ret);
-+			return -EFAULT;
-+		}
-+	}
-+#endif
-+	return 0;
-+}
-+
-+/**
-+ * pfm_cell_release_pmu
-+ *
-+ * release PMU resource.
-+ * actual release happens when last context is destroyed
-+ **/
-+void pfm_cell_release_pmu(void)
-+{
-+#ifdef CONFIG_PPC_PS3
-+	if (machine_is(ps3)) {
-+		if (ps3_lpm_close())
-+			PFM_ERR("Can't delete PS3 lpm.");
-+	}
-+#endif
-+}
-+
-+/**
-+ * handle_trace_buffer_interrupts
-+ *
-+ * This routine is for processing just the interval timer and trace buffer
-+ * overflow interrupts. Performance counter interrupts are handled by the
-+ * perf_irq_handler() routine, which reads and saves the pm_status register.
-+ * This routine should not read the actual pm_status register, but rather
-+ * the value passed in.
-+ **/
-+static void handle_trace_buffer_interrupts(unsigned long iip,
-+					   struct pt_regs *regs,
-+					   struct pfm_context *ctx,
-+					   u32 pm_status)
-+{
-+	/* FIX: Currently ignoring trace-buffer interrupts. */
-+	return;
-+}
-+
-+/**
-+ * pfm_cell_irq_handler
-+ *
-+ * Handler for all Cell performance-monitor interrupts.
-+ **/
-+static void pfm_cell_irq_handler(struct pt_regs *regs, struct pfm_context *ctx)
-+{
-+	struct pfm_arch_context *ctx_arch = pfm_ctx_arch(ctx);
-+	u32 last_read_pm_status;
-+	int cpu = smp_processor_id();
-+	struct pfm_cell_platform_pmu_info *info =
-+		((struct pfm_arch_pmu_info *)
-+		 (pfm_pmu_conf->pmu_info))->platform_info;
-+
-+	/* Need to disable and reenable the performance counters to get the
-+	 * desired behavior from the hardware. This is specific to the Cell
-+	 * PMU hardware.
-+	 */
-+	info->disable_pm(cpu);
-+
-+	/* Read the pm_status register to get the interrupt bits. If a
-+	 * perfmormance counter overflow interrupt occurred, call the core
-+	 * perfmon interrupt handler to service the counter overflow. If the
-+	 * interrupt was for the interval timer or the trace_buffer,
-+	 * call the interval timer and trace buffer interrupt handler.
-+	 *
-+	 * The value read from the pm_status register is stored in the
-+	 * pmf_arch_context structure for use by other routines. Note that
-+	 * reading the pm_status register resets the interrupt flags to zero.
-+	 * Hence, it is important that the register is only read in one place.
-+	 *
-+	 * The pm_status reg interrupt reg format is:
-+	 * [pmd0:pmd1:pmd2:pmd3:pmd4:pmd5:pmd6:pmd7:intt:tbf:tbu:]
-+	 * - pmd0 to pm7 are the perf counter overflow interrupts.
-+	 * - intt is the interval timer overflowed interrupt.
-+	 * - tbf is the trace buffer full interrupt.
-+	 * - tbu is the trace buffer underflow interrupt.
-+	 * - The pmd0 bit is the MSB of the 32 bit register.
-+	 */
-+	ctx_arch->last_read_pm_status = last_read_pm_status =
-+			info->get_and_clear_pm_interrupts(cpu);
-+
-+	/* Set flag for pfm_cell_get_ovfl_pmds() routine so it knows
-+	 * last_read_pm_status was updated by the interrupt handler.
-+	 */
-+	ctx_arch->last_read_updated = 1;
-+
-+	if (last_read_pm_status & CBE_PM_ALL_OVERFLOW_INTR)
-+		/* At least one counter overflowed. */
-+		pfm_interrupt_handler(instruction_pointer(regs), regs);
-+
-+	if (last_read_pm_status & (CBE_PM_INTERVAL_INTR |
-+				   CBE_PM_TRACE_BUFFER_FULL_INTR |
-+				   CBE_PM_TRACE_BUFFER_UNDERFLOW_INTR))
-+		/* Trace buffer or interval timer overflow. */
-+		handle_trace_buffer_interrupts(instruction_pointer(regs),
-+					       regs, ctx, last_read_pm_status);
-+
-+	/* The interrupt settings is the value written to the pm_status
-+	 * register. It is saved in the context when the register is
-+	 * written.
-+	 */
-+	info->enable_pm_interrupts(cpu, info->get_hw_thread_id(cpu),
-+	ctx->active_set->pmcs[CELL_PMC_PM_STATUS]);
-+
-+	/* The writes to the various performance counters only writes to a
-+	 * latch. The new values (interrupt setting bits, reset counter value
-+	 * etc.) are not copied to the actual registers until the performance
-+	 * monitor is enabled. In order to get this to work as desired, the
-+	 * permormance monitor needs to be disabled while writting to the
-+	 * latches. This is a HW design issue.
-+	 */
-+	info->enable_pm(cpu);
-+}
-+
-+
-+static struct pfm_cell_platform_pmu_info ps3_platform_pmu_info = {
-+#ifdef CONFIG_PPC_PS3
-+	.read_ctr                    = ps3_read_ctr,
-+	.write_ctr                   = ps3_write_ctr,
-+	.write_pm07_control          = ps3_write_pm07_control,
-+	.write_pm                    = ps3_write_pm,
-+	.enable_pm                   = ps3_enable_pm,
-+	.disable_pm                  = ps3_disable_pm,
-+	.enable_pm_interrupts        = ps3_enable_pm_interrupts,
-+	.get_and_clear_pm_interrupts = ps3_get_and_clear_pm_interrupts,
-+	.get_hw_thread_id            = ps3_get_hw_thread_id,
-+	.get_cpu_ppe_priv_regs       = NULL,
-+	.get_cpu_pmd_regs            = NULL,
-+	.get_cpu_mic_tm_regs         = NULL,
-+	.rtas_token                  = NULL,
-+	.rtas_call                   = NULL,
-+#endif
-+};
-+
-+static struct pfm_cell_platform_pmu_info native_platform_pmu_info = {
-+#ifdef CONFIG_PPC_CELL_NATIVE
-+	.read_ctr                    = cbe_read_ctr,
-+	.write_ctr                   = cbe_write_ctr,
-+	.write_pm07_control          = cbe_write_pm07_control,
-+	.write_pm                    = cbe_write_pm,
-+	.enable_pm                   = cbe_enable_pm,
-+	.disable_pm                  = cbe_disable_pm,
-+	.enable_pm_interrupts        = cbe_enable_pm_interrupts,
-+	.get_and_clear_pm_interrupts = cbe_get_and_clear_pm_interrupts,
-+	.get_hw_thread_id            = cbe_get_hw_thread_id,
-+	.get_cpu_ppe_priv_regs       = cbe_get_cpu_ppe_priv_regs,
-+	.get_cpu_pmd_regs            = cbe_get_cpu_pmd_regs,
-+	.get_cpu_mic_tm_regs         = cbe_get_cpu_mic_tm_regs,
-+	.rtas_token                  = rtas_token,
-+	.rtas_call                   = rtas_call,
-+#endif
-+};
-+
-+static struct pfm_arch_pmu_info pfm_cell_pmu_info = {
-+	.pmu_style        = PFM_POWERPC_PMU_CELL,
-+	.acquire_pmu      = pfm_cell_acquire_pmu,
-+	.release_pmu      = pfm_cell_release_pmu,
-+	.write_pmc        = pfm_cell_write_pmc,
-+	.write_pmd        = pfm_cell_write_pmd,
-+	.read_pmd         = pfm_cell_read_pmd,
-+	.enable_counters  = pfm_cell_enable_counters,
-+	.disable_counters = pfm_cell_disable_counters,
-+	.irq_handler      = pfm_cell_irq_handler,
-+	.get_ovfl_pmds    = pfm_cell_get_ovfl_pmds,
-+	.restore_pmcs     = pfm_cell_restore_pmcs,
-+	.restore_pmds     = pfm_cell_restore_pmds,
-+	.ctxswout_thread  = pfm_cell_ctxswout_thread,
-+	.load_context     = pfm_cell_load_context,
-+	.unload_context   = pfm_cell_unload_context,
-+};
-+
-+static struct pfm_pmu_config pfm_cell_pmu_conf = {
-+	.pmu_name = "Cell",
-+	.version = "0.1",
-+	.counter_width = 32,
-+	.pmd_desc = pfm_cell_pmd_desc,
-+	.pmc_desc = pfm_cell_pmc_desc,
-+	.num_pmc_entries = PFM_PM_NUM_PMCS,
-+	.num_pmd_entries = PFM_PM_NUM_PMDS,
-+	.probe_pmu  = pfm_cell_probe_pmu,
-+	.pmu_info = &pfm_cell_pmu_info,
-+	.flags = PFM_PMU_BUILTIN_FLAG,
-+	.owner = THIS_MODULE,
-+};
-+
-+/**
-+ * pfm_cell_platform_probe
-+ *
-+ * If we're on a system without the firmware rtas call available, set up the
-+ * PMC write-checker for all the pmX_event control registers.
-+ **/
-+static void pfm_cell_platform_probe(void)
-+{
-+	if (machine_is(celleb)) {
-+		int cnum;
-+		pfm_cell_pmu_conf.pmc_write_check = pfm_cell_pmc_check;
-+		for (cnum = NR_CTRS; cnum < (NR_CTRS * 2); cnum++)
-+			pfm_cell_pmc_desc[cnum].type |= PFM_REG_WC;
-+	}
-+
-+	if (machine_is(ps3))
-+		pfm_cell_pmu_info.platform_info = &ps3_platform_pmu_info;
-+	else
-+		pfm_cell_pmu_info.platform_info = &native_platform_pmu_info;
-+}
-+
-+static int __init pfm_cell_pmu_init_module(void)
-+{
-+	pfm_cell_platform_probe();
-+	return pfm_pmu_register(&pfm_cell_pmu_conf);
-+}
-+
-+static void __exit pfm_cell_pmu_cleanup_module(void)
-+{
-+	pfm_pmu_unregister(&pfm_cell_pmu_conf);
-+}
-+
-+module_init(pfm_cell_pmu_init_module);
-+module_exit(pfm_cell_pmu_cleanup_module);
-diff --git a/arch/powerpc/perfmon/perfmon_power4.c b/arch/powerpc/perfmon/perfmon_power4.c
-new file mode 100644
-index 0000000..eba9e8c
---- /dev/null
-+++ b/arch/powerpc/perfmon/perfmon_power4.c
-@@ -0,0 +1,309 @@
-+/*
-+ * This file contains the POWER4 PMU register description tables
-+ * and pmc checker used by perfmon.c.
-+ *
-+ * Copyright (c) 2007, IBM Corporation.
-+ *
-+ * Based on a simple modification of perfmon_power5.c for POWER4 by
-+ * Corey Ashford <cjashfor@us.ibm.com>.
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/module.h>
-+#include <linux/perfmon_kern.h>
-+
-+MODULE_AUTHOR("Corey Ashford <cjashfor@us.ibm.com>");
-+MODULE_DESCRIPTION("POWER4 PMU description table");
-+MODULE_LICENSE("GPL");
-+
-+static struct pfm_regmap_desc pfm_power4_pmc_desc[] = {
-+/* mmcr0 */ PMC_D(PFM_REG_I, "MMCR0", MMCR0_FC, 0, 0, SPRN_MMCR0),
-+/* mmcr1 */ PMC_D(PFM_REG_I, "MMCR1", 0, 0, 0, SPRN_MMCR1),
-+/* mmcra */ PMC_D(PFM_REG_I, "MMCRA", 0, 0, 0, SPRN_MMCRA)
-+};
-+#define PFM_PM_NUM_PMCS	ARRAY_SIZE(pfm_power4_pmc_desc)
-+
-+/* The TB and PURR registers are read-only. Also, note that the TB register
-+ * actually consists of both the 32-bit SPRN_TBRU and SPRN_TBRL registers.
-+ * For Perfmon2's purposes, we'll treat it as a single 64-bit register.
-+ */
-+static struct pfm_regmap_desc pfm_power4_pmd_desc[] = {
-+/* tb    */ PMD_D((PFM_REG_I|PFM_REG_RO), "TB", SPRN_TBRL),
-+/* pmd1  */ PMD_D(PFM_REG_C, "PMC1", SPRN_PMC1),
-+/* pmd2  */ PMD_D(PFM_REG_C, "PMC2", SPRN_PMC2),
-+/* pmd3  */ PMD_D(PFM_REG_C, "PMC3", SPRN_PMC3),
-+/* pmd4  */ PMD_D(PFM_REG_C, "PMC4", SPRN_PMC4),
-+/* pmd5  */ PMD_D(PFM_REG_C, "PMC5", SPRN_PMC5),
-+/* pmd6  */ PMD_D(PFM_REG_C, "PMC6", SPRN_PMC6),
-+/* pmd7  */ PMD_D(PFM_REG_C, "PMC7", SPRN_PMC7),
-+/* pmd8  */ PMD_D(PFM_REG_C, "PMC8", SPRN_PMC8)
-+};
-+#define PFM_PM_NUM_PMDS	ARRAY_SIZE(pfm_power4_pmd_desc)
-+
-+static int pfm_power4_probe_pmu(void)
-+{
-+	unsigned long pvr = mfspr(SPRN_PVR);
-+	int ver = PVR_VER(pvr);
-+
-+	if ((ver == PV_POWER4) || (ver == PV_POWER4p))
-+		return 0;
-+
-+	return -1;
-+}
-+
-+static void pfm_power4_write_pmc(unsigned int cnum, u64 value)
-+{
-+	switch (pfm_pmu_conf->pmc_desc[cnum].hw_addr) {
-+	case SPRN_MMCR0:
-+		mtspr(SPRN_MMCR0, value);
-+		break;
-+	case SPRN_MMCR1:
-+		mtspr(SPRN_MMCR1, value);
-+		break;
-+	case SPRN_MMCRA:
-+		mtspr(SPRN_MMCRA, value);
-+		break;
-+	default:
-+		BUG();
-+	}
-+}
-+
-+static void pfm_power4_write_pmd(unsigned int cnum, u64 value)
-+{
-+	u64 ovfl_mask = pfm_pmu_conf->ovfl_mask;
-+
-+	switch (pfm_pmu_conf->pmd_desc[cnum].hw_addr) {
-+	case SPRN_PMC1:
-+		mtspr(SPRN_PMC1, value & ovfl_mask);
-+		break;
-+	case SPRN_PMC2:
-+		mtspr(SPRN_PMC2, value & ovfl_mask);
-+		break;
-+	case SPRN_PMC3:
-+		mtspr(SPRN_PMC3, value & ovfl_mask);
-+		break;
-+	case SPRN_PMC4:
-+		mtspr(SPRN_PMC4, value & ovfl_mask);
-+		break;
-+	case SPRN_PMC5:
-+		mtspr(SPRN_PMC5, value & ovfl_mask);
-+		break;
-+	case SPRN_PMC6:
-+		mtspr(SPRN_PMC6, value & ovfl_mask);
-+		break;
-+	case SPRN_PMC7:
-+		mtspr(SPRN_PMC7, value & ovfl_mask);
-+		break;
-+	case SPRN_PMC8:
-+		mtspr(SPRN_PMC8, value & ovfl_mask);
-+		break;
-+	case SPRN_TBRL:
-+	case SPRN_PURR:
-+		/* Ignore writes to read-only registers. */
-+		break;
-+	default:
-+		BUG();
-+	}
-+}
-+
-+static u64 pfm_power4_read_pmd(unsigned int cnum)
-+{
-+	switch (pfm_pmu_conf->pmd_desc[cnum].hw_addr) {
-+	case SPRN_PMC1:
-+		return mfspr(SPRN_PMC1);
-+	case SPRN_PMC2:
-+		return mfspr(SPRN_PMC2);
-+	case SPRN_PMC3:
-+		return mfspr(SPRN_PMC3);
-+	case SPRN_PMC4:
-+		return mfspr(SPRN_PMC4);
-+	case SPRN_PMC5:
-+		return mfspr(SPRN_PMC5);
-+	case SPRN_PMC6:
-+		return mfspr(SPRN_PMC6);
-+	case SPRN_PMC7:
-+		return mfspr(SPRN_PMC7);
-+	case SPRN_PMC8:
-+		return mfspr(SPRN_PMC8);
-+	case SPRN_TBRL:
-+		return ((u64)mfspr(SPRN_TBRU) << 32) | mfspr(SPRN_TBRL);
-+	case SPRN_PURR:
-+		if (cpu_has_feature(CPU_FTR_PURR))
-+			return mfspr(SPRN_PURR);
-+		else
-+			return 0;
-+	default:
-+		BUG();
-+	}
-+}
-+
-+/* forward decl */
-+static void pfm_power4_disable_counters(struct pfm_context *ctx,
-+					struct pfm_event_set *set);
-+
-+/**
-+ * pfm_power4_enable_counters
-+ *
-+ **/
-+static void pfm_power4_enable_counters(struct pfm_context *ctx,
-+				       struct pfm_event_set *set)
-+{
-+	unsigned int i, max_pmc;
-+
-+	/* Make sure the counters are disabled before touching the other
-+	   control registers */
-+	pfm_power4_disable_counters(ctx, set);
-+
-+	max_pmc = ctx->regs.max_pmc;
-+
-+	/* Write MMCR0 last, and a fairly easy way to do this is to write
-+	   the registers in the reverse order */
-+	for (i = max_pmc; i != 0; i--)
-+		if (test_bit(i - 1, set->used_pmcs))
-+			pfm_power4_write_pmc(i - 1, set->pmcs[i - 1]);
-+}
-+
-+/**
-+ * pfm_power4_disable_counters
-+ *
-+ **/
-+static void pfm_power4_disable_counters(struct pfm_context *ctx,
-+					struct pfm_event_set *set)
-+{
-+	/* Set the Freeze Counters bit */
-+	mtspr(SPRN_MMCR0, mfspr(SPRN_MMCR0) | MMCR0_FC);
-+	asm volatile ("sync");
-+}
-+
-+/**
-+ * pfm_power4_get_ovfl_pmds
-+ *
-+ * Determine which counters in this set have overflowed and fill in the
-+ * set->povfl_pmds mask and set->npend_ovfls count.
-+ **/
-+static void pfm_power4_get_ovfl_pmds(struct pfm_context *ctx,
-+				     struct pfm_event_set *set)
-+{
-+	unsigned int i;
-+	unsigned int max_pmd = ctx->regs.max_intr_pmd;
-+	u64 *used_pmds = set->used_pmds;
-+	u64 *cntr_pmds = ctx->regs.cnt_pmds;
-+	u64 width_mask = 1 << pfm_pmu_conf->counter_width;
-+	u64 new_val, mask[PFM_PMD_BV];
-+
-+	bitmap_and(cast_ulp(mask), cast_ulp(cntr_pmds),
-+		   cast_ulp(used_pmds), max_pmd);
-+
-+	for (i = 0; i < max_pmd; i++) {
-+		if (test_bit(i, mask)) {
-+			new_val = pfm_power4_read_pmd(i);
-+			if (new_val & width_mask) {
-+				set_bit(i, set->povfl_pmds);
-+				set->npend_ovfls++;
-+			}
-+		}
-+	}
-+}
-+
-+static void pfm_power4_irq_handler(struct pt_regs *regs,
-+				   struct pfm_context *ctx)
-+{
-+	u32 mmcr0;
-+
-+	/* Disable the counters (set the freeze bit) to not polute
-+	 * the counts.
-+	 */
-+	mmcr0 = mfspr(SPRN_MMCR0);
-+	mtspr(SPRN_MMCR0, (mmcr0 | MMCR0_FC));
-+
-+	/* Set the PMM bit (see comment below). */
-+	mtmsrd(mfmsr() | MSR_PMM);
-+
-+	pfm_interrupt_handler(instruction_pointer(regs), regs);
-+
-+	mmcr0 = mfspr(SPRN_MMCR0);
-+
-+	/*
-+	 * Reset the perfmon trigger if
-+	 * not in masking mode.
-+	 */
-+	if (ctx->state != PFM_CTX_MASKED)
-+		mmcr0 |= MMCR0_PMXE;
-+
-+	/*
-+	 * We must clear the PMAO bit on some (GQ) chips. Just do it
-+	 * all the time.
-+	 */
-+	mmcr0 &= ~MMCR0_PMAO;
-+
-+	/*
-+	 * Now clear the freeze bit, counting will not start until we
-+	 * rfid from this exception, because only at that point will
-+	 * the PMM bit be cleared.
-+	 */
-+	mmcr0 &= ~MMCR0_FC;
-+	mtspr(SPRN_MMCR0, mmcr0);
-+}
-+
-+static void pfm_power4_resend_irq(struct pfm_context *ctx)
-+{
-+	/*
-+	 * Assert the PMAO bit to cause a PMU interrupt.  Make sure we
-+	 * trigger the edge detection circuitry for PMAO
-+	 */
-+	mtspr(SPRN_MMCR0, mfspr(SPRN_MMCR0) & ~MMCR0_PMAO);
-+	mtspr(SPRN_MMCR0, mfspr(SPRN_MMCR0) | MMCR0_PMAO);
-+}
-+
-+struct pfm_arch_pmu_info pfm_power4_pmu_info = {
-+	.pmu_style        = PFM_POWERPC_PMU_POWER4,
-+	.write_pmc        = pfm_power4_write_pmc,
-+	.write_pmd        = pfm_power4_write_pmd,
-+	.read_pmd         = pfm_power4_read_pmd,
-+	.irq_handler      = pfm_power4_irq_handler,
-+	.get_ovfl_pmds    = pfm_power4_get_ovfl_pmds,
-+	.enable_counters  = pfm_power4_enable_counters,
-+	.disable_counters = pfm_power4_disable_counters,
-+	.resend_irq       = pfm_power4_resend_irq
-+};
-+
-+/*
-+ * impl_pmcs, impl_pmds are computed at runtime to minimize errors!
-+ */
-+static struct pfm_pmu_config pfm_power4_pmu_conf = {
-+	.pmu_name = "POWER4",
-+	.counter_width = 31,
-+	.pmd_desc = pfm_power4_pmd_desc,
-+	.pmc_desc = pfm_power4_pmc_desc,
-+	.num_pmc_entries = PFM_PM_NUM_PMCS,
-+	.num_pmd_entries = PFM_PM_NUM_PMDS,
-+	.probe_pmu  = pfm_power4_probe_pmu,
-+	.pmu_info = &pfm_power4_pmu_info,
-+	.flags = PFM_PMU_BUILTIN_FLAG,
-+	.owner = THIS_MODULE
-+};
-+
-+static int __init pfm_power4_pmu_init_module(void)
-+{
-+	return pfm_pmu_register(&pfm_power4_pmu_conf);
-+}
-+
-+static void __exit pfm_power4_pmu_cleanup_module(void)
-+{
-+	pfm_pmu_unregister(&pfm_power4_pmu_conf);
-+}
-+
-+module_init(pfm_power4_pmu_init_module);
-+module_exit(pfm_power4_pmu_cleanup_module);
-diff --git a/arch/powerpc/perfmon/perfmon_power5.c b/arch/powerpc/perfmon/perfmon_power5.c
-new file mode 100644
-index 0000000..f4bb1ac
---- /dev/null
-+++ b/arch/powerpc/perfmon/perfmon_power5.c
-@@ -0,0 +1,326 @@
-+/*
-+ * This file contains the POWER5 PMU register description tables
-+ * and pmc checker used by perfmon.c.
-+ *
-+ * Copyright (c) 2005 David Gibson, IBM Corporation.
-+ *
-+ * Based on perfmon_p6.c:
-+ * Copyright (c) 2005-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/module.h>
-+#include <linux/perfmon_kern.h>
-+
-+MODULE_AUTHOR("David Gibson <dwg@au1.ibm.com>");
-+MODULE_DESCRIPTION("POWER5 PMU description table");
-+MODULE_LICENSE("GPL");
-+
-+static struct pfm_regmap_desc pfm_power5_pmc_desc[] = {
-+/* mmcr0 */ PMC_D(PFM_REG_I, "MMCR0", MMCR0_FC, 0, 0, SPRN_MMCR0),
-+/* mmcr1 */ PMC_D(PFM_REG_I, "MMCR1", 0, 0, 0, SPRN_MMCR1),
-+/* mmcra */ PMC_D(PFM_REG_I, "MMCRA", 0, 0, 0, SPRN_MMCRA)
-+};
-+#define PFM_PM_NUM_PMCS	ARRAY_SIZE(pfm_power5_pmc_desc)
-+
-+/* The TB and PURR registers are read-only. Also, note that the TB register
-+ * actually consists of both the 32-bit SPRN_TBRU and SPRN_TBRL registers.
-+ * For Perfmon2's purposes, we'll treat it as a single 64-bit register.
-+ */
-+static struct pfm_regmap_desc pfm_power5_pmd_desc[] = {
-+/* tb    */ PMD_D((PFM_REG_I|PFM_REG_RO), "TB", SPRN_TBRL),
-+/* pmd1  */ PMD_D(PFM_REG_C, "PMC1", SPRN_PMC1),
-+/* pmd2  */ PMD_D(PFM_REG_C, "PMC2", SPRN_PMC2),
-+/* pmd3  */ PMD_D(PFM_REG_C, "PMC3", SPRN_PMC3),
-+/* pmd4  */ PMD_D(PFM_REG_C, "PMC4", SPRN_PMC4),
-+/* pmd5  */ PMD_D(PFM_REG_C, "PMC5", SPRN_PMC5),
-+/* pmd6  */ PMD_D(PFM_REG_C, "PMC6", SPRN_PMC6),
-+/* purr  */ PMD_D((PFM_REG_I|PFM_REG_RO), "PURR", SPRN_PURR),
-+};
-+#define PFM_PM_NUM_PMDS	ARRAY_SIZE(pfm_power5_pmd_desc)
-+
-+/* forward decl */
-+static void pfm_power5_disable_counters(struct pfm_context *ctx,
-+					struct pfm_event_set *set);
-+
-+static int pfm_power5_probe_pmu(void)
-+{
-+	unsigned long pvr = mfspr(SPRN_PVR);
-+
-+	switch (PVR_VER(pvr)) {
-+	case PV_POWER5:
-+		return 0;
-+	case PV_POWER5p:
-+		return (PVR_REV(pvr) < 0x300) ? 0 : -1;
-+	default:
-+		return -1;
-+	}
-+}
-+
-+static void pfm_power5_write_pmc(unsigned int cnum, u64 value)
-+{
-+	switch (pfm_pmu_conf->pmc_desc[cnum].hw_addr) {
-+	case SPRN_MMCR0:
-+		mtspr(SPRN_MMCR0, value);
-+		break;
-+	case SPRN_MMCR1:
-+		mtspr(SPRN_MMCR1, value);
-+		break;
-+	case SPRN_MMCRA:
-+		mtspr(SPRN_MMCRA, value);
-+		break;
-+	default:
-+		BUG();
-+	}
-+}
-+
-+static void pfm_power5_write_pmd(unsigned int cnum, u64 value)
-+{
-+	u64 ovfl_mask = pfm_pmu_conf->ovfl_mask;
-+
-+	switch (pfm_pmu_conf->pmd_desc[cnum].hw_addr) {
-+	case SPRN_PMC1:
-+		mtspr(SPRN_PMC1, value & ovfl_mask);
-+		break;
-+	case SPRN_PMC2:
-+		mtspr(SPRN_PMC2, value & ovfl_mask);
-+		break;
-+	case SPRN_PMC3:
-+		mtspr(SPRN_PMC3, value & ovfl_mask);
-+		break;
-+	case SPRN_PMC4:
-+		mtspr(SPRN_PMC4, value & ovfl_mask);
-+		break;
-+	case SPRN_PMC5:
-+		mtspr(SPRN_PMC5, value & ovfl_mask);
-+		break;
-+	case SPRN_PMC6:
-+		mtspr(SPRN_PMC6, value & ovfl_mask);
-+		break;
-+	case SPRN_TBRL:
-+	case SPRN_PURR:
-+		/* Ignore writes to read-only registers. */
-+		break;
-+	default:
-+		BUG();
-+	}
-+}
-+
-+static u64 pfm_power5_read_pmd(unsigned int cnum)
-+{
-+	switch (pfm_pmu_conf->pmd_desc[cnum].hw_addr) {
-+	case SPRN_PMC1:
-+		return mfspr(SPRN_PMC1);
-+	case SPRN_PMC2:
-+		return mfspr(SPRN_PMC2);
-+	case SPRN_PMC3:
-+		return mfspr(SPRN_PMC3);
-+	case SPRN_PMC4:
-+		return mfspr(SPRN_PMC4);
-+	case SPRN_PMC5:
-+		return mfspr(SPRN_PMC5);
-+	case SPRN_PMC6:
-+		return mfspr(SPRN_PMC6);
-+	case SPRN_TBRL:
-+		return ((u64)mfspr(SPRN_TBRU) << 32) | mfspr(SPRN_TBRL);
-+	case SPRN_PURR:
-+		if (cpu_has_feature(CPU_FTR_PURR))
-+			return mfspr(SPRN_PURR);
-+		else
-+			return 0;
-+	default:
-+		BUG();
-+	}
-+}
-+
-+/**
-+ * pfm_power5_enable_counters
-+ *
-+ **/
-+static void pfm_power5_enable_counters(struct pfm_context *ctx,
-+				       struct pfm_event_set *set)
-+{
-+	unsigned int i, max_pmc;
-+
-+	/*
-+	 * Make sure the counters are disabled before touching the
-+	 * other control registers
-+	 */
-+	pfm_power5_disable_counters(ctx, set);
-+
-+	max_pmc = ctx->regs.max_pmc;
-+
-+	/*
-+	 * Write MMCR0 last, and a fairly easy way to do
-+	 * this is to write the registers in the reverse
-+	 * order
-+	 */
-+	for (i = max_pmc; i != 0; i--)
-+		if (test_bit(i - 1, set->used_pmcs))
-+			pfm_power5_write_pmc(i - 1, set->pmcs[i - 1]);
-+}
-+
-+/**
-+ * pfm_power5_disable_counters
-+ *
-+ * Just need to zero all the control registers.
-+ **/
-+static void pfm_power5_disable_counters(struct pfm_context *ctx,
-+					struct pfm_event_set *set)
-+{
-+	/* Set the Freeze Counters bit */
-+	mtspr(SPRN_MMCR0, mfspr(SPRN_MMCR0) | MMCR0_FC);
-+	asm volatile ("sync");
-+}
-+
-+/**
-+ * pfm_power5_get_ovfl_pmds
-+ *
-+ * Determine which counters in this set have overflowed and fill in the
-+ * set->povfl_pmds mask and set->npend_ovfls count.
-+ **/
-+static void pfm_power5_get_ovfl_pmds(struct pfm_context *ctx,
-+				     struct pfm_event_set *set)
-+{
-+	unsigned int i;
-+	unsigned int max = ctx->regs.max_intr_pmd;
-+	u64 *used_pmds = set->used_pmds;
-+	u64 *intr_pmds = ctx->regs.intr_pmds;
-+	u64 width_mask = 1 << pfm_pmu_conf->counter_width;
-+	u64 new_val, mask[PFM_PMD_BV];
-+
-+	bitmap_and(cast_ulp(mask), cast_ulp(intr_pmds),
-+		   cast_ulp(used_pmds), max);
-+	/*
-+	 * If either PMC5 or PMC6 are not being used, just zero out the unused
-+	 * ones so that they won't interrupt again for another 2^31 counts.
-+	 * Note that if no other counters overflowed, set->npend_ovfls will
-+	 * be zero upon returning from this call (i.e. a spurious
-+	 * interrupt), but that should be ok.
-+	 *
-+	 * If neither PMC5 nor PMC6 are used, the counters should be frozen
-+	 * via MMCR0_FC5_6 and zeroed out.
-+	 *
-+	 * If both PMC5 and PMC6 are used, they can be handled correctly by
-+	 * the loop that follows.
-+	 */
-+
-+	if  (!test_bit(5, cast_ulp(used_pmds)))
-+		mtspr(SPRN_PMC5, 0);
-+	if  (!test_bit(6, cast_ulp(used_pmds)))
-+		mtspr(SPRN_PMC6, 0);
-+
-+	for (i = 0; i < max; i++) {
-+		if (test_bit(i, mask)) {
-+			new_val = pfm_power5_read_pmd(i);
-+			if (new_val & width_mask) {
-+				set_bit(i, set->povfl_pmds);
-+				set->npend_ovfls++;
-+			}
-+		}
-+	}
-+}
-+
-+static void pfm_power5_irq_handler(struct pt_regs *regs,
-+				   struct pfm_context *ctx)
-+{
-+	u32 mmcr0;
-+
-+	/* Disable the counters (set the freeze bit) to not polute
-+	 * the counts.
-+	 */
-+	mmcr0 = mfspr(SPRN_MMCR0);
-+	mtspr(SPRN_MMCR0, (mmcr0 | MMCR0_FC));
-+
-+	/* Set the PMM bit (see comment below). */
-+	mtmsrd(mfmsr() | MSR_PMM);
-+
-+	pfm_interrupt_handler(instruction_pointer(regs), regs);
-+
-+	mmcr0 = mfspr(SPRN_MMCR0);
-+
-+	/*
-+	 * Reset the perfmon trigger if
-+	 * not in masking mode.
-+	 */
-+	if (ctx->state != PFM_CTX_MASKED)
-+		mmcr0 |= MMCR0_PMXE;
-+
-+	/*
-+	 * We must clear the PMAO bit on some (GQ) chips. Just do it
-+	 * all the time.
-+	 */
-+	mmcr0 &= ~MMCR0_PMAO;
-+
-+	/*
-+	 * Now clear the freeze bit, counting will not start until we
-+	 * rfid from this exception, because only at that point will
-+	 * the PMM bit be cleared.
-+	 */
-+	mmcr0 &= ~MMCR0_FC;
-+	mtspr(SPRN_MMCR0, mmcr0);
-+}
-+
-+static void pfm_power5_resend_irq(struct pfm_context *ctx)
-+{
-+	/*
-+	 * Assert the PMAO bit to cause a PMU interrupt.  Make sure we
-+	 * trigger the edge detection circuitry for PMAO
-+	 */
-+	mtspr(SPRN_MMCR0, mfspr(SPRN_MMCR0) & ~MMCR0_PMAO);
-+	mtspr(SPRN_MMCR0, mfspr(SPRN_MMCR0) | MMCR0_PMAO);
-+}
-+
-+struct pfm_arch_pmu_info pfm_power5_pmu_info = {
-+	.pmu_style        = PFM_POWERPC_PMU_POWER5,
-+	.write_pmc        = pfm_power5_write_pmc,
-+	.write_pmd        = pfm_power5_write_pmd,
-+	.read_pmd         = pfm_power5_read_pmd,
-+	.irq_handler      = pfm_power5_irq_handler,
-+	.get_ovfl_pmds    = pfm_power5_get_ovfl_pmds,
-+	.enable_counters  = pfm_power5_enable_counters,
-+	.disable_counters = pfm_power5_disable_counters,
-+	.resend_irq       = pfm_power5_resend_irq
-+};
-+
-+/*
-+ * impl_pmcs, impl_pmds are computed at runtime to minimize errors!
-+ */
-+static struct pfm_pmu_config pfm_power5_pmu_conf = {
-+	.pmu_name = "POWER5",
-+	.counter_width = 31,
-+	.pmd_desc = pfm_power5_pmd_desc,
-+	.pmc_desc = pfm_power5_pmc_desc,
-+	.num_pmc_entries = PFM_PM_NUM_PMCS,
-+	.num_pmd_entries = PFM_PM_NUM_PMDS,
-+	.probe_pmu  = pfm_power5_probe_pmu,
-+	.pmu_info = &pfm_power5_pmu_info,
-+	.flags = PFM_PMU_BUILTIN_FLAG,
-+	.owner = THIS_MODULE
-+};
-+
-+static int __init pfm_power5_pmu_init_module(void)
-+{
-+	return pfm_pmu_register(&pfm_power5_pmu_conf);
-+}
-+
-+static void __exit pfm_power5_pmu_cleanup_module(void)
-+{
-+	pfm_pmu_unregister(&pfm_power5_pmu_conf);
-+}
-+
-+module_init(pfm_power5_pmu_init_module);
-+module_exit(pfm_power5_pmu_cleanup_module);
-diff --git a/arch/powerpc/perfmon/perfmon_power6.c b/arch/powerpc/perfmon/perfmon_power6.c
-new file mode 100644
-index 0000000..7882feb
---- /dev/null
-+++ b/arch/powerpc/perfmon/perfmon_power6.c
-@@ -0,0 +1,520 @@
-+/*
-+ * This file contains the POWER6 PMU register description tables
-+ * and pmc checker used by perfmon.c.
-+ *
-+ * Copyright (c) 2007, IBM Corporation
-+ *
-+ * Based on perfmon_power5.c, and written by Carl Love <carll@us.ibm.com>
-+ * and Kevin Corry <kevcorry@us.ibm.com>.  Some fixes and refinement by
-+ * Corey Ashford <cjashfor@us.ibm.com>
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/module.h>
-+#include <linux/perfmon_kern.h>
-+
-+MODULE_AUTHOR("Corey Ashford <cjashfor@us.ibm.com>");
-+MODULE_DESCRIPTION("POWER6 PMU description table");
-+MODULE_LICENSE("GPL");
-+
-+static struct pfm_regmap_desc pfm_power6_pmc_desc[] = {
-+/* mmcr0 */ PMC_D(PFM_REG_I, "MMCR0", MMCR0_FC, 0, 0, SPRN_MMCR0),
-+/* mmcr1 */ PMC_D(PFM_REG_I, "MMCR1", 0, 0, 0, SPRN_MMCR1),
-+/* mmcra */ PMC_D(PFM_REG_I, "MMCRA", 0, 0, 0, SPRN_MMCRA)
-+};
-+#define PFM_PM_NUM_PMCS	ARRAY_SIZE(pfm_power6_pmc_desc)
-+#define PFM_DELTA_TB    10000   /* Not a real registers */
-+#define PFM_DELTA_PURR  10001
-+
-+/*
-+ * counters wrap to zero at transition from 2^32-1 to 2^32.  Note:
-+ * interrupt generated at transition from 2^31-1 to 2^31
-+ */
-+#define OVERFLOW_VALUE    0x100000000UL
-+
-+/* The TB and PURR registers are read-only. Also, note that the TB register
-+ * actually consists of both the 32-bit SPRN_TBRU and SPRN_TBRL registers.
-+ * For Perfmon2's purposes, we'll treat it as a single 64-bit register.
-+ */
-+static struct pfm_regmap_desc pfm_power6_pmd_desc[] = {
-+	/* On POWER 6 PMC5 and PMC6 are not writable, they do not
-+	 * generate interrupts, and do not qualify their counts
-+	 * based on problem mode, supervisor mode or hypervisor mode.
-+	 * These two counters are implemented as virtual counters
-+	 * to make the appear to work like the other counters.  A
-+	 * kernel timer is used sample the real PMC5 and PMC6 and
-+	 * update the virtual counters.
-+	 */
-+/* tb    */ PMD_D((PFM_REG_I|PFM_REG_RO), "TB", SPRN_TBRL),
-+/* pmd1  */ PMD_D(PFM_REG_C, "PMC1", SPRN_PMC1),
-+/* pmd2  */ PMD_D(PFM_REG_C, "PMC2", SPRN_PMC2),
-+/* pmd3  */ PMD_D(PFM_REG_C, "PMC3", SPRN_PMC3),
-+/* pmd4  */ PMD_D(PFM_REG_C, "PMC4", SPRN_PMC4),
-+/* pmd5  */ PMD_D((PFM_REG_I|PFM_REG_V), "PMC5", SPRN_PMC5),
-+/* pmd6  */ PMD_D((PFM_REG_I|PFM_REG_V), "PMC6", SPRN_PMC6),
-+/* purr  */ PMD_D((PFM_REG_I|PFM_REG_RO), "PURR", SPRN_PURR),
-+/* delta purr */ PMD_D((PFM_REG_I|PFM_REG_V), "DELTA_TB", PFM_DELTA_TB),
-+/* delta tb   */ PMD_D((PFM_REG_I|PFM_REG_V), "DELTA_PURR", PFM_DELTA_PURR),
-+};
-+
-+#define PFM_PM_NUM_PMDS	ARRAY_SIZE(pfm_power6_pmd_desc)
-+
-+u32 pmc5_start_save[NR_CPUS];
-+u32 pmc6_start_save[NR_CPUS];
-+
-+static struct timer_list pmc5_6_update[NR_CPUS];
-+u64 enable_cntrs_cnt;
-+u64 disable_cntrs_cnt;
-+u64 call_delta;
-+u64 pm5_6_interrupt;
-+u64 pm1_4_interrupt;
-+/* need ctx_arch for kernel timer.  Can't get it in context of the kernel
-+ * timer.
-+ */
-+struct pfm_arch_context *pmc5_6_ctx_arch[NR_CPUS];
-+long int update_time;
-+
-+static void delta(int cpu_num, struct pfm_arch_context *ctx_arch)
-+{
-+	u32 tmp5, tmp6;
-+
-+	call_delta++;
-+
-+	tmp5 = (u32) mfspr(SPRN_PMC5);
-+	tmp6 = (u32) mfspr(SPRN_PMC6);
-+
-+	/*
-+	 * The following difference calculation relies on 32-bit modular
-+	 * arithmetic for the deltas to come out correct (especially in the
-+	 * presence of a 32-bit counter wrap).
-+	 */
-+	ctx_arch->powergs_pmc5 += (u64)(tmp5 - pmc5_start_save[cpu_num]);
-+	ctx_arch->powergs_pmc6 += (u64)(tmp6 - pmc6_start_save[cpu_num]);
-+
-+	pmc5_start_save[cpu_num] = tmp5;
-+	pmc6_start_save[cpu_num] = tmp6;
-+
-+	return;
-+}
-+
-+
-+static void pmc5_6_updater(unsigned long cpu_num)
-+{
-+	/* update the virtual pmd 5 and pmd 6 counters */
-+
-+	delta(cpu_num, pmc5_6_ctx_arch[cpu_num]);
-+	mod_timer(&pmc5_6_update[cpu_num], jiffies + update_time);
-+}
-+
-+
-+static int pfm_power6_probe_pmu(void)
-+{
-+	unsigned long pvr = mfspr(SPRN_PVR);
-+
-+	switch (PVR_VER(pvr)) {
-+	case PV_POWER6:
-+		return 0;
-+	case PV_POWER5p:
-+		/* If this is a POWER5+ and the revision is less than 0x300,
-+		   don't treat it as a POWER6. */
-+		return (PVR_REV(pvr) < 0x300) ? -1 : 0;
-+	default:
-+		return -1;
-+	}
-+}
-+
-+static void pfm_power6_write_pmc(unsigned int cnum, u64 value)
-+{
-+	switch (pfm_pmu_conf->pmc_desc[cnum].hw_addr) {
-+	case SPRN_MMCR0:
-+		mtspr(SPRN_MMCR0, value);
-+		break;
-+	case SPRN_MMCR1:
-+		mtspr(SPRN_MMCR1, value);
-+		break;
-+	case SPRN_MMCRA:
-+		mtspr(SPRN_MMCRA, value);
-+		break;
-+	default:
-+		BUG();
-+	}
-+}
-+
-+static void pfm_power6_write_pmd(unsigned int cnum, u64 value)
-+{
-+	/* On POWER 6 PMC5 and PMC6 are implemented as
-+	 * virtual counters.  See comment in pfm_power6_pmd_desc
-+	 * definition.
-+	 */
-+	u64 ovfl_mask = pfm_pmu_conf->ovfl_mask;
-+
-+	switch (pfm_pmu_conf->pmd_desc[cnum].hw_addr) {
-+	case SPRN_PMC1:
-+		mtspr(SPRN_PMC1, value & ovfl_mask);
-+		break;
-+	case SPRN_PMC2:
-+		mtspr(SPRN_PMC2, value & ovfl_mask);
-+		break;
-+	case SPRN_PMC3:
-+		mtspr(SPRN_PMC3, value & ovfl_mask);
-+		break;
-+	case SPRN_PMC4:
-+		mtspr(SPRN_PMC4, value & ovfl_mask);
-+		break;
-+	case SPRN_TBRL:
-+	case SPRN_PURR:
-+		/* Ignore writes to read-only registers. */
-+		break;
-+	default:
-+		BUG();
-+	}
-+}
-+
-+static u64 pfm_power6_sread(struct pfm_context *ctx, unsigned int cnum)
-+{
-+	struct pfm_arch_context *ctx_arch = pfm_ctx_arch(ctx);
-+	int cpu_num = smp_processor_id();
-+
-+	/* On POWER 6 PMC5 and PMC6 are implemented as
-+	 * virtual counters.  See comment in pfm_power6_pmd_desc
-+	 * definition.
-+	 */
-+
-+	switch (pfm_pmu_conf->pmd_desc[cnum].hw_addr) {
-+	case SPRN_PMC5:
-+		return ctx_arch->powergs_pmc5 + (u64)((u32)mfspr(SPRN_PMC5) - pmc5_start_save[cpu_num]);
-+		break;
-+
-+	case SPRN_PMC6:
-+		return ctx_arch->powergs_pmc6 + (u64)((u32)mfspr(SPRN_PMC6) - pmc6_start_save[cpu_num]);
-+		break;
-+
-+	case PFM_DELTA_TB:
-+		return ctx_arch->delta_tb
-+			+ (((u64)mfspr(SPRN_TBRU) << 32) | mfspr(SPRN_TBRL))
-+			- ctx_arch->delta_tb_start;
-+		break;
-+
-+	case PFM_DELTA_PURR:
-+		return ctx_arch->delta_purr
-+			+ mfspr(SPRN_PURR)
-+			- ctx_arch->delta_purr_start;
-+		break;
-+
-+	default:
-+		BUG();
-+	}
-+}
-+
-+void pfm_power6_swrite(struct pfm_context *ctx, unsigned int cnum,
-+	u64 val)
-+{
-+	struct pfm_arch_context *ctx_arch = pfm_ctx_arch(ctx);
-+	int cpu_num = smp_processor_id();
-+
-+	switch (pfm_pmu_conf->pmd_desc[cnum].hw_addr) {
-+	case SPRN_PMC5:
-+		pmc5_start_save[cpu_num] = mfspr(SPRN_PMC5);
-+		ctx_arch->powergs_pmc5 = val;
-+		break;
-+
-+	case SPRN_PMC6:
-+		pmc6_start_save[cpu_num] = mfspr(SPRN_PMC6);
-+		ctx_arch->powergs_pmc6 = val;
-+		break;
-+
-+	case PFM_DELTA_TB:
-+		ctx_arch->delta_tb_start =
-+			(((u64)mfspr(SPRN_TBRU) << 32) | mfspr(SPRN_TBRL));
-+		ctx_arch->delta_tb = val;
-+		break;
-+
-+	case PFM_DELTA_PURR:
-+		ctx_arch->delta_purr_start = mfspr(SPRN_PURR);
-+		ctx_arch->delta_purr = val;
-+		break;
-+
-+	default:
-+		BUG();
-+	}
-+}
-+
-+static u64 pfm_power6_read_pmd(unsigned int cnum)
-+{
-+	switch (pfm_pmu_conf->pmd_desc[cnum].hw_addr) {
-+	case SPRN_PMC1:
-+		return mfspr(SPRN_PMC1);
-+	case SPRN_PMC2:
-+		return mfspr(SPRN_PMC2);
-+	case SPRN_PMC3:
-+		return mfspr(SPRN_PMC3);
-+	case SPRN_PMC4:
-+		return mfspr(SPRN_PMC4);
-+	case SPRN_TBRL:
-+		return ((u64)mfspr(SPRN_TBRU) << 32) | mfspr(SPRN_TBRL);
-+	case SPRN_PURR:
-+		if (cpu_has_feature(CPU_FTR_PURR))
-+			return mfspr(SPRN_PURR);
-+		else
-+			return 0;
-+	default:
-+		BUG();
-+	}
-+}
-+
-+
-+/**
-+ * pfm_power6_enable_counters
-+ *
-+ **/
-+static void pfm_power6_enable_counters(struct pfm_context *ctx,
-+				       struct pfm_event_set *set)
-+{
-+
-+	unsigned int i, max_pmc;
-+	int cpu_num = smp_processor_id();
-+	struct pfm_arch_context *ctx_arch;
-+
-+	enable_cntrs_cnt++;
-+
-+	/* need the ctx passed down to the routine */
-+	ctx_arch = pfm_ctx_arch(ctx);
-+	max_pmc = ctx->regs.max_pmc;
-+
-+	/* Write MMCR0 last, and a fairly easy way to do this is to write
-+	   the registers in the reverse order */
-+	for (i = max_pmc; i != 0; i--)
-+		if (test_bit(i - 1, set->used_pmcs))
-+			pfm_power6_write_pmc(i - 1, set->pmcs[i - 1]);
-+
-+	/* save current free running HW event count */
-+	pmc5_start_save[cpu_num] = mfspr(SPRN_PMC5);
-+	pmc6_start_save[cpu_num] = mfspr(SPRN_PMC6);
-+
-+	ctx_arch->delta_purr_start = mfspr(SPRN_PURR);
-+
-+	if (cpu_has_feature(CPU_FTR_PURR))
-+		ctx_arch->delta_tb_start =
-+			((u64)mfspr(SPRN_TBRU) << 32) | mfspr(SPRN_TBRL);
-+	else
-+		ctx_arch->delta_tb_start = 0;
-+
-+	/* Start kernel timer for this cpu to periodically update
-+	 * the virtual counters.
-+	 */
-+	init_timer(&pmc5_6_update[cpu_num]);
-+	pmc5_6_update[cpu_num].function = pmc5_6_updater;
-+	pmc5_6_update[cpu_num].data = (unsigned long) cpu_num;
-+	pmc5_6_update[cpu_num].expires = jiffies + update_time;
-+	/* context for this timer, timer will be removed if context
-+	 * is switched because the counters will be stopped first.
-+	 * NEEDS WORK, I think this is all ok, a little concerned about a
-+	 * race between the kernel timer going off right as the counters
-+	 * are being stopped and the context switching.  Need to think
-+	 * about this.
-+	 */
-+	pmc5_6_ctx_arch[cpu_num] = ctx_arch;
-+	add_timer(&pmc5_6_update[cpu_num]);
-+}
-+
-+/**
-+ * pfm_power6_disable_counters
-+ *
-+ **/
-+static void pfm_power6_disable_counters(struct pfm_context *ctx,
-+					struct pfm_event_set *set)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+	int cpu_num = smp_processor_id();
-+
-+	disable_cntrs_cnt++;
-+
-+	/* Set the Freeze Counters bit */
-+	mtspr(SPRN_MMCR0, mfspr(SPRN_MMCR0) | MMCR0_FC);
-+	asm volatile ("sync");
-+
-+	/* delete kernel update timer */
-+	del_timer_sync(&pmc5_6_update[cpu_num]);
-+
-+	/* Update the virtual pmd 5 and 6 counters from the free running
-+	 * HW counters
-+	 */
-+	ctx_arch = pfm_ctx_arch(ctx);
-+	delta(cpu_num, ctx_arch);
-+
-+	ctx_arch->delta_tb +=
-+		(((u64)mfspr(SPRN_TBRU) << 32) | mfspr(SPRN_TBRL))
-+		- ctx_arch->delta_tb_start;
-+
-+	ctx_arch->delta_purr += mfspr(SPRN_PURR)
-+		- ctx_arch->delta_purr_start;
-+}
-+
-+/**
-+ * pfm_power6_get_ovfl_pmds
-+ *
-+ * Determine which counters in this set have overflowed and fill in the
-+ * set->povfl_pmds mask and set->npend_ovfls count.
-+ **/
-+static void pfm_power6_get_ovfl_pmds(struct pfm_context *ctx,
-+				     struct pfm_event_set *set)
-+{
-+	unsigned int i;
-+	unsigned int first_intr_pmd = ctx->regs.first_intr_pmd;
-+	unsigned int max_intr_pmd = ctx->regs.max_intr_pmd;
-+	u64 *used_pmds = set->used_pmds;
-+	u64 *cntr_pmds = ctx->regs.cnt_pmds;
-+	u64 width_mask = 1 << pfm_pmu_conf->counter_width;
-+	u64 new_val, mask[PFM_PMD_BV];
-+
-+	bitmap_and(cast_ulp(mask), cast_ulp(cntr_pmds), cast_ulp(used_pmds), max_intr_pmd);
-+
-+	/* max_intr_pmd is actually the last interrupting pmd register + 1 */
-+	for (i = first_intr_pmd; i < max_intr_pmd; i++) {
-+		if (test_bit(i, mask)) {
-+			new_val = pfm_power6_read_pmd(i);
-+			if (new_val & width_mask) {
-+				set_bit(i, set->povfl_pmds);
-+				set->npend_ovfls++;
-+			}
-+		}
-+	}
-+}
-+
-+static void pfm_power6_irq_handler(struct pt_regs *regs,
-+				   struct pfm_context *ctx)
-+{
-+	u32 mmcr0;
-+	u64 mmcra;
-+
-+	/* Disable the counters (set the freeze bit) to not polute
-+	 * the counts.
-+	 */
-+	mmcr0 = mfspr(SPRN_MMCR0);
-+	mtspr(SPRN_MMCR0, (mmcr0 | MMCR0_FC));
-+	mmcra = mfspr(SPRN_MMCRA);
-+
-+	/* Set the PMM bit (see comment below). */
-+	mtmsrd(mfmsr() | MSR_PMM);
-+
-+	pm1_4_interrupt++;
-+
-+	pfm_interrupt_handler(instruction_pointer(regs), regs);
-+
-+	mmcr0 = mfspr(SPRN_MMCR0);
-+
-+	/*
-+	 * Reset the perfmon trigger if
-+	 * not in masking mode.
-+	 */
-+	if (ctx->state != PFM_CTX_MASKED)
-+		mmcr0 |= MMCR0_PMXE;
-+
-+	/*
-+	 * Clear the PMU Alert Occurred bit
-+	 */
-+	mmcr0 &= ~MMCR0_PMAO;
-+
-+	/* Clear the appropriate bits in the MMCRA. */
-+	mmcra &= ~(POWER6_MMCRA_THRM | POWER6_MMCRA_OTHER);
-+	mtspr(SPRN_MMCRA, mmcra);
-+
-+	/*
-+	 * Now clear the freeze bit, counting will not start until we
-+	 * rfid from this exception, because only at that point will
-+	 * the PMM bit be cleared.
-+	 */
-+	mmcr0 &= ~MMCR0_FC;
-+	mtspr(SPRN_MMCR0, mmcr0);
-+}
-+
-+static void pfm_power6_resend_irq(struct pfm_context *ctx)
-+{
-+	/*
-+	 * Assert the PMAO bit to cause a PMU interrupt.  Make sure we
-+	 * trigger the edge detection circuitry for PMAO
-+	 */
-+	mtspr(SPRN_MMCR0, mfspr(SPRN_MMCR0) & ~MMCR0_PMAO);
-+	mtspr(SPRN_MMCR0, mfspr(SPRN_MMCR0) | MMCR0_PMAO);
-+}
-+
-+struct pfm_arch_pmu_info pfm_power6_pmu_info = {
-+	.pmu_style        = PFM_POWERPC_PMU_POWER6,
-+	.write_pmc        = pfm_power6_write_pmc,
-+	.write_pmd        = pfm_power6_write_pmd,
-+	.read_pmd         = pfm_power6_read_pmd,
-+	.irq_handler      = pfm_power6_irq_handler,
-+	.get_ovfl_pmds    = pfm_power6_get_ovfl_pmds,
-+	.enable_counters  = pfm_power6_enable_counters,
-+	.disable_counters = pfm_power6_disable_counters,
-+	.resend_irq       = pfm_power6_resend_irq
-+};
-+
-+/*
-+ * impl_pmcs, impl_pmds are computed at runtime to minimize errors!
-+ */
-+static struct pfm_pmu_config pfm_power6_pmu_conf = {
-+	.pmu_name = "POWER6",
-+	.counter_width = 31,
-+	.pmd_desc = pfm_power6_pmd_desc,
-+	.pmc_desc = pfm_power6_pmc_desc,
-+	.num_pmc_entries = PFM_PM_NUM_PMCS,
-+	.num_pmd_entries = PFM_PM_NUM_PMDS,
-+	.probe_pmu  = pfm_power6_probe_pmu,
-+	.pmu_info = &pfm_power6_pmu_info,
-+	.pmd_sread = pfm_power6_sread,
-+	.pmd_swrite = pfm_power6_swrite,
-+	.flags = PFM_PMU_BUILTIN_FLAG,
-+	.owner = THIS_MODULE
-+};
-+
-+static int __init pfm_power6_pmu_init_module(void)
-+{
-+	int ret;
-+	disable_cntrs_cnt = 0;
-+	enable_cntrs_cnt = 0;
-+	call_delta = 0;
-+	pm5_6_interrupt = 0;
-+	pm1_4_interrupt = 0;
-+
-+	/* calculate the time for updating counters 5 and 6 */
-+
-+	/*
-+	 * MAX_EVENT_RATE assumes a max instruction issue rate of 2
-+	 * instructions per clock cycle.  Experience shows that this factor
-+	 * of 2 is more than adequate.
-+	 */
-+
-+# define MAX_EVENT_RATE (ppc_proc_freq * 2)
-+
-+	/*
-+	 * Calculate the time, in jiffies, it takes for event counter 5 or
-+	 * 6 to completely wrap when counting at the max event rate, and
-+	 * then figure on sampling at twice that rate.
-+	 */
-+	update_time = (((unsigned long)HZ * OVERFLOW_VALUE)
-+		       / ((unsigned long)MAX_EVENT_RATE)) / 2;
-+
-+	ret =  pfm_pmu_register(&pfm_power6_pmu_conf);
-+	return ret;
-+}
-+
-+static void __exit pfm_power6_pmu_cleanup_module(void)
-+{
-+	pfm_pmu_unregister(&pfm_power6_pmu_conf);
-+}
-+
-+module_init(pfm_power6_pmu_init_module);
-+module_exit(pfm_power6_pmu_cleanup_module);
-diff --git a/arch/powerpc/perfmon/perfmon_ppc32.c b/arch/powerpc/perfmon/perfmon_ppc32.c
-new file mode 100644
-index 0000000..76f0b84
---- /dev/null
-+++ b/arch/powerpc/perfmon/perfmon_ppc32.c
-@@ -0,0 +1,340 @@
-+/*
-+ * This file contains the PPC32 PMU register description tables
-+ * and pmc checker used by perfmon.c.
-+ *
-+ * Philip Mucci, mucci@cs.utk.edu
-+ *
-+ * Based on code from:
-+ * Copyright (c) 2005 David Gibson, IBM Corporation.
-+ *
-+ * Based on perfmon_p6.c:
-+ * Copyright (c) 2005-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/module.h>
-+#include <linux/perfmon_kern.h>
-+#include <asm/reg.h>
-+
-+MODULE_AUTHOR("Philip Mucci <mucci@cs.utk.edu>");
-+MODULE_DESCRIPTION("PPC32 PMU description table");
-+MODULE_LICENSE("GPL");
-+
-+static struct pfm_pmu_config pfm_ppc32_pmu_conf;
-+
-+static struct pfm_regmap_desc pfm_ppc32_pmc_desc[] = {
-+/* mmcr0 */ PMC_D(PFM_REG_I, "MMCR0", 0x0, 0, 0, SPRN_MMCR0),
-+/* mmcr1 */ PMC_D(PFM_REG_I, "MMCR1", 0x0, 0, 0, SPRN_MMCR1),
-+/* mmcr2 */ PMC_D(PFM_REG_I, "MMCR2", 0x0, 0, 0, SPRN_MMCR2),
-+};
-+#define PFM_PM_NUM_PMCS	ARRAY_SIZE(pfm_ppc32_pmc_desc)
-+
-+static struct pfm_regmap_desc pfm_ppc32_pmd_desc[] = {
-+/* pmd0  */ PMD_D(PFM_REG_C, "PMC1", SPRN_PMC1),
-+/* pmd1  */ PMD_D(PFM_REG_C, "PMC2", SPRN_PMC2),
-+/* pmd2  */ PMD_D(PFM_REG_C, "PMC3", SPRN_PMC3),
-+/* pmd3  */ PMD_D(PFM_REG_C, "PMC4", SPRN_PMC4),
-+/* pmd4  */ PMD_D(PFM_REG_C, "PMC5", SPRN_PMC5),
-+/* pmd5  */ PMD_D(PFM_REG_C, "PMC6", SPRN_PMC6),
-+};
-+#define PFM_PM_NUM_PMDS	ARRAY_SIZE(pfm_ppc32_pmd_desc)
-+
-+static void perfmon_perf_irq(struct pt_regs *regs)
-+{
-+	u32 mmcr0;
-+
-+	/* BLATANTLY STOLEN FROM OPROFILE, then modified */
-+
-+	/* set the PMM bit (see comment below) */
-+	mtmsr(mfmsr() | MSR_PMM);
-+
-+	pfm_interrupt_handler(instruction_pointer(regs), regs);
-+
-+	/* The freeze bit was set by the interrupt.
-+	 * Clear the freeze bit, and reenable the interrupt.
-+	 * The counters won't actually start until the rfi clears
-+	 * the PMM bit.
-+	 */
-+
-+	/* Unfreezes the counters on this CPU, enables the interrupt,
-+	 * enables the counters to trigger the interrupt, and sets the
-+	 * counters to only count when the mark bit is not set.
-+	 */
-+	mmcr0 = mfspr(SPRN_MMCR0);
-+
-+	mmcr0 &= ~(MMCR0_FC | MMCR0_FCM0);
-+	mmcr0 |= (MMCR0_FCECE | MMCR0_PMC1CE | MMCR0_PMCnCE | MMCR0_PMXE);
-+
-+	mtspr(SPRN_MMCR0, mmcr0);
-+}
-+
-+static int pfm_ppc32_probe_pmu(void)
-+{
-+	enum ppc32_pmu_type pm_type;
-+	int nmmcr = 0, npmds = 0, intsok = 0, i;
-+	unsigned int pvr;
-+	char *str;
-+
-+	pvr = mfspr(SPRN_PVR);
-+
-+	switch (PVR_VER(pvr)) {
-+	case 0x0004: /* 604 */
-+		str = "PPC604";
-+		pm_type = PFM_POWERPC_PMU_604;
-+		nmmcr = 1;
-+		npmds = 2;
-+		break;
-+	case 0x0009: /* 604e;  */
-+	case 0x000A: /* 604ev */
-+		str = "PPC604e";
-+		pm_type = PFM_POWERPC_PMU_604e;
-+		nmmcr = 2;
-+		npmds = 4;
-+		break;
-+	case 0x0008: /* 750/740 */
-+		str = "PPC750";
-+		pm_type = PFM_POWERPC_PMU_750;
-+		nmmcr = 2;
-+		npmds = 4;
-+		break;
-+	case 0x7000: /* 750FX */
-+	case 0x7001:
-+		str = "PPC750";
-+		pm_type = PFM_POWERPC_PMU_750;
-+		nmmcr = 2;
-+		npmds = 4;
-+		if ((pvr & 0xFF0F) >= 0x0203)
-+			intsok = 1;
-+		break;
-+	case 0x7002: /* 750GX */
-+		str = "PPC750";
-+		pm_type = PFM_POWERPC_PMU_750;
-+		nmmcr = 2;
-+		npmds = 4;
-+		intsok = 1;
-+	case 0x000C: /* 7400 */
-+		str = "PPC7400";
-+		pm_type = PFM_POWERPC_PMU_7400;
-+		nmmcr = 3;
-+		npmds = 4;
-+		break;
-+	case 0x800C: /* 7410 */
-+		str = "PPC7410";
-+		pm_type = PFM_POWERPC_PMU_7400;
-+		nmmcr = 3;
-+		npmds = 4;
-+		if ((pvr & 0xFFFF) >= 0x01103)
-+			intsok = 1;
-+		break;
-+	case 0x8000: /* 7451/7441 */
-+	case 0x8001: /* 7455/7445 */
-+	case 0x8002: /* 7457/7447 */
-+	case 0x8003: /* 7447A */
-+	case 0x8004: /* 7448 */
-+		str = "PPC7450";
-+		pm_type = PFM_POWERPC_PMU_7450;
-+		nmmcr = 3; npmds = 6;
-+		intsok = 1;
-+		break;
-+	default:
-+		PFM_INFO("Unknown PVR_VER(0x%x)\n", PVR_VER(pvr));
-+		return -1;
-+	}
-+
-+	/*
-+	 * deconfigure unimplemented registers
-+	 */
-+	for (i = npmds; i < PFM_PM_NUM_PMDS; i++)
-+		pfm_ppc32_pmd_desc[i].type = PFM_REG_NA;
-+
-+	for (i = nmmcr; i < PFM_PM_NUM_PMCS; i++)
-+		pfm_ppc32_pmc_desc[i].type = PFM_REG_NA;
-+
-+	/*
-+	 * update PMU description structure
-+	 */
-+	pfm_ppc32_pmu_conf.pmu_name = str;
-+	pfm_ppc32_pmu_info.pmu_style = pm_type;
-+	pfm_ppc32_pmu_conf.num_pmc_entries = nmmcr;
-+	pfm_ppc32_pmu_conf.num_pmd_entries = npmds;
-+
-+	if (intsok == 0)
-+		PFM_INFO("Interrupts unlikely to work\n");
-+
-+	return reserve_pmc_hardware(perfmon_perf_irq);
-+}
-+
-+static void pfm_ppc32_write_pmc(unsigned int cnum, u64 value)
-+{
-+	switch (pfm_pmu_conf->pmc_desc[cnum].hw_addr) {
-+	case SPRN_MMCR0:
-+		mtspr(SPRN_MMCR0, value);
-+		break;
-+	case SPRN_MMCR1:
-+		mtspr(SPRN_MMCR1, value);
-+		break;
-+	case SPRN_MMCR2:
-+		mtspr(SPRN_MMCR2, value);
-+		break;
-+	default:
-+		BUG();
-+	}
-+}
-+
-+static void pfm_ppc32_write_pmd(unsigned int cnum, u64 value)
-+{
-+	switch (pfm_pmu_conf->pmd_desc[cnum].hw_addr) {
-+	case SPRN_PMC1:
-+		mtspr(SPRN_PMC1, value);
-+		break;
-+	case SPRN_PMC2:
-+		mtspr(SPRN_PMC2, value);
-+		break;
-+	case SPRN_PMC3:
-+		mtspr(SPRN_PMC3, value);
-+		break;
-+	case SPRN_PMC4:
-+		mtspr(SPRN_PMC4, value);
-+		break;
-+	case SPRN_PMC5:
-+		mtspr(SPRN_PMC5, value);
-+		break;
-+	case SPRN_PMC6:
-+		mtspr(SPRN_PMC6, value);
-+		break;
-+	default:
-+		BUG();
-+	}
-+}
-+
-+static u64 pfm_ppc32_read_pmd(unsigned int cnum)
-+{
-+	switch (pfm_pmu_conf->pmd_desc[cnum].hw_addr) {
-+	case SPRN_PMC1:
-+		return mfspr(SPRN_PMC1);
-+	case SPRN_PMC2:
-+		return mfspr(SPRN_PMC2);
-+	case SPRN_PMC3:
-+		return mfspr(SPRN_PMC3);
-+	case SPRN_PMC4:
-+		return mfspr(SPRN_PMC4);
-+	case SPRN_PMC5:
-+		return mfspr(SPRN_PMC5);
-+	case SPRN_PMC6:
-+		return mfspr(SPRN_PMC6);
-+	default:
-+		BUG();
-+	}
-+}
-+
-+/**
-+ * pfm_ppc32_enable_counters
-+ *
-+ * Just need to load the current values into the control registers.
-+ **/
-+static void pfm_ppc32_enable_counters(struct pfm_context *ctx,
-+				      struct pfm_event_set *set)
-+{
-+	unsigned int i, max_pmc;
-+
-+	max_pmc = pfm_pmu_conf->regs.max_pmc;
-+
-+	for (i = 0; i < max_pmc; i++)
-+		if (test_bit(i, set->used_pmcs))
-+			pfm_ppc32_write_pmc(i, set->pmcs[i]);
-+}
-+
-+/**
-+ * pfm_ppc32_disable_counters
-+ *
-+ * Just need to zero all the control registers.
-+ **/
-+static void pfm_ppc32_disable_counters(struct pfm_context *ctx,
-+				       struct pfm_event_set *set)
-+{
-+	unsigned int i, max;
-+
-+	max = pfm_pmu_conf->regs.max_pmc;
-+
-+	for (i = 0; i < max; i++)
-+		if (test_bit(i, set->used_pmcs))
-+			pfm_ppc32_write_pmc(ctx, 0);
-+}
-+
-+/**
-+ * pfm_ppc32_get_ovfl_pmds
-+ *
-+ * Determine which counters in this set have overflowed and fill in the
-+ * set->povfl_pmds mask and set->npend_ovfls count.
-+ **/
-+static void pfm_ppc32_get_ovfl_pmds(struct pfm_context *ctx,
-+				    struct pfm_event_set *set)
-+{
-+	unsigned int i;
-+	unsigned int max_pmd = pfm_pmu_conf->regs.max_cnt_pmd;
-+	u64 *used_pmds = set->used_pmds;
-+	u64 *cntr_pmds = pfm_pmu_conf->regs.cnt_pmds;
-+	u64 width_mask = 1 << pfm_pmu_conf->counter_width;
-+	u64 new_val, mask[PFM_PMD_BV];
-+
-+	bitmap_and(cast_ulp(mask), cast_ulp(cntr_pmds),
-+		   cast_ulp(used_pmds), max_pmd);
-+
-+	for (i = 0; i < max_pmd; i++) {
-+		if (test_bit(i, mask)) {
-+			new_val = pfm_ppc32_read_pmd(i);
-+			if (new_val & width_mask) {
-+				set_bit(i, set->povfl_pmds);
-+				set->npend_ovfls++;
-+			}
-+		}
-+	}
-+}
-+
-+struct pfm_arch_pmu_info pfm_ppc32_pmu_info = {
-+	.pmu_style        = PFM_POWERPC_PMU_NONE,
-+	.write_pmc        = pfm_ppc32_write_pmc,
-+	.write_pmd        = pfm_ppc32_write_pmd,
-+	.read_pmd         = pfm_ppc32_read_pmd,
-+	.get_ovfl_pmds    = pfm_ppc32_get_ovfl_pmds,
-+	.enable_counters  = pfm_ppc32_enable_counters,
-+	.disable_counters = pfm_ppc32_disable_counters,
-+};
-+
-+static struct pfm_pmu_config pfm_ppc32_pmu_conf = {
-+	.counter_width = 31,
-+	.pmd_desc = pfm_ppc32_pmd_desc,
-+	.pmc_desc = pfm_ppc32_pmc_desc,
-+	.probe_pmu  = pfm_ppc32_probe_pmu,
-+	.flags = PFM_PMU_BUILTIN_FLAG,
-+	.owner = THIS_MODULE,
-+	.version = "0.1",
-+	.arch_info = &pfm_ppc32_pmu_info,
-+};
-+
-+static int __init pfm_ppc32_pmu_init_module(void)
-+{
-+	return pfm_pmu_register(&pfm_ppc32_pmu_conf);
-+}
-+
-+static void __exit pfm_ppc32_pmu_cleanup_module(void)
-+{
-+	release_pmc_hardware();
-+	pfm_pmu_unregister(&pfm_ppc32_pmu_conf);
-+}
-+
-+module_init(pfm_ppc32_pmu_init_module);
-+module_exit(pfm_ppc32_pmu_cleanup_module);
-diff --git a/arch/powerpc/platforms/cell/cbe_regs.c b/arch/powerpc/platforms/cell/cbe_regs.c
-index dbc338f..e24320e 100644
---- a/arch/powerpc/platforms/cell/cbe_regs.c
-+++ b/arch/powerpc/platforms/cell/cbe_regs.c
-@@ -33,6 +33,7 @@ static struct cbe_regs_map
- 	struct cbe_iic_regs __iomem *iic_regs;
- 	struct cbe_mic_tm_regs __iomem *mic_tm_regs;
- 	struct cbe_pmd_shadow_regs pmd_shadow_regs;
-+	struct cbe_ppe_priv_regs __iomem *ppe_priv_regs;
- } cbe_regs_maps[MAX_CBE];
- static int cbe_regs_map_count;
- 
-@@ -145,6 +146,23 @@ struct cbe_mic_tm_regs __iomem *cbe_get_cpu_mic_tm_regs(int cpu)
- }
- EXPORT_SYMBOL_GPL(cbe_get_cpu_mic_tm_regs);
- 
-+struct cbe_ppe_priv_regs __iomem *cbe_get_ppe_priv_regs(struct device_node *np)
-+{
-+	struct cbe_regs_map *map = cbe_find_map(np);
-+	if (map == NULL)
-+		return NULL;
-+	return map->ppe_priv_regs;
-+}
-+
-+struct cbe_ppe_priv_regs __iomem *cbe_get_cpu_ppe_priv_regs(int cpu)
-+{
-+	struct cbe_regs_map *map = cbe_thread_map[cpu].regs;
-+	if (map == NULL)
-+		return NULL;
-+	return map->ppe_priv_regs;
-+}
-+EXPORT_SYMBOL_GPL(cbe_get_cpu_ppe_priv_regs);
-+
- u32 cbe_get_hw_thread_id(int cpu)
- {
- 	return cbe_thread_map[cpu].thread_id;
-@@ -206,6 +224,11 @@ void __init cbe_fill_regs_map(struct cbe_regs_map *map)
- 		for_each_node_by_type(np, "mic-tm")
- 			if (of_get_parent(np) == be)
- 				map->mic_tm_regs = of_iomap(np, 0);
-+
-+		for_each_node_by_type(np, "ppe-mmio")
-+			if (of_get_parent(np) == be)
-+				map->ppe_priv_regs = of_iomap(np, 0);
-+
- 	} else {
- 		struct device_node *cpu;
- 		/* That hack must die die die ! */
-@@ -227,6 +250,10 @@ void __init cbe_fill_regs_map(struct cbe_regs_map *map)
- 		prop = of_get_property(cpu, "mic-tm", NULL);
- 		if (prop != NULL)
- 			map->mic_tm_regs = ioremap(prop->address, prop->len);
-+
-+		prop = of_get_property(cpu, "ppe-mmio", NULL);
-+		if (prop != NULL)
-+			map->ppe_priv_regs = ioremap(prop->address, prop->len);
- 	}
- }
- 
-diff --git a/arch/sparc/include/asm/hypervisor.h b/arch/sparc/include/asm/hypervisor.h
-index 109ae24..bafe5a6 100644
---- a/arch/sparc/include/asm/hypervisor.h
-+++ b/arch/sparc/include/asm/hypervisor.h
-@@ -2713,6 +2713,30 @@ extern unsigned long sun4v_ldc_revoke(unsigned long channel,
-  */
- #define HV_FAST_SET_PERFREG		0x101
- 
-+#define HV_N2_PERF_SPARC_CTL		0x0
-+#define HV_N2_PERF_DRAM_CTL0		0x1
-+#define HV_N2_PERF_DRAM_CNT0		0x2
-+#define HV_N2_PERF_DRAM_CTL1		0x3
-+#define HV_N2_PERF_DRAM_CNT1		0x4
-+#define HV_N2_PERF_DRAM_CTL2		0x5
-+#define HV_N2_PERF_DRAM_CNT2		0x6
-+#define HV_N2_PERF_DRAM_CTL3		0x7
-+#define HV_N2_PERF_DRAM_CNT3		0x8
-+
-+#define HV_FAST_N2_GET_PERFREG		0x104
-+#define HV_FAST_N2_SET_PERFREG		0x105
-+
-+#ifndef __ASSEMBLY__
-+extern unsigned long sun4v_niagara_getperf(unsigned long reg,
-+					   unsigned long *val);
-+extern unsigned long sun4v_niagara_setperf(unsigned long reg,
-+					   unsigned long val);
-+extern unsigned long sun4v_niagara2_getperf(unsigned long reg,
-+					    unsigned long *val);
-+extern unsigned long sun4v_niagara2_setperf(unsigned long reg,
-+					    unsigned long val);
-+#endif
-+
- /* MMU statistics services.
-  *
-  * The hypervisor maintains MMU statistics and privileged code provides
-diff --git a/arch/sparc/include/asm/irq_64.h b/arch/sparc/include/asm/irq_64.h
-index e3dd930..6cf3aec 100644
---- a/arch/sparc/include/asm/irq_64.h
-+++ b/arch/sparc/include/asm/irq_64.h
-@@ -67,6 +67,9 @@ extern void virt_irq_free(unsigned int virt_irq);
- extern void __init init_IRQ(void);
- extern void fixup_irqs(void);
- 
-+extern int register_perfctr_intr(void (*handler)(struct pt_regs *));
-+extern void release_perfctr_intr(void (*handler)(struct pt_regs *));
-+
- static inline void set_softint(unsigned long bits)
- {
- 	__asm__ __volatile__("wr	%0, 0x0, %%set_softint"
-diff --git a/arch/sparc/include/asm/perfmon.h b/arch/sparc/include/asm/perfmon.h
-new file mode 100644
-index 0000000..f20cbfa
---- /dev/null
-+++ b/arch/sparc/include/asm/perfmon.h
-@@ -0,0 +1,11 @@
-+#ifndef _SPARC64_PERFMON_H_
-+#define _SPARC64_PERFMON_H_
-+
-+/*
-+ * arch-specific user visible interface definitions
-+ */
-+
-+#define PFM_ARCH_MAX_PMCS	2
-+#define PFM_ARCH_MAX_PMDS	3
-+
-+#endif /* _SPARC64_PERFMON_H_ */
-diff --git a/arch/sparc/include/asm/perfmon_kern.h b/arch/sparc/include/asm/perfmon_kern.h
-new file mode 100644
-index 0000000..033eff5
---- /dev/null
-+++ b/arch/sparc/include/asm/perfmon_kern.h
-@@ -0,0 +1,286 @@
-+#ifndef _SPARC64_PERFMON_KERN_H_
-+#define _SPARC64_PERFMON_KERN_H_
-+
-+#ifdef __KERNEL__
-+
-+#ifdef CONFIG_PERFMON
-+
-+#include <linux/irq.h>
-+#include <asm/system.h>
-+
-+#define PFM_ARCH_PMD_STK_ARG	2
-+#define PFM_ARCH_PMC_STK_ARG	1
-+
-+struct pfm_arch_pmu_info {
-+	u32 pmu_style;
-+};
-+
-+static inline void pfm_arch_resend_irq(struct pfm_context *ctx)
-+{
-+}
-+
-+static inline void pfm_arch_clear_pmd_ovfl_cond(struct pfm_context *ctx,
-+					        struct pfm_event_set *set)
-+{}
-+
-+static inline void pfm_arch_serialize(void)
-+{
-+}
-+
-+/*
-+ * SPARC does not save the PMDs during pfm_arch_intr_freeze_pmu(), thus
-+ * this routine needs to do it when switching sets on overflow
-+ */
-+static inline void pfm_arch_save_pmds_from_intr(struct pfm_context *ctx,
-+						struct pfm_event_set *set)
-+{
-+	pfm_save_pmds(ctx, set);
-+}
-+
-+extern void pfm_arch_write_pmc(struct pfm_context *ctx,
-+			       unsigned int cnum, u64 value);
-+extern u64 pfm_arch_read_pmc(struct pfm_context *ctx, unsigned int cnum);
-+
-+static inline void pfm_arch_write_pmd(struct pfm_context *ctx,
-+				      unsigned int cnum, u64 value)
-+{
-+	u64 pic;
-+
-+	value &= pfm_pmu_conf->ovfl_mask;
-+
-+	read_pic(pic);
-+
-+	switch (cnum) {
-+	case 0:
-+		pic = (pic & 0xffffffff00000000UL) |
-+			(value & 0xffffffffUL);
-+		break;
-+	case 1:
-+		pic = (pic & 0xffffffffUL) |
-+			(value << 32UL);
-+		break;
-+	default:
-+		BUG();
-+	}
-+
-+	write_pic(pic);
-+}
-+
-+static inline u64 pfm_arch_read_pmd(struct pfm_context *ctx,
-+				    unsigned int cnum)
-+{
-+	u64 pic;
-+
-+	read_pic(pic);
-+
-+	switch (cnum) {
-+	case 0:
-+		return pic & 0xffffffffUL;
-+	case 1:
-+		return pic >> 32UL;
-+	default:
-+		BUG();
-+		return 0;
-+	}
-+}
-+
-+/*
-+ * For some CPUs, the upper bits of a counter must be set in order for the
-+ * overflow interrupt to happen. On overflow, the counter has wrapped around,
-+ * and the upper bits are cleared. This function may be used to set them back.
-+ */
-+static inline void pfm_arch_ovfl_reset_pmd(struct pfm_context *ctx,
-+					   unsigned int cnum)
-+{
-+	u64 val = pfm_arch_read_pmd(ctx, cnum);
-+
-+	/* This masks out overflow bit 31 */
-+	pfm_arch_write_pmd(ctx, cnum, val);
-+}
-+
-+/*
-+ * At certain points, perfmon needs to know if monitoring has been
-+ * explicitely started/stopped by user via pfm_start/pfm_stop. The
-+ * information is tracked in ctx.flags.started. However on certain
-+ * architectures, it may be possible to start/stop directly from
-+ * user level with a single assembly instruction bypassing
-+ * the kernel. This function must be used to determine by
-+ * an arch-specific mean if monitoring is actually started/stopped.
-+ */
-+static inline int pfm_arch_is_active(struct pfm_context *ctx)
-+{
-+	return ctx->flags.started;
-+}
-+
-+static inline void pfm_arch_ctxswout_sys(struct task_struct *task,
-+					 struct pfm_context *ctx)
-+{
-+}
-+
-+static inline void pfm_arch_ctxswin_sys(struct task_struct *task,
-+					struct pfm_context *ctx)
-+{
-+}
-+
-+static inline void pfm_arch_ctxswin_thread(struct task_struct *task,
-+					   struct pfm_context *ctx)
-+{
-+}
-+
-+int  pfm_arch_is_monitoring_active(struct pfm_context *ctx);
-+int  pfm_arch_ctxswout_thread(struct task_struct *task,
-+			      struct pfm_context *ctx);
-+void pfm_arch_stop(struct task_struct *task, struct pfm_context *ctx);
-+void pfm_arch_start(struct task_struct *task, struct pfm_context *ctx);
-+void pfm_arch_restore_pmds(struct pfm_context *ctx, struct pfm_event_set *set);
-+void pfm_arch_restore_pmcs(struct pfm_context *ctx, struct pfm_event_set *set);
-+char *pfm_arch_get_pmu_module_name(void);
-+
-+static inline void pfm_arch_intr_freeze_pmu(struct pfm_context *ctx,
-+					    struct pfm_event_set *set)
-+{
-+	pfm_arch_stop(current, ctx);
-+	/*
-+	 * we mark monitoring as stopped to avoid
-+	 * certain side effects especially in
-+	 * pfm_switch_sets_from_intr() on
-+	 * pfm_arch_restore_pmcs()
-+	 */
-+	ctx->flags.started = 0;
-+}
-+
-+/*
-+ * unfreeze PMU from pfm_do_interrupt_handler()
-+ * ctx may be NULL for spurious
-+ */
-+static inline void pfm_arch_intr_unfreeze_pmu(struct pfm_context *ctx)
-+{
-+	if (!ctx)
-+		return;
-+
-+	PFM_DBG_ovfl("state=%d", ctx->state);
-+
-+	ctx->flags.started = 1;
-+
-+	if (ctx->state == PFM_CTX_MASKED)
-+		return;
-+
-+	pfm_arch_restore_pmcs(ctx, ctx->active_set);
-+}
-+
-+/*
-+ * this function is called from the PMU interrupt handler ONLY.
-+ * On SPARC, the PMU is frozen via arch_stop, masking would be implemented
-+ * via arch-stop as well. Given that the PMU is already stopped when
-+ * entering the interrupt handler, we do not need to stop it again, so
-+ * this function is a nop.
-+ */
-+static inline void pfm_arch_mask_monitoring(struct pfm_context *ctx,
-+					    struct pfm_event_set *set)
-+{
-+}
-+
-+/*
-+ * on MIPS masking/unmasking uses the start/stop mechanism, so we simply
-+ * need to start here.
-+ */
-+static inline void pfm_arch_unmask_monitoring(struct pfm_context *ctx,
-+					      struct pfm_event_set *set)
-+{
-+	pfm_arch_start(current, ctx);
-+}
-+
-+static inline void pfm_arch_pmu_config_remove(void)
-+{
-+}
-+
-+static inline int pfm_arch_context_create(struct pfm_context *ctx,
-+					  u32 ctx_flags)
-+{
-+	return 0;
-+}
-+
-+static inline void pfm_arch_context_free(struct pfm_context *ctx)
-+{
-+}
-+
-+/*
-+ * function called from pfm_setfl_sane(). Context is locked
-+ * and interrupts are masked.
-+ * The value of flags is the value of ctx_flags as passed by
-+ * user.
-+ *
-+ * function must check arch-specific set flags.
-+ * Return:
-+ * 	1 when flags are valid
-+ *      0 on error
-+ */
-+static inline int pfm_arch_setfl_sane(struct pfm_context *ctx, u32 flags)
-+{
-+	return 0;
-+}
-+
-+static inline int pfm_arch_init(void)
-+{
-+	return 0;
-+}
-+
-+static inline void pfm_arch_init_percpu(void)
-+{
-+}
-+
-+static inline int pfm_arch_load_context(struct pfm_context *ctx)
-+{
-+	return 0;
-+}
-+
-+static inline void pfm_arch_unload_context(struct pfm_context *ctx)
-+{}
-+
-+extern void perfmon_interrupt(struct pt_regs *);
-+
-+static inline int pfm_arch_pmu_acquire(u64 *unavail_pmcs, u64 *unavail_pmds)
-+{
-+	return register_perfctr_intr(perfmon_interrupt);
-+}
-+
-+static inline void pfm_arch_pmu_release(void)
-+{
-+	release_perfctr_intr(perfmon_interrupt);
-+}
-+
-+static inline void pfm_arch_arm_handle_work(struct task_struct *task)
-+{}
-+
-+static inline void pfm_arch_disarm_handle_work(struct task_struct *task)
-+{}
-+
-+static inline int pfm_arch_pmu_config_init(struct pfm_pmu_config *cfg)
-+{
-+	return 0;
-+}
-+
-+static inline int pfm_arch_get_base_syscall(void)
-+{
-+	return __NR_pfm_create_context;
-+}
-+
-+struct pfm_arch_context {
-+	/* empty */
-+};
-+
-+#define PFM_ARCH_CTX_SIZE	sizeof(struct pfm_arch_context)
-+/*
-+ * SPARC needs extra alignment for the sampling buffer
-+ */
-+#define PFM_ARCH_SMPL_ALIGN_SIZE	(16 * 1024)
-+
-+static inline void pfm_cacheflush(void *addr, unsigned int len)
-+{
-+}
-+
-+#endif /* CONFIG_PERFMON */
-+
-+#endif /* __KERNEL__ */
-+
-+#endif /* _SPARC64_PERFMON_KERN_H_ */
-diff --git a/arch/sparc/include/asm/system_64.h b/arch/sparc/include/asm/system_64.h
-index db9e742..2a9ddb9 100644
---- a/arch/sparc/include/asm/system_64.h
-+++ b/arch/sparc/include/asm/system_64.h
-@@ -30,6 +30,9 @@ enum sparc_cpu {
- #define ARCH_SUN4C_SUN4 0
- #define ARCH_SUN4 0
- 
-+extern char *sparc_cpu_type;
-+extern char *sparc_fpu_type;
-+extern char *sparc_pmu_type;
- extern char reboot_command[];
- 
- /* These are here in an effort to more fully work around Spitfire Errata
-@@ -104,15 +107,13 @@ do {	__asm__ __volatile__("ba,pt	%%xcc, 1f\n\t" \
- #define write_pcr(__p) __asm__ __volatile__("wr	%0, 0x0, %%pcr" : : "r" (__p))
- #define read_pic(__p)  __asm__ __volatile__("rd %%pic, %0" : "=r" (__p))
- 
--/* Blackbird errata workaround.  See commentary in
-- * arch/sparc64/kernel/smp.c:smp_percpu_timer_interrupt()
-- * for more information.
-- */
--#define reset_pic()    						\
--	__asm__ __volatile__("ba,pt	%xcc, 99f\n\t"		\
-+/* Blackbird errata workaround.  */
-+#define write_pic(val)    					\
-+	__asm__ __volatile__("ba,pt	%%xcc, 99f\n\t"		\
- 			     ".align	64\n"			\
--			  "99:wr	%g0, 0x0, %pic\n\t"	\
--			     "rd	%pic, %g0")
-+			  "99:wr	%0, 0x0, %%pic\n\t"	\
-+			     "rd	%%pic, %%g0" : : "r" (val))
-+#define reset_pic()	write_pic(0)
- 
- #ifndef __ASSEMBLY__
- 
-@@ -145,14 +146,10 @@ do {						\
- 	 * and 2 stores in this critical code path.  -DaveM
- 	 */
- #define switch_to(prev, next, last)					\
--do {	if (test_thread_flag(TIF_PERFCTR)) {				\
--		unsigned long __tmp;					\
--		read_pcr(__tmp);					\
--		current_thread_info()->pcr_reg = __tmp;			\
--		read_pic(__tmp);					\
--		current_thread_info()->kernel_cntd0 += (unsigned int)(__tmp);\
--		current_thread_info()->kernel_cntd1 += ((__tmp) >> 32);	\
--	}								\
-+do {	if (test_tsk_thread_flag(prev, TIF_PERFMON_CTXSW))		\
-+		pfm_ctxsw_out(prev, next);				\
-+	if (test_tsk_thread_flag(next, TIF_PERFMON_CTXSW))		\
-+		pfm_ctxsw_in(prev, next);				\
- 	flush_tlb_pending();						\
- 	save_and_clear_fpu();						\
- 	/* If you are tempted to conditionalize the following */	\
-@@ -197,11 +194,6 @@ do {	if (test_thread_flag(TIF_PERFCTR)) {				\
- 	        "l1", "l2", "l3", "l4", "l5", "l6", "l7",		\
- 	  "i0", "i1", "i2", "i3", "i4", "i5",				\
- 	  "o0", "o1", "o2", "o3", "o4", "o5",       "o7");		\
--	/* If you fuck with this, update ret_from_syscall code too. */	\
--	if (test_thread_flag(TIF_PERFCTR)) {				\
--		write_pcr(current_thread_info()->pcr_reg);		\
--		reset_pic();						\
--	}								\
- } while(0)
- 
- static inline unsigned long xchg32(__volatile__ unsigned int *m, unsigned int val)
-diff --git a/arch/sparc/include/asm/thread_info_64.h b/arch/sparc/include/asm/thread_info_64.h
-index c0a737d..53857f7 100644
---- a/arch/sparc/include/asm/thread_info_64.h
-+++ b/arch/sparc/include/asm/thread_info_64.h
-@@ -58,11 +58,6 @@ struct thread_info {
- 	unsigned long		gsr[7];
- 	unsigned long		xfsr[7];
- 
--	__u64			__user *user_cntd0;
--	__u64			__user *user_cntd1;
--	__u64			kernel_cntd0, kernel_cntd1;
--	__u64			pcr_reg;
--
- 	struct restart_block	restart_block;
- 
- 	struct pt_regs		*kern_una_regs;
-@@ -96,15 +91,10 @@ struct thread_info {
- #define TI_RWIN_SPTRS	0x000003c8
- #define TI_GSR		0x00000400
- #define TI_XFSR		0x00000438
--#define TI_USER_CNTD0	0x00000470
--#define TI_USER_CNTD1	0x00000478
--#define TI_KERN_CNTD0	0x00000480
--#define TI_KERN_CNTD1	0x00000488
--#define TI_PCR		0x00000490
--#define TI_RESTART_BLOCK 0x00000498
--#define TI_KUNA_REGS	0x000004c0
--#define TI_KUNA_INSN	0x000004c8
--#define TI_FPREGS	0x00000500
-+#define TI_RESTART_BLOCK 0x00000470
-+#define TI_KUNA_REGS	0x00000498
-+#define TI_KUNA_INSN	0x000004a0
-+#define TI_FPREGS	0x000004c0
- 
- /* We embed this in the uppermost byte of thread_info->flags */
- #define FAULT_CODE_WRITE	0x01	/* Write access, implies D-TLB	   */
-@@ -222,11 +212,11 @@ register struct thread_info *current_thread_info_reg asm("g6");
- #define TIF_NOTIFY_RESUME	1	/* callback before returning to user */
- #define TIF_SIGPENDING		2	/* signal pending */
- #define TIF_NEED_RESCHED	3	/* rescheduling necessary */
--#define TIF_PERFCTR		4	/* performance counters active */
-+/* Bit 4 is available */
- #define TIF_UNALIGNED		5	/* allowed to do unaligned accesses */
- /* flag bit 6 is available */
- #define TIF_32BIT		7	/* 32-bit binary */
--/* flag bit 8 is available */
-+#define TIF_PERFMON_WORK	8	/* work for pfm_handle_work() */
- #define TIF_SECCOMP		9	/* secure computing */
- #define TIF_SYSCALL_AUDIT	10	/* syscall auditing active */
- /* flag bit 11 is available */
-@@ -237,22 +227,24 @@ register struct thread_info *current_thread_info_reg asm("g6");
- #define TIF_ABI_PENDING		12
- #define TIF_MEMDIE		13
- #define TIF_POLLING_NRFLAG	14
-+#define TIF_PERFMON_CTXSW	15	/* perfmon needs ctxsw calls */
- 
- #define _TIF_SYSCALL_TRACE	(1<<TIF_SYSCALL_TRACE)
- #define _TIF_NOTIFY_RESUME	(1<<TIF_NOTIFY_RESUME)
- #define _TIF_SIGPENDING		(1<<TIF_SIGPENDING)
- #define _TIF_NEED_RESCHED	(1<<TIF_NEED_RESCHED)
--#define _TIF_PERFCTR		(1<<TIF_PERFCTR)
- #define _TIF_UNALIGNED		(1<<TIF_UNALIGNED)
- #define _TIF_32BIT		(1<<TIF_32BIT)
-+#define _TIF_PERFMON_WORK	(1<<TIF_PERFMON_WORK)
- #define _TIF_SECCOMP		(1<<TIF_SECCOMP)
- #define _TIF_SYSCALL_AUDIT	(1<<TIF_SYSCALL_AUDIT)
- #define _TIF_ABI_PENDING	(1<<TIF_ABI_PENDING)
- #define _TIF_POLLING_NRFLAG	(1<<TIF_POLLING_NRFLAG)
-+#define _TIF_PERFMON_CTXSW	(1<<TIF_PERFMON_CTXSW)
- 
- #define _TIF_USER_WORK_MASK	((0xff << TI_FLAG_WSAVED_SHIFT) | \
- 				 _TIF_DO_NOTIFY_RESUME_MASK | \
--				 _TIF_NEED_RESCHED | _TIF_PERFCTR)
-+				 _TIF_NEED_RESCHED)
- #define _TIF_DO_NOTIFY_RESUME_MASK	(_TIF_NOTIFY_RESUME | _TIF_SIGPENDING)
- 
- /*
-diff --git a/arch/sparc/include/asm/unistd_32.h b/arch/sparc/include/asm/unistd_32.h
-index 648643a..efe4d86 100644
---- a/arch/sparc/include/asm/unistd_32.h
-+++ b/arch/sparc/include/asm/unistd_32.h
-@@ -338,8 +338,20 @@
- #define __NR_dup3		320
- #define __NR_pipe2		321
- #define __NR_inotify_init1	322
-+#define __NR_pfm_create_context 323
-+#define __NR_pfm_write_pmcs	324
-+#define __NR_pfm_write_pmds	325
-+#define __NR_pfm_read_pmds	326
-+#define __NR_pfm_load_context	327
-+#define __NR_pfm_start		328
-+#define __NR_pfm_stop		329
-+#define __NR_pfm_restart	330
-+#define __NR_pfm_create_evtsets	331
-+#define __NR_pfm_getinfo_evtsets 332
-+#define __NR_pfm_delete_evtsets	333
-+#define __NR_pfm_unload_context	334
- 
--#define NR_SYSCALLS		323
-+#define NR_SYSCALLS		325
- 
- /* Sparc 32-bit only has the "setresuid32", "getresuid32" variants,
-  * it never had the plain ones and there is no value to adding those
-diff --git a/arch/sparc/include/asm/unistd_64.h b/arch/sparc/include/asm/unistd_64.h
-index c5cc0e0..cbbb0b5 100644
---- a/arch/sparc/include/asm/unistd_64.h
-+++ b/arch/sparc/include/asm/unistd_64.h
-@@ -340,8 +340,20 @@
- #define __NR_dup3		320
- #define __NR_pipe2		321
- #define __NR_inotify_init1	322
-+#define __NR_pfm_create_context 323
-+#define __NR_pfm_write_pmcs	324
-+#define __NR_pfm_write_pmds	325
-+#define __NR_pfm_read_pmds	326
-+#define __NR_pfm_load_context	327
-+#define __NR_pfm_start		328
-+#define __NR_pfm_stop		329
-+#define __NR_pfm_restart	330
-+#define __NR_pfm_create_evtsets	331
-+#define __NR_pfm_getinfo_evtsets 332
-+#define __NR_pfm_delete_evtsets	333
-+#define __NR_pfm_unload_context	334
- 
--#define NR_SYSCALLS		323
-+#define NR_SYSCALLS		335
- 
- #ifdef __KERNEL__
- #define __ARCH_WANT_IPC_PARSE_VERSION
-diff --git a/arch/sparc/kernel/systbls.S b/arch/sparc/kernel/systbls.S
-index e1b9233..727e4e7 100644
---- a/arch/sparc/kernel/systbls.S
-+++ b/arch/sparc/kernel/systbls.S
-@@ -81,4 +81,6 @@ sys_call_table:
- /*305*/	.long sys_set_mempolicy, sys_kexec_load, sys_move_pages, sys_getcpu, sys_epoll_pwait
- /*310*/	.long sys_utimensat, sys_signalfd, sys_timerfd_create, sys_eventfd, sys_fallocate
- /*315*/	.long sys_timerfd_settime, sys_timerfd_gettime, sys_signalfd4, sys_eventfd2, sys_epoll_create1
--/*320*/	.long sys_dup3, sys_pipe2, sys_inotify_init1
-+/*320*/	.long sys_dup3, sys_pipe2, sys_inotify_init1, sys_pfm_create_context, sys_pfm_write_pmcs, sys_pfm_write_pmds
-+/*325*/ .long sys_pfm_write_pmds, sys_pfm_read_pmds, sys_pfm_load_context, sys_pfm_start, sys_pfm_stop
-+/*330*/	.long sys_pfm_restart, sys_pfm_create_evtsets, sys_pfm_getinfo_evtsets, sys_pfm_delete_evtsets, sys_pfm_unload_context
-diff --git a/arch/sparc64/Kconfig b/arch/sparc64/Kconfig
-index 36b4b7a..5555d1e 100644
---- a/arch/sparc64/Kconfig
-+++ b/arch/sparc64/Kconfig
-@@ -401,6 +401,8 @@ source "drivers/sbus/char/Kconfig"
- 
- source "fs/Kconfig"
- 
-+source "arch/sparc64/perfmon/Kconfig"
-+
- source "arch/sparc64/Kconfig.debug"
- 
- source "security/Kconfig"
-diff --git a/arch/sparc64/Makefile b/arch/sparc64/Makefile
-index b785a39..646731c 100644
---- a/arch/sparc64/Makefile
-+++ b/arch/sparc64/Makefile
-@@ -32,6 +32,8 @@ core-y				+= arch/sparc64/math-emu/
- libs-y				+= arch/sparc64/prom/ arch/sparc64/lib/
- drivers-$(CONFIG_OPROFILE)	+= arch/sparc64/oprofile/
- 
-+core-$(CONFIG_PERFMON)		+= arch/sparc64/perfmon/
-+
- boot := arch/sparc64/boot
- 
- image tftpboot.img vmlinux.aout: vmlinux
-diff --git a/arch/sparc64/kernel/cpu.c b/arch/sparc64/kernel/cpu.c
-index 0097c08..f839f84 100644
---- a/arch/sparc64/kernel/cpu.c
-+++ b/arch/sparc64/kernel/cpu.c
-@@ -20,16 +20,17 @@
- DEFINE_PER_CPU(cpuinfo_sparc, __cpu_data) = { 0 };
- 
- struct cpu_iu_info {
--  short manuf;
--  short impl;
--  char* cpu_name;   /* should be enough I hope... */
-+	short manuf;
-+	short impl;
-+	char *cpu_name;
-+	char *pmu_name;
- };
- 
- struct cpu_fp_info {
--  short manuf;
--  short impl;
--  char fpu_vers;
--  char* fp_name;
-+	short manuf;
-+	short impl;
-+	char fpu_vers;
-+	char* fp_name;
- };
- 
- static struct cpu_fp_info linux_sparc_fpu[] = {
-@@ -49,23 +50,24 @@ static struct cpu_fp_info linux_sparc_fpu[] = {
- #define NSPARCFPU  ARRAY_SIZE(linux_sparc_fpu)
- 
- static struct cpu_iu_info linux_sparc_chips[] = {
--  { 0x17, 0x10, "TI UltraSparc I   (SpitFire)"},
--  { 0x22, 0x10, "TI UltraSparc I   (SpitFire)"},
--  { 0x17, 0x11, "TI UltraSparc II  (BlackBird)"},
--  { 0x17, 0x12, "TI UltraSparc IIi (Sabre)"},
--  { 0x17, 0x13, "TI UltraSparc IIe (Hummingbird)"},
--  { 0x3e, 0x14, "TI UltraSparc III (Cheetah)"},
--  { 0x3e, 0x15, "TI UltraSparc III+ (Cheetah+)"},
--  { 0x3e, 0x16, "TI UltraSparc IIIi (Jalapeno)"},
--  { 0x3e, 0x18, "TI UltraSparc IV (Jaguar)"},
--  { 0x3e, 0x19, "TI UltraSparc IV+ (Panther)"},
--  { 0x3e, 0x22, "TI UltraSparc IIIi+ (Serrano)"},
--};
-+   { 0x17, 0x10, "TI UltraSparc I   (SpitFire)",    "ultra12"},
-+   { 0x22, 0x10, "TI UltraSparc I   (SpitFire)",    "ultra12"},
-+   { 0x17, 0x11, "TI UltraSparc II  (BlackBird)",   "ultra12"},
-+   { 0x17, 0x12, "TI UltraSparc IIi (Sabre)",       "ultra12"},
-+   { 0x17, 0x13, "TI UltraSparc IIe (Hummingbird)", "ultra12"},
-+   { 0x3e, 0x14, "TI UltraSparc III (Cheetah)",     "ultra3"},
-+   { 0x3e, 0x15, "TI UltraSparc III+ (Cheetah+)",   "ultra3+"},
-+   { 0x3e, 0x16, "TI UltraSparc IIIi (Jalapeno)",   "ultra3i"},
-+   { 0x3e, 0x18, "TI UltraSparc IV (Jaguar)",       "ultra4"},
-+   { 0x3e, 0x19, "TI UltraSparc IV+ (Panther)",     "ultra4+"},
-+   { 0x3e, 0x22, "TI UltraSparc IIIi+ (Serrano)",   "ultra3+"},
-+ };
- 
- #define NSPARCCHIPS  ARRAY_SIZE(linux_sparc_chips)
- 
- char *sparc_cpu_type;
- char *sparc_fpu_type;
-+char *sparc_pmu_type;
- 
- static void __init sun4v_cpu_probe(void)
- {
-@@ -73,11 +75,13 @@ static void __init sun4v_cpu_probe(void)
- 	case SUN4V_CHIP_NIAGARA1:
- 		sparc_cpu_type = "UltraSparc T1 (Niagara)";
- 		sparc_fpu_type = "UltraSparc T1 integrated FPU";
-+		sparc_pmu_type = "niagara";
- 		break;
- 
- 	case SUN4V_CHIP_NIAGARA2:
- 		sparc_cpu_type = "UltraSparc T2 (Niagara2)";
- 		sparc_fpu_type = "UltraSparc T2 integrated FPU";
-+		sparc_pmu_type = "niagara2";
- 		break;
- 
- 	default:
-@@ -85,6 +89,7 @@ static void __init sun4v_cpu_probe(void)
- 		       prom_cpu_compatible);
- 		sparc_cpu_type = "Unknown SUN4V CPU";
- 		sparc_fpu_type = "Unknown SUN4V FPU";
-+		sparc_pmu_type = "Unknown SUN4V PMU";
- 		break;
- 	}
- }
-@@ -117,6 +122,8 @@ retry:
- 			if (linux_sparc_chips[i].impl == impl) {
- 				sparc_cpu_type =
- 					linux_sparc_chips[i].cpu_name;
-+				sparc_pmu_type =
-+					linux_sparc_chips[i].pmu_name;
- 				break;
- 			}
- 		}
-@@ -134,7 +141,7 @@ retry:
-  			printk("DEBUG: manuf[%lx] impl[%lx]\n",
-  			       manuf, impl);
-  		}
--		sparc_cpu_type = "Unknown CPU";
-+	        sparc_pmu_type = "Unknown PMU";
- 	}
- 
- 	for (i = 0; i < NSPARCFPU; i++) {
-diff --git a/arch/sparc64/kernel/hvcalls.S b/arch/sparc64/kernel/hvcalls.S
-index a2810f3..b9f508c 100644
---- a/arch/sparc64/kernel/hvcalls.S
-+++ b/arch/sparc64/kernel/hvcalls.S
-@@ -884,3 +884,44 @@ sun4v_mmu_demap_all:
- 	retl
- 	 nop
- 	.size	sun4v_mmu_demap_all, .-sun4v_mmu_demap_all
-+
-+	.globl	sun4v_niagara_getperf
-+	.type	sun4v_niagara_getperf,#function
-+sun4v_niagara_getperf:
-+	mov	%o0, %o4
-+	mov	HV_FAST_GET_PERFREG, %o5
-+	ta	HV_FAST_TRAP
-+	stx	%o1, [%o4]
-+	retl
-+	 nop
-+	.size	sun4v_niagara_getperf, .-sun4v_niagara_getperf
-+
-+	.globl	sun4v_niagara_setperf
-+	.type	sun4v_niagara_setperf,#function
-+sun4v_niagara_setperf:
-+	mov	HV_FAST_SET_PERFREG, %o5
-+	ta	HV_FAST_TRAP
-+	retl
-+	 nop
-+	.size	sun4v_niagara_setperf, .-sun4v_niagara_setperf
-+
-+	.globl	sun4v_niagara2_getperf
-+	.type	sun4v_niagara2_getperf,#function
-+sun4v_niagara2_getperf:
-+	mov	%o0, %o4
-+	mov	HV_FAST_N2_GET_PERFREG, %o5
-+	ta	HV_FAST_TRAP
-+	stx	%o1, [%o4]
-+	retl
-+	 nop
-+	.size	sun4v_niagara2_getperf, .-sun4v_niagara2_getperf
-+
-+	.globl	sun4v_niagara2_setperf
-+	.type	sun4v_niagara2_setperf,#function
-+sun4v_niagara2_setperf:
-+	mov	HV_FAST_N2_SET_PERFREG, %o5
-+	ta	HV_FAST_TRAP
-+	retl
-+	 nop
-+	.size	sun4v_niagara2_setperf, .-sun4v_niagara2_setperf
-+
-diff --git a/arch/sparc64/kernel/irq.c b/arch/sparc64/kernel/irq.c
-index 7495bc7..e2bcca5 100644
---- a/arch/sparc64/kernel/irq.c
-+++ b/arch/sparc64/kernel/irq.c
-@@ -749,6 +749,20 @@ void handler_irq(int irq, struct pt_regs *regs)
- 	irq_exit();
- 	set_irq_regs(old_regs);
- }
-+static void unhandled_perf_irq(struct pt_regs *regs)
-+{
-+	unsigned long pcr, pic;
-+
-+	read_pcr(pcr);
-+	read_pic(pic);
-+
-+	write_pcr(0);
-+
-+	printk(KERN_EMERG "CPU %d: Got unexpected perf counter IRQ.\n",
-+	       smp_processor_id());
-+	printk(KERN_EMERG "CPU %d: PCR[%016lx] PIC[%016lx]\n",
-+	       smp_processor_id(), pcr, pic);
-+}
- 
- void do_softirq(void)
- {
-@@ -776,6 +790,55 @@ void do_softirq(void)
- 	local_irq_restore(flags);
- }
- 
-+/* Almost a direct copy of the powerpc PMC code.  */
-+static DEFINE_SPINLOCK(perf_irq_lock);
-+static void *perf_irq_owner_caller; /* mostly for debugging */
-+static void (*perf_irq)(struct pt_regs *regs) = unhandled_perf_irq;
-+
-+/* Invoked from level 15 PIL handler in trap table.  */
-+void perfctr_irq(int irq, struct pt_regs *regs)
-+{
-+	clear_softint(1 << irq);
-+	perf_irq(regs);
-+}
-+
-+int register_perfctr_intr(void (*handler)(struct pt_regs *))
-+{
-+	int ret;
-+
-+	if (!handler)
-+		return -EINVAL;
-+
-+	spin_lock(&perf_irq_lock);
-+	if (perf_irq != unhandled_perf_irq) {
-+		printk(KERN_WARNING "register_perfctr_intr: "
-+		       "perf IRQ busy (reserved by caller %p)\n",
-+		       perf_irq_owner_caller);
-+		ret = -EBUSY;
-+		goto out;
-+	}
-+
-+	perf_irq_owner_caller = __builtin_return_address(0);
-+	perf_irq = handler;
-+
-+	ret = 0;
-+out:
-+	spin_unlock(&perf_irq_lock);
-+
-+	return ret;
-+}
-+EXPORT_SYMBOL_GPL(register_perfctr_intr);
-+
-+void release_perfctr_intr(void (*handler)(struct pt_regs *))
-+{
-+	spin_lock(&perf_irq_lock);
-+	perf_irq_owner_caller = NULL;
-+	perf_irq = unhandled_perf_irq;
-+	spin_unlock(&perf_irq_lock);
-+}
-+EXPORT_SYMBOL_GPL(release_perfctr_intr);
-+
-+
- #ifdef CONFIG_HOTPLUG_CPU
- void fixup_irqs(void)
- {
-diff --git a/arch/sparc64/kernel/process.c b/arch/sparc64/kernel/process.c
-index 15f4178..7282d21 100644
---- a/arch/sparc64/kernel/process.c
-+++ b/arch/sparc64/kernel/process.c
-@@ -30,6 +30,7 @@
- #include <linux/cpu.h>
- #include <linux/elfcore.h>
- #include <linux/sysrq.h>
-+#include <linux/perfmon_kern.h>
- 
- #include <asm/oplib.h>
- #include <asm/uaccess.h>
-@@ -385,11 +386,7 @@ void exit_thread(void)
- 			t->utraps[0]--;
- 	}
- 
--	if (test_and_clear_thread_flag(TIF_PERFCTR)) {
--		t->user_cntd0 = t->user_cntd1 = NULL;
--		t->pcr_reg = 0;
--		write_pcr(0);
--	}
-+	pfm_exit_thread();
- }
- 
- void flush_thread(void)
-@@ -411,13 +408,6 @@ void flush_thread(void)
- 
- 	set_thread_wsaved(0);
- 
--	/* Turn off performance counters if on. */
--	if (test_and_clear_thread_flag(TIF_PERFCTR)) {
--		t->user_cntd0 = t->user_cntd1 = NULL;
--		t->pcr_reg = 0;
--		write_pcr(0);
--	}
--
- 	/* Clear FPU register state. */
- 	t->fpsaved[0] = 0;
- 	
-@@ -631,16 +621,6 @@ int copy_thread(int nr, unsigned long clone_flags, unsigned long sp,
- 		t->kregs->u_regs[UREG_FP] =
- 		  ((unsigned long) child_sf) - STACK_BIAS;
- 
--		/* Special case, if we are spawning a kernel thread from
--		 * a userspace task (usermode helper, NFS or similar), we
--		 * must disable performance counters in the child because
--		 * the address space and protection realm are changing.
--		 */
--		if (t->flags & _TIF_PERFCTR) {
--			t->user_cntd0 = t->user_cntd1 = NULL;
--			t->pcr_reg = 0;
--			t->flags &= ~_TIF_PERFCTR;
--		}
- 		t->flags |= ((long)ASI_P << TI_FLAG_CURRENT_DS_SHIFT);
- 		t->kregs->u_regs[UREG_G6] = (unsigned long) t;
- 		t->kregs->u_regs[UREG_G4] = (unsigned long) t->task;
-@@ -673,6 +653,8 @@ int copy_thread(int nr, unsigned long clone_flags, unsigned long sp,
- 	if (clone_flags & CLONE_SETTLS)
- 		t->kregs->u_regs[UREG_G7] = regs->u_regs[UREG_I3];
- 
-+	pfm_copy_thread(p);
-+
- 	return 0;
- }
- 
-diff --git a/arch/sparc64/kernel/rtrap.S b/arch/sparc64/kernel/rtrap.S
-index 97a993c..c2af29d 100644
---- a/arch/sparc64/kernel/rtrap.S
-+++ b/arch/sparc64/kernel/rtrap.S
-@@ -65,55 +65,14 @@ __handle_user_windows:
- 		ba,pt			%xcc, __handle_user_windows_continue
- 
- 		 andn			%l1, %l4, %l1
--__handle_perfctrs:
--		call			update_perfctrs
--		 wrpr			%g0, RTRAP_PSTATE, %pstate
--		wrpr			%g0, RTRAP_PSTATE_IRQOFF, %pstate
--		ldub			[%g6 + TI_WSAVED], %o2
--		brz,pt			%o2, 1f
--		 nop
--		/* Redo userwin+sched+sig checks */
--		call			fault_in_user_windows
--
--		 wrpr			%g0, RTRAP_PSTATE, %pstate
--		wrpr			%g0, RTRAP_PSTATE_IRQOFF, %pstate
--		ldx			[%g6 + TI_FLAGS], %l0
--		andcc			%l0, _TIF_NEED_RESCHED, %g0
--		be,pt			%xcc, 1f
--
--		 nop
--		call			schedule
--		 wrpr			%g0, RTRAP_PSTATE, %pstate
--		wrpr			%g0, RTRAP_PSTATE_IRQOFF, %pstate
--		ldx			[%g6 + TI_FLAGS], %l0
--1:		andcc			%l0, _TIF_DO_NOTIFY_RESUME_MASK, %g0
--
--		be,pt			%xcc, __handle_perfctrs_continue
--		 sethi			%hi(TSTATE_PEF), %o0
--		mov			%l5, %o1
--		add			%sp, PTREGS_OFF, %o0
--		mov			%l0, %o2
--		call			do_notify_resume
--
--		 wrpr			%g0, RTRAP_PSTATE, %pstate
--		wrpr			%g0, RTRAP_PSTATE_IRQOFF, %pstate
--		/* Signal delivery can modify pt_regs tstate, so we must
--		 * reload it.
--		 */
--		ldx			[%sp + PTREGS_OFF + PT_V9_TSTATE], %l1
--		sethi			%hi(0xf << 20), %l4
--		and			%l1, %l4, %l4
--		andn			%l1, %l4, %l1
--		ba,pt			%xcc, __handle_perfctrs_continue
--
--		 sethi			%hi(TSTATE_PEF), %o0
- __handle_userfpu:
- 		rd			%fprs, %l5
- 		andcc			%l5, FPRS_FEF, %g0
- 		sethi			%hi(TSTATE_PEF), %o0
- 		be,a,pn			%icc, __handle_userfpu_continue
- 		 andn			%l1, %o0, %l1
--		ba,a,pt			%xcc, __handle_userfpu_continue
-+		ba,pt			%xcc, __handle_userfpu_continue
-+		 nop
- 
- __handle_signal:
- 		mov			%l5, %o1
-@@ -202,12 +161,8 @@ __handle_signal_continue:
- 		brnz,pn			%o2, __handle_user_windows
- 		 nop
- __handle_user_windows_continue:
--		ldx			[%g6 + TI_FLAGS], %l5
--		andcc			%l5, _TIF_PERFCTR, %g0
- 		sethi			%hi(TSTATE_PEF), %o0
--		bne,pn			%xcc, __handle_perfctrs
--__handle_perfctrs_continue:
--		 andcc			%l1, %o0, %g0
-+		andcc			%l1, %o0, %g0
- 
- 		/* This fpdepth clear is necessary for non-syscall rtraps only */
- user_nowork:
-diff --git a/arch/sparc64/kernel/setup.c b/arch/sparc64/kernel/setup.c
-index c8b03a4..248aa1f 100644
---- a/arch/sparc64/kernel/setup.c
-+++ b/arch/sparc64/kernel/setup.c
-@@ -352,6 +352,7 @@ static int show_cpuinfo(struct seq_file *m, void *__unused)
- 	seq_printf(m, 
- 		   "cpu\t\t: %s\n"
- 		   "fpu\t\t: %s\n"
-+		   "pmu\t\t: %s\n"
- 		   "prom\t\t: %s\n"
- 		   "type\t\t: %s\n"
- 		   "ncpus probed\t: %d\n"
-@@ -364,6 +365,7 @@ static int show_cpuinfo(struct seq_file *m, void *__unused)
- 		   ,
- 		   sparc_cpu_type,
- 		   sparc_fpu_type,
-+		   sparc_pmu_type,
- 		   prom_version,
- 		   ((tlb_type == hypervisor) ?
- 		    "sun4v" :
-diff --git a/arch/sparc64/kernel/signal.c b/arch/sparc64/kernel/signal.c
-index ec82d76..cea1082 100644
---- a/arch/sparc64/kernel/signal.c
-+++ b/arch/sparc64/kernel/signal.c
-@@ -23,6 +23,7 @@
- #include <linux/tty.h>
- #include <linux/binfmts.h>
- #include <linux/bitops.h>
-+#include <linux/perfmon_kern.h>
- 
- #include <asm/uaccess.h>
- #include <asm/ptrace.h>
-@@ -608,6 +609,9 @@ static void do_signal(struct pt_regs *regs, unsigned long orig_i0)
- 
- void do_notify_resume(struct pt_regs *regs, unsigned long orig_i0, unsigned long thread_info_flags)
- {
-+	if (thread_info_flags & _TIF_PERFMON_WORK)
-+		pfm_handle_work(regs);
-+
- 	if (thread_info_flags & _TIF_SIGPENDING)
- 		do_signal(regs, orig_i0);
- 	if (thread_info_flags & _TIF_NOTIFY_RESUME) {
-diff --git a/arch/sparc64/kernel/sys_sparc.c b/arch/sparc64/kernel/sys_sparc.c
-index 39749e3..384004b 100644
---- a/arch/sparc64/kernel/sys_sparc.c
-+++ b/arch/sparc64/kernel/sys_sparc.c
-@@ -26,7 +26,6 @@
- 
- #include <asm/uaccess.h>
- #include <asm/utrap.h>
--#include <asm/perfctr.h>
- #include <asm/unistd.h>
- 
- #include "entry.h"
-@@ -791,106 +790,10 @@ asmlinkage long sys_rt_sigaction(int sig,
- 	return ret;
- }
- 
--/* Invoked by rtrap code to update performance counters in
-- * user space.
-- */
--asmlinkage void update_perfctrs(void)
--{
--	unsigned long pic, tmp;
--
--	read_pic(pic);
--	tmp = (current_thread_info()->kernel_cntd0 += (unsigned int)pic);
--	__put_user(tmp, current_thread_info()->user_cntd0);
--	tmp = (current_thread_info()->kernel_cntd1 += (pic >> 32));
--	__put_user(tmp, current_thread_info()->user_cntd1);
--	reset_pic();
--}
--
- asmlinkage long sys_perfctr(int opcode, unsigned long arg0, unsigned long arg1, unsigned long arg2)
- {
--	int err = 0;
--
--	switch(opcode) {
--	case PERFCTR_ON:
--		current_thread_info()->pcr_reg = arg2;
--		current_thread_info()->user_cntd0 = (u64 __user *) arg0;
--		current_thread_info()->user_cntd1 = (u64 __user *) arg1;
--		current_thread_info()->kernel_cntd0 =
--			current_thread_info()->kernel_cntd1 = 0;
--		write_pcr(arg2);
--		reset_pic();
--		set_thread_flag(TIF_PERFCTR);
--		break;
--
--	case PERFCTR_OFF:
--		err = -EINVAL;
--		if (test_thread_flag(TIF_PERFCTR)) {
--			current_thread_info()->user_cntd0 =
--				current_thread_info()->user_cntd1 = NULL;
--			current_thread_info()->pcr_reg = 0;
--			write_pcr(0);
--			clear_thread_flag(TIF_PERFCTR);
--			err = 0;
--		}
--		break;
--
--	case PERFCTR_READ: {
--		unsigned long pic, tmp;
--
--		if (!test_thread_flag(TIF_PERFCTR)) {
--			err = -EINVAL;
--			break;
--		}
--		read_pic(pic);
--		tmp = (current_thread_info()->kernel_cntd0 += (unsigned int)pic);
--		err |= __put_user(tmp, current_thread_info()->user_cntd0);
--		tmp = (current_thread_info()->kernel_cntd1 += (pic >> 32));
--		err |= __put_user(tmp, current_thread_info()->user_cntd1);
--		reset_pic();
--		break;
--	}
--
--	case PERFCTR_CLRPIC:
--		if (!test_thread_flag(TIF_PERFCTR)) {
--			err = -EINVAL;
--			break;
--		}
--		current_thread_info()->kernel_cntd0 =
--			current_thread_info()->kernel_cntd1 = 0;
--		reset_pic();
--		break;
--
--	case PERFCTR_SETPCR: {
--		u64 __user *user_pcr = (u64 __user *)arg0;
--
--		if (!test_thread_flag(TIF_PERFCTR)) {
--			err = -EINVAL;
--			break;
--		}
--		err |= __get_user(current_thread_info()->pcr_reg, user_pcr);
--		write_pcr(current_thread_info()->pcr_reg);
--		current_thread_info()->kernel_cntd0 =
--			current_thread_info()->kernel_cntd1 = 0;
--		reset_pic();
--		break;
--	}
--
--	case PERFCTR_GETPCR: {
--		u64 __user *user_pcr = (u64 __user *)arg0;
--
--		if (!test_thread_flag(TIF_PERFCTR)) {
--			err = -EINVAL;
--			break;
--		}
--		err |= __put_user(current_thread_info()->pcr_reg, user_pcr);
--		break;
--	}
--
--	default:
--		err = -EINVAL;
--		break;
--	};
--	return err;
-+	/* Superceded by perfmon2 */
-+	return -ENOSYS;
- }
- 
- /*
-diff --git a/arch/sparc64/kernel/syscalls.S b/arch/sparc64/kernel/syscalls.S
-index a2f2427..b20bf1e 100644
---- a/arch/sparc64/kernel/syscalls.S
-+++ b/arch/sparc64/kernel/syscalls.S
-@@ -117,26 +117,9 @@ ret_from_syscall:
- 	stb	%g0, [%g6 + TI_NEW_CHILD]
- 	ldx	[%g6 + TI_FLAGS], %l0
- 	call	schedule_tail
--	 mov	%g7, %o0
--	andcc	%l0, _TIF_PERFCTR, %g0
--	be,pt	%icc, 1f
--	 nop
--	ldx	[%g6 + TI_PCR], %o7
--	wr	%g0, %o7, %pcr
--
--	/* Blackbird errata workaround.  See commentary in
--	 * smp.c:smp_percpu_timer_interrupt() for more
--	 * information.
--	 */
--	ba,pt	%xcc, 99f
--	 nop
--
--	.align	64
--99:	wr	%g0, %g0, %pic
--	rd	%pic, %g0
--
--1:	ba,pt	%xcc, ret_sys_call
--	 ldx	[%sp + PTREGS_OFF + PT_V9_I0], %o0
-+	mov             %g7, %o0
-+	ba,pt           %xcc, ret_sys_call
-+	ldx	[%sp + PTREGS_OFF + PT_V9_I0], %o0
- 
- 	.globl	sparc_exit
- 	.type	sparc_exit,#function
-diff --git a/arch/sparc64/kernel/systbls.S b/arch/sparc64/kernel/systbls.S
-index 0fdbf3b..1a1a296 100644
---- a/arch/sparc64/kernel/systbls.S
-+++ b/arch/sparc64/kernel/systbls.S
-@@ -82,7 +82,9 @@ sys_call_table32:
- 	.word compat_sys_set_mempolicy, compat_sys_kexec_load, compat_sys_move_pages, sys_getcpu, compat_sys_epoll_pwait
- /*310*/	.word compat_sys_utimensat, compat_sys_signalfd, sys_timerfd_create, sys_eventfd, compat_sys_fallocate
- 	.word compat_sys_timerfd_settime, compat_sys_timerfd_gettime, compat_sys_signalfd4, sys_eventfd2, sys_epoll_create1
--/*320*/	.word sys_dup3, sys_pipe2, sys_inotify_init1
-+/*320*/	.word sys_dup3, sys_pipe2, sys_inotify_init1, sys_pfm_create_context, sys_pfm_write_pmcs
-+	.word sys_pfm_write_pmds, sys_pfm_read_pmds, sys_pfm_load_context, sys_pfm_start, sys_pfm_stop
-+/*330*/	.word sys_pfm_restart, sys_pfm_create_evtsets, sys_pfm_getinfo_evtsets, sys_pfm_delete_evtsets, sys_pfm_unload_context
- 
- #endif /* CONFIG_COMPAT */
- 
-@@ -156,4 +158,6 @@ sys_call_table:
- 	.word sys_set_mempolicy, sys_kexec_load, sys_move_pages, sys_getcpu, sys_epoll_pwait
- /*310*/	.word sys_utimensat, sys_signalfd, sys_timerfd_create, sys_eventfd, sys_fallocate
- 	.word sys_timerfd_settime, sys_timerfd_gettime, sys_signalfd4, sys_eventfd2, sys_epoll_create1
--/*320*/	.word sys_dup3, sys_pipe2, sys_inotify_init1
-+/*320*/	.word sys_dup3, sys_pipe2, sys_inotify_init1, sys_pfm_create_context, sys_pfm_write_pmcs
-+	.word sys_pfm_write_pmds, sys_pfm_read_pmds, sys_pfm_load_context, sys_pfm_start, sys_pfm_stop
-+/*330*/	.word sys_pfm_restart, sys_pfm_create_evtsets, sys_pfm_getinfo_evtsets, sys_pfm_delete_evtsets, sys_pfm_unload_context
-diff --git a/arch/sparc64/kernel/traps.c b/arch/sparc64/kernel/traps.c
-index c824df1..be45d09 100644
---- a/arch/sparc64/kernel/traps.c
-+++ b/arch/sparc64/kernel/traps.c
-@@ -2470,86 +2470,90 @@ extern void tsb_config_offsets_are_bolixed_dave(void);
- /* Only invoked on boot processor. */
- void __init trap_init(void)
- {
--	/* Compile time sanity check. */
--	if (TI_TASK != offsetof(struct thread_info, task) ||
--	    TI_FLAGS != offsetof(struct thread_info, flags) ||
--	    TI_CPU != offsetof(struct thread_info, cpu) ||
--	    TI_FPSAVED != offsetof(struct thread_info, fpsaved) ||
--	    TI_KSP != offsetof(struct thread_info, ksp) ||
--	    TI_FAULT_ADDR != offsetof(struct thread_info, fault_address) ||
--	    TI_KREGS != offsetof(struct thread_info, kregs) ||
--	    TI_UTRAPS != offsetof(struct thread_info, utraps) ||
--	    TI_EXEC_DOMAIN != offsetof(struct thread_info, exec_domain) ||
--	    TI_REG_WINDOW != offsetof(struct thread_info, reg_window) ||
--	    TI_RWIN_SPTRS != offsetof(struct thread_info, rwbuf_stkptrs) ||
--	    TI_GSR != offsetof(struct thread_info, gsr) ||
--	    TI_XFSR != offsetof(struct thread_info, xfsr) ||
--	    TI_USER_CNTD0 != offsetof(struct thread_info, user_cntd0) ||
--	    TI_USER_CNTD1 != offsetof(struct thread_info, user_cntd1) ||
--	    TI_KERN_CNTD0 != offsetof(struct thread_info, kernel_cntd0) ||
--	    TI_KERN_CNTD1 != offsetof(struct thread_info, kernel_cntd1) ||
--	    TI_PCR != offsetof(struct thread_info, pcr_reg) ||
--	    TI_PRE_COUNT != offsetof(struct thread_info, preempt_count) ||
--	    TI_NEW_CHILD != offsetof(struct thread_info, new_child) ||
--	    TI_SYS_NOERROR != offsetof(struct thread_info, syscall_noerror) ||
--	    TI_RESTART_BLOCK != offsetof(struct thread_info, restart_block) ||
--	    TI_KUNA_REGS != offsetof(struct thread_info, kern_una_regs) ||
--	    TI_KUNA_INSN != offsetof(struct thread_info, kern_una_insn) ||
--	    TI_FPREGS != offsetof(struct thread_info, fpregs) ||
--	    (TI_FPREGS & (64 - 1)))
--		thread_info_offsets_are_bolixed_dave();
--
--	if (TRAP_PER_CPU_THREAD != offsetof(struct trap_per_cpu, thread) ||
--	    (TRAP_PER_CPU_PGD_PADDR !=
--	     offsetof(struct trap_per_cpu, pgd_paddr)) ||
--	    (TRAP_PER_CPU_CPU_MONDO_PA !=
--	     offsetof(struct trap_per_cpu, cpu_mondo_pa)) ||
--	    (TRAP_PER_CPU_DEV_MONDO_PA !=
--	     offsetof(struct trap_per_cpu, dev_mondo_pa)) ||
--	    (TRAP_PER_CPU_RESUM_MONDO_PA !=
--	     offsetof(struct trap_per_cpu, resum_mondo_pa)) ||
--	    (TRAP_PER_CPU_RESUM_KBUF_PA !=
--	     offsetof(struct trap_per_cpu, resum_kernel_buf_pa)) ||
--	    (TRAP_PER_CPU_NONRESUM_MONDO_PA !=
--	     offsetof(struct trap_per_cpu, nonresum_mondo_pa)) ||
--	    (TRAP_PER_CPU_NONRESUM_KBUF_PA !=
--	     offsetof(struct trap_per_cpu, nonresum_kernel_buf_pa)) ||
--	    (TRAP_PER_CPU_FAULT_INFO !=
--	     offsetof(struct trap_per_cpu, fault_info)) ||
--	    (TRAP_PER_CPU_CPU_MONDO_BLOCK_PA !=
--	     offsetof(struct trap_per_cpu, cpu_mondo_block_pa)) ||
--	    (TRAP_PER_CPU_CPU_LIST_PA !=
--	     offsetof(struct trap_per_cpu, cpu_list_pa)) ||
--	    (TRAP_PER_CPU_TSB_HUGE !=
--	     offsetof(struct trap_per_cpu, tsb_huge)) ||
--	    (TRAP_PER_CPU_TSB_HUGE_TEMP !=
--	     offsetof(struct trap_per_cpu, tsb_huge_temp)) ||
--	    (TRAP_PER_CPU_IRQ_WORKLIST_PA !=
--	     offsetof(struct trap_per_cpu, irq_worklist_pa)) ||
--	    (TRAP_PER_CPU_CPU_MONDO_QMASK !=
--	     offsetof(struct trap_per_cpu, cpu_mondo_qmask)) ||
--	    (TRAP_PER_CPU_DEV_MONDO_QMASK !=
--	     offsetof(struct trap_per_cpu, dev_mondo_qmask)) ||
--	    (TRAP_PER_CPU_RESUM_QMASK !=
--	     offsetof(struct trap_per_cpu, resum_qmask)) ||
--	    (TRAP_PER_CPU_NONRESUM_QMASK !=
--	     offsetof(struct trap_per_cpu, nonresum_qmask)))
--		trap_per_cpu_offsets_are_bolixed_dave();
--
--	if ((TSB_CONFIG_TSB !=
--	     offsetof(struct tsb_config, tsb)) ||
--	    (TSB_CONFIG_RSS_LIMIT !=
--	     offsetof(struct tsb_config, tsb_rss_limit)) ||
--	    (TSB_CONFIG_NENTRIES !=
--	     offsetof(struct tsb_config, tsb_nentries)) ||
--	    (TSB_CONFIG_REG_VAL !=
--	     offsetof(struct tsb_config, tsb_reg_val)) ||
--	    (TSB_CONFIG_MAP_VADDR !=
--	     offsetof(struct tsb_config, tsb_map_vaddr)) ||
--	    (TSB_CONFIG_MAP_PTE !=
--	     offsetof(struct tsb_config, tsb_map_pte)))
--		tsb_config_offsets_are_bolixed_dave();
--
-+	BUILD_BUG_ON(TI_TASK != offsetof(struct thread_info, task));
-+	BUILD_BUG_ON(TI_FLAGS != offsetof(struct thread_info, flags));
-+	BUILD_BUG_ON(TI_CPU != offsetof(struct thread_info, cpu));
-+	BUILD_BUG_ON(TI_FPSAVED != offsetof(struct thread_info, fpsaved));
-+	BUILD_BUG_ON(TI_KSP != offsetof(struct thread_info, ksp));
-+	BUILD_BUG_ON(TI_FAULT_ADDR !=
-+		     offsetof(struct thread_info, fault_address));
-+	BUILD_BUG_ON(TI_KREGS != offsetof(struct thread_info, kregs));
-+	BUILD_BUG_ON(TI_UTRAPS != offsetof(struct thread_info, utraps));
-+	BUILD_BUG_ON(TI_EXEC_DOMAIN !=
-+		     offsetof(struct thread_info, exec_domain));
-+	BUILD_BUG_ON(TI_REG_WINDOW !=
-+		     offsetof(struct thread_info, reg_window));
-+	BUILD_BUG_ON(TI_RWIN_SPTRS !=
-+		     offsetof(struct thread_info, rwbuf_stkptrs));
-+	BUILD_BUG_ON(TI_GSR != offsetof(struct thread_info, gsr));
-+	BUILD_BUG_ON(TI_XFSR != offsetof(struct thread_info, xfsr));
-+	BUILD_BUG_ON(TI_PRE_COUNT !=
-+		     offsetof(struct thread_info, preempt_count));
-+	BUILD_BUG_ON(TI_NEW_CHILD !=
-+		     offsetof(struct thread_info, new_child));
-+	BUILD_BUG_ON(TI_SYS_NOERROR !=
-+		     offsetof(struct thread_info, syscall_noerror));
-+	BUILD_BUG_ON(TI_RESTART_BLOCK !=
-+		     offsetof(struct thread_info, restart_block));
-+	BUILD_BUG_ON(TI_KUNA_REGS !=
-+		     offsetof(struct thread_info, kern_una_regs));
-+	BUILD_BUG_ON(TI_KUNA_INSN !=
-+		     offsetof(struct thread_info, kern_una_insn));
-+	BUILD_BUG_ON(TI_FPREGS != offsetof(struct thread_info, fpregs));
-+	BUILD_BUG_ON((TI_FPREGS & (64 - 1)));
-+ 
-+	BUILD_BUG_ON(TRAP_PER_CPU_THREAD !=
-+		     offsetof(struct trap_per_cpu, thread));
-+	BUILD_BUG_ON(TRAP_PER_CPU_PGD_PADDR !=
-+		     offsetof(struct trap_per_cpu, pgd_paddr));
-+	BUILD_BUG_ON(TRAP_PER_CPU_CPU_MONDO_PA !=
-+		     offsetof(struct trap_per_cpu, cpu_mondo_pa));
-+	BUILD_BUG_ON(TRAP_PER_CPU_DEV_MONDO_PA !=
-+		     offsetof(struct trap_per_cpu, dev_mondo_pa));
-+	BUILD_BUG_ON(TRAP_PER_CPU_RESUM_MONDO_PA !=
-+		     offsetof(struct trap_per_cpu, resum_mondo_pa));
-+	BUILD_BUG_ON(TRAP_PER_CPU_RESUM_KBUF_PA !=
-+		     offsetof(struct trap_per_cpu, resum_kernel_buf_pa));
-+	BUILD_BUG_ON(TRAP_PER_CPU_NONRESUM_MONDO_PA !=
-+		     offsetof(struct trap_per_cpu, nonresum_mondo_pa));
-+	BUILD_BUG_ON(TRAP_PER_CPU_NONRESUM_KBUF_PA !=
-+		     offsetof(struct trap_per_cpu, nonresum_kernel_buf_pa));
-+	BUILD_BUG_ON(TRAP_PER_CPU_FAULT_INFO !=
-+		     offsetof(struct trap_per_cpu, fault_info));
-+	BUILD_BUG_ON(TRAP_PER_CPU_CPU_MONDO_BLOCK_PA !=
-+		     offsetof(struct trap_per_cpu, cpu_mondo_block_pa));
-+	BUILD_BUG_ON(TRAP_PER_CPU_CPU_LIST_PA !=
-+		     offsetof(struct trap_per_cpu, cpu_list_pa));
-+	BUILD_BUG_ON(TRAP_PER_CPU_TSB_HUGE !=
-+		     offsetof(struct trap_per_cpu, tsb_huge));
-+	BUILD_BUG_ON(TRAP_PER_CPU_TSB_HUGE_TEMP !=
-+		     offsetof(struct trap_per_cpu, tsb_huge_temp));
-+#if 0
-+	BUILD_BUG_ON(TRAP_PER_CPU_IRQ_WORKLIST !=
-+		     offsetof(struct trap_per_cpu, irq_worklist));
-+#endif
-+	BUILD_BUG_ON(TRAP_PER_CPU_CPU_MONDO_QMASK !=
-+		     offsetof(struct trap_per_cpu, cpu_mondo_qmask));
-+	BUILD_BUG_ON(TRAP_PER_CPU_DEV_MONDO_QMASK !=
-+		     offsetof(struct trap_per_cpu, dev_mondo_qmask));
-+	BUILD_BUG_ON(TRAP_PER_CPU_RESUM_QMASK !=
-+		     offsetof(struct trap_per_cpu, resum_qmask));
-+	BUILD_BUG_ON(TRAP_PER_CPU_NONRESUM_QMASK !=
-+		     offsetof(struct trap_per_cpu, nonresum_qmask));
-+ 
-+	BUILD_BUG_ON(TSB_CONFIG_TSB !=
-+		      offsetof(struct tsb_config, tsb));
-+	BUILD_BUG_ON(TSB_CONFIG_RSS_LIMIT !=
-+		     offsetof(struct tsb_config, tsb_rss_limit));
-+	BUILD_BUG_ON(TSB_CONFIG_NENTRIES !=
-+		     offsetof(struct tsb_config, tsb_nentries));
-+	BUILD_BUG_ON(TSB_CONFIG_REG_VAL !=
-+		     offsetof(struct tsb_config, tsb_reg_val));
-+	BUILD_BUG_ON(TSB_CONFIG_MAP_VADDR !=
-+		     offsetof(struct tsb_config, tsb_map_vaddr));
-+	BUILD_BUG_ON(TSB_CONFIG_MAP_PTE !=
-+		     offsetof(struct tsb_config, tsb_map_pte));
-+ 
- 	/* Attach to the address space of init_task.  On SMP we
- 	 * do this in smp.c:smp_callin for other cpus.
- 	 */
-diff --git a/arch/sparc64/kernel/ttable.S b/arch/sparc64/kernel/ttable.S
-index 1ade3d6..2a31ffa 100644
---- a/arch/sparc64/kernel/ttable.S
-+++ b/arch/sparc64/kernel/ttable.S
-@@ -66,7 +66,7 @@ tl0_irq6:	BTRAP(0x46)
- tl0_irq7:	BTRAP(0x47) BTRAP(0x48) BTRAP(0x49)
- tl0_irq10:	BTRAP(0x4a) BTRAP(0x4b) BTRAP(0x4c) BTRAP(0x4d)
- tl0_irq14:	TRAP_IRQ(timer_interrupt, 14)
--tl0_irq15:	TRAP_IRQ(handler_irq, 15)
-+tl0_irq15:	TRAP_IRQ(perfctr_irq, 15)
- tl0_resv050:	BTRAP(0x50) BTRAP(0x51) BTRAP(0x52) BTRAP(0x53) BTRAP(0x54) BTRAP(0x55)
- tl0_resv056:	BTRAP(0x56) BTRAP(0x57) BTRAP(0x58) BTRAP(0x59) BTRAP(0x5a) BTRAP(0x5b)
- tl0_resv05c:	BTRAP(0x5c) BTRAP(0x5d) BTRAP(0x5e) BTRAP(0x5f)
-diff --git a/arch/sparc64/perfmon/Kconfig b/arch/sparc64/perfmon/Kconfig
-new file mode 100644
-index 0000000..4672024
---- /dev/null
-+++ b/arch/sparc64/perfmon/Kconfig
-@@ -0,0 +1,26 @@
-+menu "Hardware Performance Monitoring support"
-+config PERFMON
-+	bool "Perfmon2 performance monitoring interface"
-+	default n
-+	help
-+	Enables the perfmon2 interface to access the hardware
-+	performance counters. See <http://perfmon2.sf.net/> for
-+	more details.
-+
-+config PERFMON_DEBUG
-+	bool "Perfmon debugging"
-+	depends on PERFMON
-+	default n
-+	help
-+	Enables perfmon debugging support
-+
-+config PERFMON_DEBUG_FS
-+	bool "Enable perfmon statistics reporting via debugfs"
-+	default y
-+	depends on PERFMON && DEBUG_FS
-+	help
-+	Enable collection and reporting of perfmon timing statistics under
-+	debugfs. This is used for debugging and performance analysis of the
-+	subsystem. The debugfs filesystem must be mounted.
-+
-+endmenu
-diff --git a/arch/sparc64/perfmon/Makefile b/arch/sparc64/perfmon/Makefile
-new file mode 100644
-index 0000000..ad2d907
---- /dev/null
-+++ b/arch/sparc64/perfmon/Makefile
-@@ -0,0 +1 @@
-+obj-$(CONFIG_PERFMON)	+= perfmon.o
-diff --git a/arch/sparc64/perfmon/perfmon.c b/arch/sparc64/perfmon/perfmon.c
-new file mode 100644
-index 0000000..9e29833
---- /dev/null
-+++ b/arch/sparc64/perfmon/perfmon.c
-@@ -0,0 +1,422 @@
-+/* perfmon.c: sparc64 perfmon support
-+ *
-+ * Copyright (C) 2007 David S. Miller (davem@davemloft.net)
-+ */
-+
-+#include <linux/kernel.h>
-+#include <linux/module.h>
-+#include <linux/irq.h>
-+#include <linux/perfmon_kern.h>
-+
-+#include <asm/system.h>
-+#include <asm/spitfire.h>
-+#include <asm/hypervisor.h>
-+
-+struct pcr_ops {
-+	void (*write)(u64);
-+	u64 (*read)(void);
-+};
-+
-+static void direct_write_pcr(u64 val)
-+{
-+	write_pcr(val);
-+}
-+
-+static u64 direct_read_pcr(void)
-+{
-+	u64 pcr;
-+
-+	read_pcr(pcr);
-+
-+	return pcr;
-+}
-+
-+static struct pcr_ops direct_pcr_ops = {
-+	.write	= direct_write_pcr,
-+	.read	= direct_read_pcr,
-+};
-+
-+/* Using the hypervisor call is needed so that we can set the
-+ * hypervisor trace bit correctly, which is hyperprivileged.
-+ */
-+static void n2_write_pcr(u64 val)
-+{
-+	unsigned long ret;
-+
-+	ret = sun4v_niagara2_setperf(HV_N2_PERF_SPARC_CTL, val);
-+	if (val != HV_EOK)
-+		write_pcr(val);
-+}
-+
-+static u64 n2_read_pcr(void)
-+{
-+	u64 pcr;
-+
-+	read_pcr(pcr);
-+
-+	return pcr;
-+}
-+
-+static struct pcr_ops n2_pcr_ops = {
-+	.write	= n2_write_pcr,
-+	.read	= n2_read_pcr,
-+};
-+
-+static struct pcr_ops *pcr_ops;
-+
-+void pfm_arch_write_pmc(struct pfm_context *ctx,
-+			unsigned int cnum, u64 value)
-+{
-+	/*
-+	 * we only write to the actual register when monitoring is
-+	 * active (pfm_start was issued)
-+	 */
-+	if (ctx && ctx->flags.started == 0)
-+		return;
-+
-+	pcr_ops->write(value);
-+}
-+
-+u64 pfm_arch_read_pmc(struct pfm_context *ctx, unsigned int cnum)
-+{
-+	return pcr_ops->read();
-+}
-+
-+/*
-+ * collect pending overflowed PMDs. Called from pfm_ctxsw()
-+ * and from PMU interrupt handler. Must fill in set->povfl_pmds[]
-+ * and set->npend_ovfls. Interrupts are masked
-+ */
-+static void __pfm_get_ovfl_pmds(struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	unsigned int max = ctx->regs.max_intr_pmd;
-+	u64 wmask = 1ULL << pfm_pmu_conf->counter_width;
-+	u64 *intr_pmds = ctx->regs.intr_pmds;
-+	u64 *used_mask = set->used_pmds;
-+	u64 mask[PFM_PMD_BV];
-+	unsigned int i;
-+
-+	bitmap_and(cast_ulp(mask),
-+		   cast_ulp(intr_pmds),
-+		   cast_ulp(used_mask),
-+		   max);
-+
-+	/*
-+	 * check all PMD that can generate interrupts
-+	 * (that includes counters)
-+	 */
-+	for (i = 0; i < max; i++) {
-+		if (test_bit(i, mask)) {
-+			u64 new_val = pfm_arch_read_pmd(ctx, i);
-+
-+			PFM_DBG_ovfl("pmd%u new_val=0x%llx bit=%d\n",
-+				     i, (unsigned long long)new_val,
-+				     (new_val&wmask) ? 1 : 0);
-+
-+			if (new_val & wmask) {
-+				__set_bit(i, set->povfl_pmds);
-+				set->npend_ovfls++;
-+			}
-+		}
-+	}
-+}
-+
-+static void pfm_stop_active(struct task_struct *task, struct pfm_context *ctx,
-+			    struct pfm_event_set *set)
-+{
-+	unsigned int i, max = ctx->regs.max_pmc;
-+
-+	/*
-+	 * clear enable bits, assume all pmcs are enable pmcs
-+	 */
-+	for (i = 0; i < max; i++) {
-+		if (test_bit(i, set->used_pmcs))
-+			pfm_arch_write_pmc(ctx, i, 0);
-+	}
-+
-+	if (set->npend_ovfls)
-+		return;
-+
-+	__pfm_get_ovfl_pmds(ctx, set);
-+}
-+
-+/*
-+ * Called from pfm_ctxsw(). Task is guaranteed to be current.
-+ * Context is locked. Interrupts are masked. Monitoring is active.
-+ * PMU access is guaranteed. PMC and PMD registers are live in PMU.
-+ *
-+ * for per-thread:
-+ * 	must stop monitoring for the task
-+ *
-+ * Return:
-+ * 	non-zero : did not save PMDs (as part of stopping the PMU)
-+ * 	       0 : saved PMDs (no need to save them in caller)
-+ */
-+int pfm_arch_ctxswout_thread(struct task_struct *task, struct pfm_context *ctx)
-+{
-+	/*
-+	 * disable lazy restore of PMC registers.
-+	 */
-+	ctx->active_set->priv_flags |= PFM_SETFL_PRIV_MOD_PMCS;
-+
-+	pfm_stop_active(task, ctx, ctx->active_set);
-+
-+	return 1;
-+}
-+
-+/*
-+ * Called from pfm_stop() and idle notifier
-+ *
-+ * Interrupts are masked. Context is locked. Set is the active set.
-+ *
-+ * For per-thread:
-+ *   task is not necessarily current. If not current task, then
-+ *   task is guaranteed stopped and off any cpu. Access to PMU
-+ *   is not guaranteed. Interrupts are masked. Context is locked.
-+ *   Set is the active set.
-+ *
-+ * For system-wide:
-+ * 	task is current
-+ *
-+ * must disable active monitoring. ctx cannot be NULL
-+ */
-+void pfm_arch_stop(struct task_struct *task, struct pfm_context *ctx)
-+{
-+	/*
-+	 * no need to go through stop_save()
-+	 * if we are already stopped
-+	 */
-+	if (!ctx->flags.started || ctx->state == PFM_CTX_MASKED)
-+		return;
-+
-+	/*
-+	 * stop live registers and collect pending overflow
-+	 */
-+	if (task == current)
-+		pfm_stop_active(task, ctx, ctx->active_set);
-+}
-+
-+/*
-+ * Enable active monitoring. Called from pfm_start() and
-+ * pfm_arch_unmask_monitoring().
-+ *
-+ * Interrupts are masked. Context is locked. Set is the active set.
-+ *
-+ * For per-trhead:
-+ * 	Task is not necessarily current. If not current task, then task
-+ * 	is guaranteed stopped and off any cpu. Access to PMU is not guaranteed.
-+ *
-+ * For system-wide:
-+ * 	task is always current
-+ *
-+ * must enable active monitoring.
-+ */
-+void pfm_arch_start(struct task_struct *task, struct pfm_context *ctx)
-+{
-+	struct pfm_event_set *set;
-+	unsigned int max_pmc = ctx->regs.max_pmc;
-+	unsigned int i;
-+
-+	if (task != current)
-+		return;
-+
-+	set = ctx->active_set;
-+	for (i = 0; i < max_pmc; i++) {
-+		if (test_bit(i, set->used_pmcs))
-+			pfm_arch_write_pmc(ctx, i, set->pmcs[i]);
-+	}
-+}
-+
-+/*
-+ * function called from pfm_switch_sets(), pfm_context_load_thread(),
-+ * pfm_context_load_sys(), pfm_ctxsw(), pfm_switch_sets()
-+ * context is locked. Interrupts are masked. set cannot be NULL.
-+ * Access to the PMU is guaranteed.
-+ *
-+ * function must restore all PMD registers from set.
-+ */
-+void pfm_arch_restore_pmds(struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	unsigned int max_pmd = ctx->regs.max_pmd;
-+	u64 ovfl_mask = pfm_pmu_conf->ovfl_mask;
-+	u64 *impl_pmds = ctx->regs.pmds;
-+	unsigned int i;
-+
-+	/*
-+	 * must restore all pmds to avoid leaking
-+	 * information to user.
-+	 */
-+	for (i = 0; i < max_pmd; i++) {
-+		u64 val;
-+
-+		if (test_bit(i, impl_pmds) == 0)
-+			continue;
-+
-+		val = set->pmds[i].value;
-+
-+		/*
-+		 * set upper bits for counter to ensure
-+		 * overflow will trigger
-+		 */
-+		val &= ovfl_mask;
-+
-+		pfm_arch_write_pmd(ctx, i, val);
-+	}
-+}
-+
-+/*
-+ * function called from pfm_switch_sets(), pfm_context_load_thread(),
-+ * pfm_context_load_sys(), pfm_ctxsw().
-+ * Context is locked. Interrupts are masked. set cannot be NULL.
-+ * Access to the PMU is guaranteed.
-+ *
-+ * function must restore all PMC registers from set, if needed.
-+ */
-+void pfm_arch_restore_pmcs(struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	unsigned int max_pmc = ctx->regs.max_pmc;
-+	u64 *impl_pmcs = ctx->regs.pmcs;
-+	unsigned int i;
-+
-+	/* If we're masked or stopped we don't need to bother restoring
-+	 * the PMCs now.
-+	 */
-+	if (ctx->state == PFM_CTX_MASKED || ctx->flags.started == 0)
-+		return;
-+
-+	/*
-+	 * restore all pmcs
-+	 */
-+	for (i = 0; i < max_pmc; i++)
-+		if (test_bit(i, impl_pmcs))
-+			pfm_arch_write_pmc(ctx, i, set->pmcs[i]);
-+}
-+
-+char *pfm_arch_get_pmu_module_name(void)
-+{
-+	return NULL;
-+}
-+
-+void perfmon_interrupt(struct pt_regs *regs)
-+{
-+	pfm_interrupt_handler(instruction_pointer(regs), regs);
-+}
-+
-+static struct pfm_regmap_desc pfm_sparc64_pmc_desc[] = {
-+	PMC_D(PFM_REG_I, "PCR", 0, 0, 0, 0),
-+};
-+
-+static struct pfm_regmap_desc pfm_sparc64_pmd_desc[] = {
-+	PMD_D(PFM_REG_C, "PIC0", 0),
-+	PMD_D(PFM_REG_C, "PIC1", 0),
-+};
-+
-+static int pfm_sparc64_probe(void)
-+{
-+	return 0;
-+}
-+
-+static struct pfm_pmu_config pmu_sparc64_pmu_conf = {
-+	.counter_width	= 31,
-+	.pmd_desc	= pfm_sparc64_pmd_desc,
-+	.num_pmd_entries = 2,
-+	.pmc_desc	= pfm_sparc64_pmc_desc,
-+	.num_pmc_entries = 1,
-+	.probe_pmu	= pfm_sparc64_probe,
-+	.flags		= PFM_PMU_BUILTIN_FLAG,
-+	.owner		= THIS_MODULE,
-+};
-+
-+static unsigned long perf_hsvc_group;
-+static unsigned long perf_hsvc_major;
-+static unsigned long perf_hsvc_minor;
-+
-+static int __init register_perf_hsvc(void)
-+{
-+	if (tlb_type == hypervisor) {
-+		switch (sun4v_chip_type) {
-+		case SUN4V_CHIP_NIAGARA1:
-+			perf_hsvc_group = HV_GRP_N2_CPU;
-+			break;
-+
-+		case SUN4V_CHIP_NIAGARA2:
-+			perf_hsvc_group = HV_GRP_N2_CPU;
-+			break;
-+
-+		default:
-+			return -ENODEV;
-+		}
-+
-+
-+		perf_hsvc_major = 1;
-+		perf_hsvc_minor = 0;
-+		if (sun4v_hvapi_register(perf_hsvc_group,
-+					 perf_hsvc_major,
-+					 &perf_hsvc_minor)) {
-+			printk("perfmon: Could not register N2 hvapi.\n");
-+			return -ENODEV;
-+		}
-+	}
-+	return 0;
-+}
-+
-+static void unregister_perf_hsvc(void)
-+{
-+	if (tlb_type != hypervisor)
-+		return;
-+	sun4v_hvapi_unregister(perf_hsvc_group);
-+}
-+
-+static int __init pfm_sparc64_pmu_init(void)
-+{
-+	u64 mask;
-+	int err;
-+
-+	err = register_perf_hsvc();
-+	if (err)
-+		return err;
-+
-+	if (tlb_type == hypervisor &&
-+	    sun4v_chip_type == SUN4V_CHIP_NIAGARA2)
-+		pcr_ops = &n2_pcr_ops;
-+	else
-+		pcr_ops = &direct_pcr_ops;
-+
-+	if (!strcmp(sparc_pmu_type, "ultra12"))
-+		mask = (0xf << 11) | (0xf << 4) | 0x7;
-+	else if (!strcmp(sparc_pmu_type, "ultra3") ||
-+		 !strcmp(sparc_pmu_type, "ultra3i") ||
-+		 !strcmp(sparc_pmu_type, "ultra3+") ||
-+		 !strcmp(sparc_pmu_type, "ultra4+"))
-+		mask = (0x3f << 11) | (0x3f << 4) | 0x7;
-+	else if (!strcmp(sparc_pmu_type, "niagara2"))
-+		mask = ((1UL << 63) | (1UL << 62) |
-+			(1UL << 31) | (0xfUL << 27) | (0xffUL << 19) |
-+			(1UL << 18) | (0xfUL << 14) | (0xff << 6) |
-+			(0x3UL << 4) | 0x7UL);
-+	else if (!strcmp(sparc_pmu_type, "niagara"))
-+		mask = ((1UL << 9) | (1UL << 8) |
-+			(0x7UL << 4) | 0x7UL);
-+	else {
-+		err = -ENODEV;
-+		goto out_err;
-+	}
-+
-+	pmu_sparc64_pmu_conf.pmu_name = sparc_pmu_type;
-+	pfm_sparc64_pmc_desc[0].rsvd_msk = ~mask;
-+
-+	return pfm_pmu_register(&pmu_sparc64_pmu_conf);
-+
-+out_err:
-+	unregister_perf_hsvc();
-+	return err;
-+}
-+
-+static void __exit pfm_sparc64_pmu_exit(void)
-+{
-+	unregister_perf_hsvc();
-+	return pfm_pmu_unregister(&pmu_sparc64_pmu_conf);
-+}
-+
-+module_init(pfm_sparc64_pmu_init);
-+module_exit(pfm_sparc64_pmu_exit);
-diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
-index ed92864..3a2b544 100644
---- a/arch/x86/Kconfig
-+++ b/arch/x86/Kconfig
-@@ -1378,6 +1378,8 @@ config COMPAT_VDSO
- 
- 	  If unsure, say Y.
- 
-+source "arch/x86/perfmon/Kconfig"
-+
- endmenu
- 
- config ARCH_ENABLE_MEMORY_HOTPLUG
-diff --git a/arch/x86/Makefile b/arch/x86/Makefile
-index f5631da..c868ad6 100644
---- a/arch/x86/Makefile
-+++ b/arch/x86/Makefile
-@@ -150,6 +150,8 @@ core-$(CONFIG_LGUEST_GUEST) += arch/x86/lguest/
- core-y += arch/x86/kernel/
- core-y += arch/x86/mm/
- 
-+core-$(CONFIG_PERFMON) += arch/x86/perfmon/
-+
- # Remaining sub architecture files
- core-y += $(mcore-y)
- 
-diff --git a/arch/x86/ia32/ia32entry.S b/arch/x86/ia32/ia32entry.S
-index ffc1bb4..58e00cb 100644
---- a/arch/x86/ia32/ia32entry.S
-+++ b/arch/x86/ia32/ia32entry.S
-@@ -832,4 +832,16 @@ ia32_sys_call_table:
- 	.quad sys_dup3			/* 330 */
- 	.quad sys_pipe2
- 	.quad sys_inotify_init1
-+	.quad sys_pfm_create_context
-+	.quad sys_pfm_write_pmcs
-+	.quad sys_pfm_write_pmds	/* 335 */
-+	.quad sys_pfm_read_pmds
-+	.quad sys_pfm_load_context
-+	.quad sys_pfm_start
-+	.quad sys_pfm_stop
-+	.quad sys_pfm_restart		/* 340 */
-+	.quad sys_pfm_create_evtsets
-+	.quad sys_pfm_getinfo_evtsets
-+	.quad sys_pfm_delete_evtsets
-+	.quad sys_pfm_unload_context
- ia32_syscall_end:
-diff --git a/arch/x86/kernel/apic_32.c b/arch/x86/kernel/apic_32.c
-index f88bd0d..53fe335 100644
---- a/arch/x86/kernel/apic_32.c
-+++ b/arch/x86/kernel/apic_32.c
-@@ -28,6 +28,7 @@
- #include <linux/acpi_pmtmr.h>
- #include <linux/module.h>
- #include <linux/dmi.h>
-+#include <linux/perfmon_kern.h>
- 
- #include <asm/atomic.h>
- #include <asm/smp.h>
-@@ -669,6 +670,7 @@ u8 setup_APIC_eilvt_ibs(u8 vector, u8 msg_type, u8 mask)
- 	setup_APIC_eilvt(APIC_EILVT_LVTOFF_IBS, vector, msg_type, mask);
- 	return APIC_EILVT_LVTOFF_IBS;
- }
-+EXPORT_SYMBOL(setup_APIC_eilvt_ibs);
- 
- /*
-  * Local APIC start and shutdown
-@@ -1367,6 +1369,9 @@ void __init apic_intr_init(void)
- #ifdef CONFIG_X86_MCE_P4THERMAL
- 	alloc_intr_gate(THERMAL_APIC_VECTOR, thermal_interrupt);
- #endif
-+#ifdef CONFIG_PERFMON
-+	set_intr_gate(LOCAL_PERFMON_VECTOR, pmu_interrupt);
-+#endif
- }
- 
- /**
-diff --git a/arch/x86/kernel/apic_64.c b/arch/x86/kernel/apic_64.c
-index 446c062..574cd3b 100644
---- a/arch/x86/kernel/apic_64.c
-+++ b/arch/x86/kernel/apic_64.c
-@@ -228,6 +228,7 @@ u8 setup_APIC_eilvt_ibs(u8 vector, u8 msg_type, u8 mask)
- 	setup_APIC_eilvt(APIC_EILVT_LVTOFF_IBS, vector, msg_type, mask);
- 	return APIC_EILVT_LVTOFF_IBS;
- }
-+EXPORT_SYMBOL(setup_APIC_eilvt_ibs);
- 
- /*
-  * Program the next event, relative to now
-diff --git a/arch/x86/kernel/cpu/common.c b/arch/x86/kernel/cpu/common.c
-index 4e456bd..5b6d6ca 100644
---- a/arch/x86/kernel/cpu/common.c
-+++ b/arch/x86/kernel/cpu/common.c
-@@ -5,6 +5,7 @@
- #include <linux/module.h>
- #include <linux/percpu.h>
- #include <linux/bootmem.h>
-+#include <linux/perfmon_kern.h>
- #include <asm/processor.h>
- #include <asm/i387.h>
- #include <asm/msr.h>
-@@ -726,6 +727,8 @@ void __cpuinit cpu_init(void)
- 	current_thread_info()->status = 0;
- 	clear_used_math();
- 	mxcsr_feature_mask_init();
-+
-+	pfm_init_percpu();
- }
- 
- #ifdef CONFIG_HOTPLUG_CPU
-diff --git a/arch/x86/kernel/entry_32.S b/arch/x86/kernel/entry_32.S
-index 109792b..0b6e34c 100644
---- a/arch/x86/kernel/entry_32.S
-+++ b/arch/x86/kernel/entry_32.S
-@@ -513,7 +513,7 @@ ENDPROC(system_call)
- 	ALIGN
- 	RING0_PTREGS_FRAME		# can't unwind into user space anyway
- work_pending:
--	testb $_TIF_NEED_RESCHED, %cl
-+	testw $(_TIF_NEED_RESCHED|_TIF_PERFMON_WORK), %cx
- 	jz work_notifysig
- work_resched:
- 	call schedule
-diff --git a/arch/x86/kernel/entry_64.S b/arch/x86/kernel/entry_64.S
-index 89434d4..34e44f5 100644
---- a/arch/x86/kernel/entry_64.S
-+++ b/arch/x86/kernel/entry_64.S
-@@ -888,7 +888,13 @@ END(error_interrupt)
- ENTRY(spurious_interrupt)
- 	apicinterrupt SPURIOUS_APIC_VECTOR,smp_spurious_interrupt
- END(spurious_interrupt)
--				
-+
-+#ifdef CONFIG_PERFMON
-+ENTRY(pmu_interrupt)
-+	apicinterrupt LOCAL_PERFMON_VECTOR,smp_pmu_interrupt
-+END(pmu_interrupt)
-+#endif
-+
- /*
-  * Exception entry points.
-  */ 		
-diff --git a/arch/x86/kernel/irqinit_64.c b/arch/x86/kernel/irqinit_64.c
-index 1f26fd9..83f6bc1 100644
---- a/arch/x86/kernel/irqinit_64.c
-+++ b/arch/x86/kernel/irqinit_64.c
-@@ -11,6 +11,7 @@
- #include <linux/kernel_stat.h>
- #include <linux/sysdev.h>
- #include <linux/bitops.h>
-+#include <linux/perfmon_kern.h>
- 
- #include <asm/acpi.h>
- #include <asm/atomic.h>
-@@ -217,6 +218,10 @@ void __init native_init_IRQ(void)
- 	alloc_intr_gate(SPURIOUS_APIC_VECTOR, spurious_interrupt);
- 	alloc_intr_gate(ERROR_APIC_VECTOR, error_interrupt);
- 
-+#ifdef CONFIG_PERFMON
-+	alloc_intr_gate(LOCAL_PERFMON_VECTOR, pmu_interrupt);
-+#endif
-+
- 	if (!acpi_ioapic)
- 		setup_irq(2, &irq2);
- }
-diff --git a/arch/x86/kernel/process_32.c b/arch/x86/kernel/process_32.c
-index 31f40b2..ed27150 100644
---- a/arch/x86/kernel/process_32.c
-+++ b/arch/x86/kernel/process_32.c
-@@ -36,6 +36,7 @@
- #include <linux/personality.h>
- #include <linux/tick.h>
- #include <linux/percpu.h>
-+#include <linux/perfmon_kern.h>
- #include <linux/prctl.h>
- 
- #include <asm/uaccess.h>
-@@ -277,6 +278,7 @@ void exit_thread(void)
- 		tss->x86_tss.io_bitmap_base = INVALID_IO_BITMAP_OFFSET;
- 		put_cpu();
- 	}
-+	pfm_exit_thread();
- }
- 
- void flush_thread(void)
-@@ -334,6 +336,8 @@ int copy_thread(int nr, unsigned long clone_flags, unsigned long sp,
- 
- 	savesegment(gs, p->thread.gs);
- 
-+	pfm_copy_thread(p);
-+
- 	tsk = current;
- 	if (unlikely(test_tsk_thread_flag(tsk, TIF_IO_BITMAP))) {
- 		p->thread.io_bitmap_ptr = kmemdup(tsk->thread.io_bitmap_ptr,
-@@ -448,6 +452,9 @@ __switch_to_xtra(struct task_struct *prev_p, struct task_struct *next_p,
- 	prev = &prev_p->thread;
- 	next = &next_p->thread;
- 
-+	if (test_tsk_thread_flag(prev_p, TIF_PERFMON_CTXSW))
-+		pfm_ctxsw_out(prev_p, next_p);
-+
- 	debugctl = prev->debugctlmsr;
- 	if (next->ds_area_msr != prev->ds_area_msr) {
- 		/* we clear debugctl to make sure DS
-@@ -460,6 +467,9 @@ __switch_to_xtra(struct task_struct *prev_p, struct task_struct *next_p,
- 	if (next->debugctlmsr != debugctl)
- 		update_debugctlmsr(next->debugctlmsr);
- 
-+	if (test_tsk_thread_flag(next_p, TIF_PERFMON_CTXSW))
-+		pfm_ctxsw_in(prev_p, next_p);
-+
- 	if (test_tsk_thread_flag(next_p, TIF_DEBUG)) {
- 		set_debugreg(next->debugreg0, 0);
- 		set_debugreg(next->debugreg1, 1);
-diff --git a/arch/x86/kernel/process_64.c b/arch/x86/kernel/process_64.c
-index e12e0e4..97d49ce 100644
---- a/arch/x86/kernel/process_64.c
-+++ b/arch/x86/kernel/process_64.c
-@@ -36,6 +36,7 @@
- #include <linux/kprobes.h>
- #include <linux/kdebug.h>
- #include <linux/tick.h>
-+#include <linux/perfmon_kern.h>
- #include <linux/prctl.h>
- 
- #include <asm/uaccess.h>
-@@ -240,6 +241,7 @@ void exit_thread(void)
- 		t->io_bitmap_max = 0;
- 		put_cpu();
- 	}
-+	pfm_exit_thread();
- }
- 
- void flush_thread(void)
-@@ -344,6 +346,8 @@ int copy_thread(int nr, unsigned long clone_flags, unsigned long sp,
- 	savesegment(es, p->thread.es);
- 	savesegment(ds, p->thread.ds);
- 
-+	pfm_copy_thread(p);
-+
- 	if (unlikely(test_tsk_thread_flag(me, TIF_IO_BITMAP))) {
- 		p->thread.io_bitmap_ptr = kmalloc(IO_BITMAP_BYTES, GFP_KERNEL);
- 		if (!p->thread.io_bitmap_ptr) {
-@@ -472,6 +476,9 @@ static inline void __switch_to_xtra(struct task_struct *prev_p,
- 	prev = &prev_p->thread,
- 	next = &next_p->thread;
- 
-+	if (test_tsk_thread_flag(prev_p, TIF_PERFMON_CTXSW))
-+		pfm_ctxsw_out(prev_p, next_p);
-+
- 	debugctl = prev->debugctlmsr;
- 	if (next->ds_area_msr != prev->ds_area_msr) {
- 		/* we clear debugctl to make sure DS
-@@ -484,6 +491,9 @@ static inline void __switch_to_xtra(struct task_struct *prev_p,
- 	if (next->debugctlmsr != debugctl)
- 		update_debugctlmsr(next->debugctlmsr);
- 
-+	if (test_tsk_thread_flag(next_p, TIF_PERFMON_CTXSW))
-+		pfm_ctxsw_in(prev_p, next_p);
-+
- 	if (test_tsk_thread_flag(next_p, TIF_DEBUG)) {
- 		loaddebug(next, 0);
- 		loaddebug(next, 1);
-diff --git a/arch/x86/kernel/signal_32.c b/arch/x86/kernel/signal_32.c
-index 6fb5bcd..53e6665 100644
---- a/arch/x86/kernel/signal_32.c
-+++ b/arch/x86/kernel/signal_32.c
-@@ -18,6 +18,7 @@
- #include <linux/sched.h>
- #include <linux/wait.h>
- #include <linux/elf.h>
-+#include <linux/perfmon_kern.h>
- #include <linux/smp.h>
- #include <linux/mm.h>
- 
-@@ -657,6 +658,10 @@ static void do_signal(struct pt_regs *regs)
- void
- do_notify_resume(struct pt_regs *regs, void *unused, __u32 thread_info_flags)
- {
-+	/* process perfmon asynchronous work (e.g. block thread or reset) */
-+	if (thread_info_flags & _TIF_PERFMON_WORK)
-+		pfm_handle_work(regs);
-+
- 	/* deal with pending signal delivery */
- 	if (thread_info_flags & _TIF_SIGPENDING)
- 		do_signal(regs);
-diff --git a/arch/x86/kernel/signal_64.c b/arch/x86/kernel/signal_64.c
-index ca316b5..6e9fa74 100644
---- a/arch/x86/kernel/signal_64.c
-+++ b/arch/x86/kernel/signal_64.c
-@@ -19,6 +19,7 @@
- #include <linux/stddef.h>
- #include <linux/personality.h>
- #include <linux/compiler.h>
-+#include <linux/perfmon_kern.h>
- #include <asm/processor.h>
- #include <asm/ucontext.h>
- #include <asm/uaccess.h>
-@@ -549,12 +550,17 @@ static void do_signal(struct pt_regs *regs)
- void do_notify_resume(struct pt_regs *regs, void *unused,
- 		      __u32 thread_info_flags)
- {
-+
- #ifdef CONFIG_X86_MCE
- 	/* notify userspace of pending MCEs */
- 	if (thread_info_flags & _TIF_MCE_NOTIFY)
- 		mce_notify_user();
- #endif /* CONFIG_X86_MCE */
- 
-+	/* process perfmon asynchronous work (e.g. block thread or reset) */
-+	if (thread_info_flags & _TIF_PERFMON_WORK)
-+		pfm_handle_work(regs);
-+
- 	/* deal with pending signal delivery */
- 	if (thread_info_flags & _TIF_SIGPENDING)
- 		do_signal(regs);
-diff --git a/arch/x86/kernel/smpboot.c b/arch/x86/kernel/smpboot.c
-index 7985c5b..9ddf6db 100644
---- a/arch/x86/kernel/smpboot.c
-+++ b/arch/x86/kernel/smpboot.c
-@@ -42,6 +42,7 @@
- #include <linux/init.h>
- #include <linux/smp.h>
- #include <linux/module.h>
-+#include <linux/perfmon_kern.h>
- #include <linux/sched.h>
- #include <linux/percpu.h>
- #include <linux/bootmem.h>
-@@ -1382,6 +1383,7 @@ int __cpu_disable(void)
- 	remove_cpu_from_maps(cpu);
- 	unlock_vector_lock();
- 	fixup_irqs(cpu_online_map);
-+	pfm_cpu_disable();
- 	return 0;
- }
- 
-diff --git a/arch/x86/kernel/syscall_table_32.S b/arch/x86/kernel/syscall_table_32.S
-index d44395f..e1384a9 100644
---- a/arch/x86/kernel/syscall_table_32.S
-+++ b/arch/x86/kernel/syscall_table_32.S
-@@ -332,3 +332,15 @@ ENTRY(sys_call_table)
- 	.long sys_dup3			/* 330 */
- 	.long sys_pipe2
- 	.long sys_inotify_init1
-+	.long sys_pfm_create_context
-+	.long sys_pfm_write_pmcs
-+	.long sys_pfm_write_pmds	/* 335 */
-+	.long sys_pfm_read_pmds
-+	.long sys_pfm_load_context
-+	.long sys_pfm_start
-+	.long sys_pfm_stop
-+	.long sys_pfm_restart		/* 340 */
-+	.long sys_pfm_create_evtsets
-+	.long sys_pfm_getinfo_evtsets
-+	.long sys_pfm_delete_evtsets
-+	.long sys_pfm_unload_context
-diff --git a/arch/x86/oprofile/nmi_int.c b/arch/x86/oprofile/nmi_int.c
-index 8a5f161..10faef5 100644
---- a/arch/x86/oprofile/nmi_int.c
-+++ b/arch/x86/oprofile/nmi_int.c
-@@ -16,6 +16,7 @@
- #include <linux/moduleparam.h>
- #include <linux/kdebug.h>
- #include <linux/cpu.h>
-+#include <linux/perfmon_kern.h>
- #include <asm/nmi.h>
- #include <asm/msr.h>
- #include <asm/apic.h>
-@@ -217,12 +218,18 @@ static int nmi_setup(void)
- 	int err = 0;
- 	int cpu;
- 
--	if (!allocate_msrs())
-+	if (pfm_session_allcpus_acquire())
-+		return -EBUSY;
-+
-+	if (!allocate_msrs()) {
-+		pfm_session_allcpus_release();
- 		return -ENOMEM;
-+	}
- 
- 	err = register_die_notifier(&profile_exceptions_nb);
- 	if (err) {
- 		free_msrs();
-+		pfm_session_allcpus_release();
- 		return err;
- 	}
- 
-@@ -304,6 +311,7 @@ static void nmi_shutdown(void)
- 	model->shutdown(msrs);
- 	free_msrs();
- 	put_cpu_var(cpu_msrs);
-+	pfm_session_allcpus_release();
- }
- 
- static void nmi_cpu_start(void *dummy)
-diff --git a/arch/x86/perfmon/Kconfig b/arch/x86/perfmon/Kconfig
-new file mode 100644
-index 0000000..08842e6
---- /dev/null
-+++ b/arch/x86/perfmon/Kconfig
-@@ -0,0 +1,89 @@
-+menu "Hardware Performance Monitoring support"
-+config PERFMON
-+	bool "Perfmon2 performance monitoring interface"
-+	select X86_LOCAL_APIC
-+	default n
-+	help
-+	Enables the perfmon2 interface to access the hardware
-+	performance counters. See <http://perfmon2.sf.net/> for
-+	more details.
-+
-+config PERFMON_DEBUG
-+	bool "Perfmon debugging"
-+	default n
-+	depends on PERFMON
-+	help
-+	Enables perfmon debugging support
-+
-+config PERFMON_DEBUG_FS
-+	bool "Enable perfmon statistics reporting via debugfs"
-+	default y
-+	depends on PERFMON && DEBUG_FS
-+	help
-+	Enable collection and reporting of perfmon timing statistics under
-+	debugfs. This is used for debugging and performance analysis of the
-+	subsystem.The debugfs filesystem must be mounted.
-+
-+config X86_PERFMON_P6
-+	tristate "Support for Intel P6/Pentium M processor hardware performance counters"
-+	depends on PERFMON && X86_32
-+	default n
-+	help
-+	Enables support for Intel P6-style hardware performance counters.
-+	To be used for with Intel Pentium III, PentiumPro, Pentium M processors.
-+
-+config X86_PERFMON_P4
-+	tristate "Support for Intel Pentium 4/Xeon hardware performance counters"
-+	depends on PERFMON
-+	default n
-+	help
-+	Enables support for Intel Pentium 4/Xeon (Netburst) hardware performance
-+	counters.
-+
-+config	X86_PERFMON_PEBS_P4
-+	tristate "Support for Intel Netburst Precise Event-Based Sampling (PEBS)"
-+	depends on PERFMON && X86_PERFMON_P4
-+	default n
-+	help
-+	Enables support for Precise Event-Based Sampling (PEBS) on the Intel
-+	Netburst processors such as Pentium 4, Xeon which support it.
-+
-+config  X86_PERFMON_CORE
-+	tristate "Support for Intel Core-based performance counters"
-+	depends on PERFMON
-+	default n
-+	help
-+	Enables support for Intel Core-based performance counters. Enable
-+	this option to support Intel Core 2 processors.
-+
-+config	X86_PERFMON_PEBS_CORE
-+	tristate "Support for Intel Core Precise Event-Based Sampling (PEBS)"
-+	depends on PERFMON && X86_PERFMON_CORE
-+	default n
-+	help
-+	Enables support for Precise Event-Based Sampling (PEBS) on the Intel
-+	Core processors.
-+
-+config  X86_PERFMON_INTEL_ATOM
-+	tristate "Support for Intel Atom processor"
-+	depends on PERFMON
-+	default n
-+	help
-+	Enables support for Intel Atom processors.
-+
-+config  X86_PERFMON_INTEL_ARCH
-+	tristate "Support for Intel architectural perfmon v1/v2"
-+	depends on PERFMON
-+	default n
-+	help
-+	Enables support for Intel architectural performance counters.
-+	This feature was introduced with Intel Core Solo/Core Duo processors.
-+
-+config	X86_PERFMON_AMD64
-+	tristate "Support AMD Athlon64/Opteron64 hardware performance counters"
-+	depends on PERFMON
-+	default n
-+	help
-+	Enables support for Athlon64/Opterton64 hardware performance counters.
-+	Support for family 6, 15 and 16(10H) processors.
-+endmenu
-diff --git a/arch/x86/perfmon/Makefile b/arch/x86/perfmon/Makefile
-new file mode 100644
-index 0000000..1cbed3e
---- /dev/null
-+++ b/arch/x86/perfmon/Makefile
-@@ -0,0 +1,13 @@
-+#
-+# Copyright (c) 2005-2007 Hewlett-Packard Development Company, L.P.
-+# Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+#
-+obj-$(CONFIG_PERFMON)			+= perfmon.o
-+obj-$(CONFIG_X86_PERFMON_P6)		+= perfmon_p6.o
-+obj-$(CONFIG_X86_PERFMON_P4)		+= perfmon_p4.o
-+obj-$(CONFIG_X86_PERFMON_CORE)		+= perfmon_intel_core.o
-+obj-$(CONFIG_X86_PERFMON_INTEL_ARCH)	+= perfmon_intel_arch.o
-+obj-$(CONFIG_X86_PERFMON_PEBS_P4)	+= perfmon_pebs_p4_smpl.o
-+obj-$(CONFIG_X86_PERFMON_PEBS_CORE)	+= perfmon_pebs_core_smpl.o
-+obj-$(CONFIG_X86_PERFMON_AMD64)   	+= perfmon_amd64.o
-+obj-$(CONFIG_X86_PERFMON_INTEL_ATOM)	+= perfmon_intel_atom.o
-diff --git a/arch/x86/perfmon/perfmon.c b/arch/x86/perfmon/perfmon.c
-new file mode 100644
-index 0000000..e727fed
---- /dev/null
-+++ b/arch/x86/perfmon/perfmon.c
-@@ -0,0 +1,761 @@
-+/*
-+ * This file implements the X86 specific support for the perfmon2 interface
-+ *
-+ * Copyright (c) 2005-2007 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * Copyright (c) 2007 Advanced Micro Devices, Inc.
-+ * Contributed by Robert Richter <robert.richter@amd.com>
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/interrupt.h>
-+#include <linux/perfmon_kern.h>
-+#include <linux/kprobes.h>
-+#include <linux/kdebug.h>
-+#include <linux/nmi.h>
-+
-+#include <asm/apic.h>
-+
-+DEFINE_PER_CPU(unsigned long, real_iip);
-+DEFINE_PER_CPU(int, pfm_using_nmi);
-+DEFINE_PER_CPU(unsigned long, saved_lvtpc);
-+
-+/**
-+ * pfm_arch_ctxswin_thread - thread context switch in
-+ * @task: task switched in
-+ * @ctx: context for the task
-+ *
-+ * Called from pfm_ctxsw(). Task is guaranteed to be current.
-+ * set cannot be NULL. Context is locked. Interrupts are masked.
-+ *
-+ * Caller has already restored all PMD and PMC registers, if
-+ * necessary (i.e., lazy restore scheme).
-+ *
-+ * On x86, the only common code just needs to unsecure RDPMC if necessary
-+ *
-+ * On model-specific features, e.g., PEBS, IBS, are taken care of in the
-+ * corresponding PMU description module
-+ */
-+void pfm_arch_ctxswin_thread(struct task_struct *task, struct pfm_context *ctx)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+
-+	/*
-+	 *  restore saved real iip
-+	 */
-+	if (ctx->active_set->npend_ovfls)
-+		__get_cpu_var(real_iip) = ctx_arch->saved_real_iip;
-+
-+	/*
-+	 * enable RDPMC on this CPU
-+	 */
-+	if (ctx_arch->flags.insecure)
-+		set_in_cr4(X86_CR4_PCE);
-+}
-+
-+/**
-+ * pfm_arch_ctxswout_thread - context switch out thread
-+ * @task: task switched out
-+ * @ctx : context switched out
-+ *
-+ * Called from pfm_ctxsw(). Task is guaranteed to be current.
-+ * Context is locked. Interrupts are masked. Monitoring may be active.
-+ * PMU access is guaranteed. PMC and PMD registers are live in PMU.
-+ *
-+ * Return:
-+ * 	non-zero : did not save PMDs (as part of stopping the PMU)
-+ * 	       0 : saved PMDs (no need to save them in caller)
-+ */
-+int pfm_arch_ctxswout_thread(struct task_struct *task, struct pfm_context *ctx)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+	struct pfm_arch_pmu_info *pmu_info;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+	pmu_info = pfm_pmu_info();
-+
-+	/*
-+	 * disable lazy restore of PMCS on ctxswin because
-+	 * we modify some of them.
-+	 */
-+	ctx->active_set->priv_flags |= PFM_SETFL_PRIV_MOD_PMCS;
-+
-+	if (ctx->active_set->npend_ovfls)
-+		ctx_arch->saved_real_iip = __get_cpu_var(real_iip);
-+
-+	/*
-+	 * disable RDPMC on this CPU
-+	 */
-+	if (ctx_arch->flags.insecure)
-+		clear_in_cr4(X86_CR4_PCE);
-+
-+	if (ctx->state == PFM_CTX_MASKED)
-+		return 1;
-+
-+	return pmu_info->stop_save(ctx, ctx->active_set);
-+}
-+
-+/**
-+ * pfm_arch_stop - deactivate monitoring
-+ * @task: task to stop
-+ * @ctx: context to stop
-+ *
-+ * Called from pfm_stop()
-+ * Interrupts are masked. Context is locked. Set is the active set.
-+ *
-+ * For per-thread:
-+ *   task is not necessarily current. If not current task, then
-+ *   task is guaranteed stopped and off any cpu. Access to PMU
-+ *   is not guaranteed.
-+ *
-+ * For system-wide:
-+ * 	task is current
-+ *
-+ * must disable active monitoring. ctx cannot be NULL
-+ */
-+void pfm_arch_stop(struct task_struct *task, struct pfm_context *ctx)
-+{
-+	struct pfm_arch_pmu_info *pmu_info;
-+
-+	pmu_info = pfm_pmu_info();
-+
-+	/*
-+	 * no need to go through stop_save()
-+	 * if we are already stopped
-+	 */
-+	if (!ctx->flags.started || ctx->state == PFM_CTX_MASKED)
-+		return;
-+
-+	if (task != current)
-+		return;
-+
-+	pmu_info->stop_save(ctx, ctx->active_set);
-+}
-+
-+
-+/**
-+ * pfm_arch_start - activate monitoring
-+ * @task: task to start
-+ * @ctx: context to stop
-+ *
-+ * Interrupts are masked. Context is locked.
-+ *
-+ * For per-thread:
-+ * 	Task is not necessarily current. If not current task, then task
-+ * 	is guaranteed stopped and off any cpu. No access to PMU is task
-+ *	is not current.
-+ *
-+ * For system-wide:
-+ * 	task is always current
-+ */
-+void pfm_arch_start(struct task_struct *task, struct pfm_context *ctx)
-+{
-+	struct pfm_event_set *set;
-+
-+	set = ctx->active_set;
-+
-+	if (task != current)
-+		return;
-+
-+	/*
-+	 * cannot restore PMC if no access to PMU. Will be done
-+	 * when the thread is switched back in
-+	 */
-+
-+	pfm_arch_restore_pmcs(ctx, set);
-+}
-+
-+/**
-+ * pfm_arch_restore_pmds - reload PMD registers
-+ * @ctx: context to restore from
-+ * @set: current event set
-+ *
-+ * function called from pfm_switch_sets(), pfm_context_load_thread(),
-+ * pfm_context_load_sys(), pfm_ctxsw()
-+ *
-+ * Context is locked. Interrupts are masked. Set cannot be NULL.
-+ * Access to the PMU is guaranteed.
-+ */
-+void pfm_arch_restore_pmds(struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	struct pfm_arch_pmu_info *pmu_info;
-+	u16 i, num;
-+
-+	pmu_info = pfm_pmu_info();
-+
-+	num = set->nused_pmds;
-+
-+	/*
-+	 * model-specific override
-+	 */
-+	if (pmu_info->restore_pmds) {
-+		pmu_info->restore_pmds(ctx, set);
-+		return;
-+	}
-+
-+	/*
-+	 * we can restore only the PMD we use because:
-+	 *
-+	 * 	- can only read with pfm_read_pmds() the registers
-+	 * 	  declared used via pfm_write_pmds(), smpl_pmds, reset_pmds
-+	 *
-+	 * 	- if cr4.pce=1, only counters are exposed to user. RDPMC
-+	 * 	  does not work with other types of PMU registers.Thus, no
-+	 * 	  address is ever exposed by counters
-+	 *
-+	 * 	- there is never a dependency between one pmd register and
-+	 * 	  another
-+	 */
-+	for (i = 0; num; i++) {
-+		if (likely(test_bit(i, cast_ulp(set->used_pmds)))) {
-+			pfm_write_pmd(ctx, i, set->pmds[i].value);
-+			num--;
-+		}
-+	}
-+}
-+
-+/**
-+ * pfm_arch_restore_pmcs - reload PMC registers
-+ * @ctx: context to restore from
-+ * @set: current event set
-+ *
-+ * function called from pfm_switch_sets(), pfm_context_load_thread(),
-+ * pfm_context_load_sys(), pfm_ctxsw().
-+ *
-+ * Context is locked. Interrupts are masked. set cannot be NULL.
-+ * Access to the PMU is guaranteed.
-+ *
-+ * function must restore all PMC registers from set
-+ */
-+void pfm_arch_restore_pmcs(struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	struct pfm_arch_pmu_info *pmu_info;
-+	u64 *mask;
-+	u16 i, num;
-+
-+	pmu_info = pfm_pmu_info();
-+
-+	/*
-+	 * we need to restore PMCs only when:
-+	 * 	- context is not masked
-+	 * 	- monitoring activated
-+	 *
-+	 * Masking monitoring after an overflow does not change the
-+	 * value of flags.started
-+	 */
-+	if (ctx->state == PFM_CTX_MASKED || !ctx->flags.started)
-+		return;
-+
-+	/*
-+	 * model-specific override
-+	 */
-+	if (pmu_info->restore_pmcs) {
-+		pmu_info->restore_pmcs(ctx, set);
-+		return;
-+	}
-+	/*
-+	 * restore all pmcs
-+	 *
-+	 * It is not possible to restore only the pmcs we used because
-+	 * certain PMU models (e.g. Pentium 4) have dependencies. Thus
-+	 * we do not want one application using stale PMC coming from
-+	 * another one.
-+	 *
-+	 * On PMU models where there is no dependencies between pmc, then
-+	 * it is possible to optimize by only restoring the registers that
-+	 * are used, and this can be done with the models-specific override
-+	 * for this function.
-+	 *
-+	 * The default code takes the safest approach, i.e., assume the worse
-+	 */
-+	mask = ctx->regs.pmcs;
-+	num = ctx->regs.num_pmcs;
-+	for (i = 0; num; i++) {
-+		if (test_bit(i, cast_ulp(mask))) {
-+			pfm_arch_write_pmc(ctx, i, set->pmcs[i]);
-+			num--;
-+		}
-+	}
-+}
-+
-+/**
-+ * smp_pmu_interrupt - lowest level PMU interrupt handler for X86
-+ * @regs: machine state
-+ *
-+ * The PMU interrupt is handled through an interrupt gate, therefore
-+ * the CPU automatically clears the EFLAGS.IF, i.e., masking interrupts.
-+ *
-+ * The perfmon interrupt handler MUST run with interrupts disabled due
-+ * to possible race with other, higher priority interrupts, such as timer
-+ * or IPI function calls.
-+ *
-+ * See description in IA-32 architecture manual, Vol 3 section 5.8.1
-+ */
-+void smp_pmu_interrupt(struct pt_regs *regs)
-+{
-+	struct pfm_arch_pmu_info *pmu_info;
-+	struct pfm_context *ctx;
-+	unsigned long iip;
-+	int using_nmi;
-+
-+	using_nmi = __get_cpu_var(pfm_using_nmi);
-+
-+	ack_APIC_irq();
-+
-+	irq_enter();
-+
-+	/*
-+	 * when using NMI, pfm_handle_nmi() gets called
-+	 * first. It stops monitoring and record the
-+	 * iip into real_iip, then it repost the interrupt
-+	 * using the lower priority vector LOCAL_PERFMON_VECTOR
-+	 *
-+	 * On some processors, e.g., P4, it may be that some
-+	 * state is already recorded from pfm_handle_nmi()
-+	 * and it only needs to be copied back into the normal
-+	 * fields so it can be used transparently by higher level
-+	 * code.
-+	 */
-+	if (using_nmi) {
-+		ctx = __get_cpu_var(pmu_ctx);
-+		pmu_info = pfm_pmu_info();
-+		iip = __get_cpu_var(real_iip);
-+		if (ctx && pmu_info->nmi_copy_state)
-+			pmu_info->nmi_copy_state(ctx);
-+	} else
-+		iip = instruction_pointer(regs);
-+
-+	pfm_interrupt_handler(iip, regs);
-+
-+	/*
-+	 * On Intel P6, Pentium M, P4, Intel Core:
-+	 * 	- it is necessary to clear the MASK field for the LVTPC
-+	 * 	  vector. Otherwise interrupts remain masked. See
-+	 * 	  section 8.5.1
-+	 * AMD X86-64:
-+	 * 	- the documentation does not stipulate the behavior.
-+	 * 	  To be safe, we also rewrite the vector to clear the
-+	 * 	  mask field
-+	 */
-+	if (!using_nmi && current_cpu_data.x86_vendor == X86_VENDOR_INTEL)
-+		apic_write(APIC_LVTPC, LOCAL_PERFMON_VECTOR);
-+
-+	irq_exit();
-+}
-+
-+/**
-+ * pfm_handle_nmi - PMU NMI handler notifier callback
-+ * @nb ; notifier block
-+ * @val: type of die notifier
-+ * @data: die notifier-specific data
-+ *
-+ * called from notify_die() notifier from an trap handler path. We only
-+ * care about NMI related callbacks, and ignore everything else.
-+ *
-+ * Cannot grab any locks, include the perfmon context lock
-+ *
-+ * Must detect if NMI interrupt comes from perfmon, and if so it must
-+ * stop the PMU and repost a lower-priority interrupt. The perfmon interrupt
-+ * handler needs to grab the context lock, thus is cannot be run directly
-+ * from the NMI interrupt call path.
-+ */
-+static int __kprobes pfm_handle_nmi(struct notifier_block *nb,
-+				    unsigned long val,
-+				    void *data)
-+{
-+	struct die_args *args = data;
-+	struct pfm_context *ctx;
-+	struct pfm_arch_pmu_info *pmu_info;
-+
-+	/*
-+	 * only NMI related calls
-+	 */
-+	if (val != DIE_NMI_IPI)
-+		return NOTIFY_DONE;
-+
-+	/*
-+	 * perfmon not using NMI
-+	 */
-+	if (!__get_cpu_var(pfm_using_nmi))
-+		return NOTIFY_DONE;
-+
-+	/*
-+	 * No context
-+	 */
-+	ctx = __get_cpu_var(pmu_ctx);
-+	if (!ctx) {
-+		PFM_DBG_ovfl("no ctx");
-+		return NOTIFY_DONE;
-+	}
-+
-+	/*
-+	 * Detect if we have overflows, i.e., NMI interrupt
-+	 * caused by PMU
-+	 */
-+	pmu_info = pfm_pmu_conf->pmu_info;
-+	if (!pmu_info->has_ovfls(ctx)) {
-+		PFM_DBG_ovfl("no ovfl");
-+		return NOTIFY_DONE;
-+	}
-+
-+	/*
-+	 * we stop the PMU to avoid further overflow before this
-+	 * one is treated by lower priority interrupt handler
-+	 */
-+	pmu_info->quiesce();
-+
-+	/*
-+	 * record actual instruction pointer
-+	 */
-+	__get_cpu_var(real_iip) = instruction_pointer(args->regs);
-+
-+	/*
-+	 * post lower priority interrupt (LOCAL_PERFMON_VECTOR)
-+	 */
-+	pfm_arch_resend_irq(ctx);
-+
-+	pfm_stats_inc(ovfl_intr_nmi_count);
-+
-+	/*
-+	 * we need to rewrite the APIC vector on Intel
-+	 */
-+	if (current_cpu_data.x86_vendor == X86_VENDOR_INTEL)
-+		apic_write(APIC_LVTPC, APIC_DM_NMI);
-+
-+	/*
-+	 * the notification was for us
-+	 */
-+	return NOTIFY_STOP;
-+}
-+
-+static struct notifier_block pfm_nmi_nb = {
-+	.notifier_call = pfm_handle_nmi
-+};
-+
-+/**
-+ * pfm_arch_get_pmu_module_name - get PMU description module name for autoload
-+ *
-+ * called from pfm_pmu_request_module
-+ */
-+char *pfm_arch_get_pmu_module_name(void)
-+{
-+	switch (current_cpu_data.x86) {
-+	case 6:
-+		switch (current_cpu_data.x86_model) {
-+		case 3: /* Pentium II */
-+		case 7 ... 11:
-+		case 13:
-+			return "perfmon_p6";
-+		case 15: /* Merom */
-+		case 23: /* Penryn */
-+			return "perfmon_intel_core";
-+		case 28: /* Atom/Silverthorne */
-+			return "perfmon_intel_atom";
-+		case 29: /* Dunnington */
-+			return "perfmon_intel_core";
-+		default:
-+			goto try_arch;
-+		}
-+	case 15:
-+	case 16:
-+		/* All Opteron processors */
-+		if (current_cpu_data.x86_vendor == X86_VENDOR_AMD)
-+			return "perfmon_amd64";
-+
-+		switch (current_cpu_data.x86_model) {
-+		case 0 ... 6:
-+			return "perfmon_p4";
-+		}
-+		/* FALL THROUGH */
-+	default:
-+try_arch:
-+		if (boot_cpu_has(X86_FEATURE_ARCH_PERFMON))
-+			return "perfmon_intel_arch";
-+		return NULL;
-+	}
-+	return NULL;
-+}
-+
-+/**
-+ * pfm_arch_resend_irq - post perfmon interrupt on regular vector
-+ *
-+ * called from pfm_ctxswin_thread() and pfm_handle_nmi()
-+ */
-+void pfm_arch_resend_irq(struct pfm_context *ctx)
-+{
-+	unsigned long val, dest;
-+	/*
-+	 * we cannot use hw_resend_irq() because it goes to
-+	 * the I/O APIC. We need to go to the Local APIC.
-+	 *
-+	 * The "int vec" is not the right solution either
-+	 * because it triggers a software intr. We need
-+	 * to regenerate the interrupt and have it pended
-+	 * until we unmask interrupts.
-+	 *
-+	 * Instead we send ourself an IPI on the perfmon
-+	 * vector.
-+	 */
-+	val  = APIC_DEST_SELF|APIC_INT_ASSERT|
-+	       APIC_DM_FIXED|LOCAL_PERFMON_VECTOR;
-+
-+	dest = apic_read(APIC_ID);
-+	apic_write(APIC_ICR2, dest);
-+	apic_write(APIC_ICR, val);
-+}
-+
-+/**
-+ * pfm_arch_pmu_acquire_percpu - setup APIC per CPU
-+ * @data: contains pmu flags
-+ */
-+static void pfm_arch_pmu_acquire_percpu(void *data)
-+{
-+
-+	struct pfm_arch_pmu_info *pmu_info;
-+	unsigned int tmp, vec;
-+	unsigned long flags = (unsigned long)data;
-+	unsigned long lvtpc;
-+
-+	pmu_info = pfm_pmu_conf->pmu_info;
-+
-+	/*
-+	 * we only reprogram the LVTPC vector if we have detected
-+	 * no sharing, otherwise it means the APIC is already programmed
-+	 * and we use whatever vector (likely NMI) is there
-+	 */
-+	if (!(flags & PFM_X86_FL_SHARING)) {
-+		if (flags & PFM_X86_FL_USE_NMI)
-+			vec = APIC_DM_NMI;
-+		else
-+			vec = LOCAL_PERFMON_VECTOR;
-+
-+		tmp = apic_read(APIC_LVTERR);
-+		apic_write(APIC_LVTERR, tmp | APIC_LVT_MASKED);
-+		apic_write(APIC_LVTPC, vec);
-+		apic_write(APIC_LVTERR, tmp);
-+	}
-+	lvtpc = (unsigned long)apic_read(APIC_LVTPC);
-+
-+	__get_cpu_var(pfm_using_nmi) = lvtpc == APIC_DM_NMI;
-+
-+	PFM_DBG("LTVPC=0x%lx using_nmi=%d", lvtpc, __get_cpu_var(pfm_using_nmi));
-+
-+	/*
-+	 * invoke model specific acquire routine. May be used for
-+	 * model-specific initializations
-+	 */
-+	if (pmu_info->acquire_pmu_percpu)
-+		pmu_info->acquire_pmu_percpu();
-+}
-+
-+/**
-+ * pfm_arch_pmu_acquire - acquire PMU resource from system
-+ * @unavail_pmcs : bitmask to use to set unavailable pmcs
-+ * @unavail_pmds : bitmask to use to set unavailable pmds
-+ *
-+ * interrupts are not masked
-+ *
-+ * Grab PMU registers from lower level MSR allocator
-+ *
-+ * Program the APIC according the possible interrupt vector
-+ * either LOCAL_PERFMON_VECTOR or NMI
-+ */
-+int pfm_arch_pmu_acquire(u64 *unavail_pmcs, u64 *unavail_pmds)
-+{
-+	struct pfm_arch_pmu_info *pmu_info;
-+	struct pfm_regmap_desc *d;
-+	u16 i, nlost;
-+
-+	pmu_info = pfm_pmu_conf->pmu_info;
-+	pmu_info->flags &= ~PFM_X86_FL_SHARING;
-+
-+	nlost = 0;
-+
-+	d = pfm_pmu_conf->pmc_desc;
-+	for (i = 0; i < pfm_pmu_conf->num_pmc_entries;  i++, d++) {
-+		if (!(d->type & PFM_REG_I))
-+			continue;
-+
-+		if (d->type & PFM_REG_V)
-+			continue;
-+		/*
-+		 * reserve register with lower-level allocator
-+		 */
-+		if (!reserve_evntsel_nmi(d->hw_addr)) {
-+			PFM_DBG("pmc%d(%s) already used", i, d->desc);
-+			__set_bit(i, cast_ulp(unavail_pmcs));
-+			nlost++;
-+			continue;
-+		}
-+	}
-+	PFM_DBG("nlost=%d info_flags=0x%x\n", nlost, pmu_info->flags);
-+	/*
-+	 * some PMU models (e.g., P6) do not support sharing
-+	 * so check if we found less than the expected number of PMC registers
-+	 */
-+	if (nlost) {
-+		if (pmu_info->flags & PFM_X86_FL_NO_SHARING) {
-+			PFM_INFO("PMU already used by another subsystem, "
-+				 "PMU does not support sharing, "
-+				 "try disabling Oprofile or "
-+				 "reboot with nmi_watchdog=0");
-+			goto undo;
-+		}
-+		pmu_info->flags |= PFM_X86_FL_SHARING;
-+	}
-+
-+	d = pfm_pmu_conf->pmd_desc;
-+	for (i = 0; i < pfm_pmu_conf->num_pmd_entries;  i++, d++) {
-+		if (!(d->type & PFM_REG_I))
-+			continue;
-+
-+		if (d->type & PFM_REG_V)
-+			continue;
-+
-+		if (!reserve_perfctr_nmi(d->hw_addr)) {
-+			PFM_DBG("pmd%d(%s) already used", i, d->desc);
-+			__set_bit(i, cast_ulp(unavail_pmds));
-+		}
-+	}
-+	/*
-+	 * program APIC on each CPU
-+	 */
-+	on_each_cpu(pfm_arch_pmu_acquire_percpu,
-+		    (void *)(unsigned long)pmu_info->flags , 1);
-+
-+	return 0;
-+undo:
-+	/*
-+	 * must undo reservation of pmcs in case of error
-+	 */
-+	d = pfm_pmu_conf->pmc_desc;
-+	for (i = 0; i < pfm_pmu_conf->num_pmc_entries;  i++, d++) {
-+		if (!(d->type & (PFM_REG_I|PFM_REG_V)))
-+			continue;
-+		if (!test_bit(i, cast_ulp(unavail_pmcs)))
-+			release_evntsel_nmi(d->hw_addr);
-+	}
-+	return -EBUSY;
-+}
-+/**
-+ * pfm-arch_pmu_release_percpu - clear NMI state for one CPU
-+ *
-+ */
-+static void pfm_arch_pmu_release_percpu(void *data)
-+{
-+	struct pfm_arch_pmu_info *pmu_info;
-+
-+	pmu_info = pfm_pmu_conf->pmu_info;
-+
-+	__get_cpu_var(pfm_using_nmi) = 0;
-+
-+	/*
-+	 * invoke model specific release routine.
-+	 * May be used to undo certain initializations
-+	 * or free some model-specific ressources.
-+	 */
-+	if (pmu_info->release_pmu_percpu)
-+		pmu_info->release_pmu_percpu();
-+}
-+
-+/**
-+ * pfm_arch_pmu_release - release PMU resource to system
-+ *
-+ * called from pfm_pmu_release()
-+ * interrupts are not masked
-+ *
-+ * On x86, we return the PMU registers to the MSR allocator
-+ */
-+void pfm_arch_pmu_release(void)
-+{
-+	struct pfm_regmap_desc *d;
-+	u16 i, n;
-+
-+	d = pfm_pmu_conf->pmc_desc;
-+	n = pfm_pmu_conf->regs_all.num_pmcs;
-+	for (i = 0; n; i++, d++) {
-+		if (!test_bit(i, cast_ulp(pfm_pmu_conf->regs_all.pmcs)))
-+			continue;
-+		release_evntsel_nmi(d->hw_addr);
-+		n--;
-+		PFM_DBG("pmc%u released", i);
-+	}
-+	d = pfm_pmu_conf->pmd_desc;
-+	n = pfm_pmu_conf->regs_all.num_pmds;
-+	for (i = 0; n; i++, d++) {
-+		if (!test_bit(i, cast_ulp(pfm_pmu_conf->regs_all.pmds)))
-+			continue;
-+		release_perfctr_nmi(d->hw_addr);
-+		n--;
-+		PFM_DBG("pmd%u released", i);
-+	}
-+
-+	/* clear NMI variable if used */
-+	if (__get_cpu_var(pfm_using_nmi))
-+		on_each_cpu(pfm_arch_pmu_release_percpu, NULL , 1);
-+}
-+
-+/**
-+ * pfm_arch_pmu_config_init - validate PMU description structure
-+ * @cfg: PMU description structure
-+ *
-+ * return:
-+ * 	0 if valid
-+ * 	errno otherwise
-+ *
-+ * called from pfm_pmu_register()
-+ */
-+int pfm_arch_pmu_config_init(struct pfm_pmu_config *cfg)
-+{
-+	struct pfm_arch_pmu_info *pmu_info;
-+
-+	pmu_info = pfm_pmu_info();
-+	if (!pmu_info) {
-+		PFM_DBG("%s missing pmu_info", cfg->pmu_name);
-+		return -EINVAL;
-+	}
-+	if (!pmu_info->has_ovfls) {
-+		PFM_DBG("%s missing has_ovfls callback", cfg->pmu_name);
-+		return -EINVAL;
-+	}
-+	if (!pmu_info->quiesce) {
-+		PFM_DBG("%s missing quiesce callback", cfg->pmu_name);
-+		return -EINVAL;
-+	}
-+	if (!pmu_info->stop_save) {
-+		PFM_DBG("%s missing stop_save callback", cfg->pmu_name);
-+		return -EINVAL;
-+	}
-+	return 0;
-+}
-+
-+/**
-+ * pfm_arch_init - one time global arch-specific initialization
-+ *
-+ * called from pfm_init()
-+ */
-+int __init pfm_arch_init(void)
-+{
-+	/*
-+	 * we need to register our NMI handler when the kernels boots
-+	 * to avoid a deadlock condition with the NMI watchdog or Oprofile
-+	 * if we were to try and register/unregister on-demand.
-+	 */
-+	register_die_notifier(&pfm_nmi_nb);
-+	return 0;
-+}
-diff --git a/arch/x86/perfmon/perfmon_amd64.c b/arch/x86/perfmon/perfmon_amd64.c
-new file mode 100644
-index 0000000..f9b5f9c
---- /dev/null
-+++ b/arch/x86/perfmon/perfmon_amd64.c
-@@ -0,0 +1,754 @@
-+/*
-+ * This file contains the PMU description for the Athlon64 and Opteron64
-+ * processors. It supports 32 and 64-bit modes.
-+ *
-+ * Copyright (c) 2005-2007 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * Copyright (c) 2007 Advanced Micro Devices, Inc.
-+ * Contributed by Robert Richter <robert.richter@amd.com>
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+  */
-+#include <linux/module.h>
-+#include <linux/vmalloc.h>
-+#include <linux/topology.h>
-+#include <linux/kprobes.h>
-+#include <linux/pci.h>
-+#include <linux/perfmon_kern.h>
-+#include <asm/hw_irq.h>
-+#include <asm/apic.h>
-+
-+MODULE_AUTHOR("Stephane Eranian <eranian@hpl.hp.com>");
-+MODULE_AUTHOR("Robert Richter <robert.richter@amd.com>");
-+MODULE_DESCRIPTION("AMD64 PMU description table");
-+MODULE_LICENSE("GPL");
-+
-+#define PCI_DEVICE_ID_AMD_10H_NB_MISC	0x1203
-+
-+static int force_nmi;
-+MODULE_PARM_DESC(force_nmi, "bool: force use of NMI for PMU interrupt");
-+module_param(force_nmi, bool, 0600);
-+
-+#define HAS_IBS		0x01	/* has IBS  support */
-+
-+static	u8  ibs_eilvt_off, ibs_status;	/* AMD: extended interrupt LVT offset */
-+
-+static void pfm_amd64_restore_pmcs(struct pfm_context *ctx,
-+				   struct pfm_event_set *set);
-+static void __kprobes pfm_amd64_quiesce(void);
-+static int pfm_amd64_has_ovfls(struct pfm_context *ctx);
-+static int pfm_amd64_stop_save(struct pfm_context *ctx,
-+			       struct pfm_event_set *set);
-+
-+#define IBSFETCHCTL_PMC	4 /* pmc4 */
-+#define IBSFETCHCTL_PMD	4 /* pmd4 */
-+#define IBSOPSCTL_PMC	5 /* pmc5 */
-+#define IBSOPSCTL_PMD	7 /* pmd7 */
-+
-+static u64 enable_mask[PFM_MAX_PMCS];
-+static u16 max_enable;
-+
-+static struct pfm_arch_pmu_info pfm_amd64_pmu_info = {
-+	.stop_save = pfm_amd64_stop_save,
-+	.has_ovfls = pfm_amd64_has_ovfls,
-+	.quiesce = pfm_amd64_quiesce,
-+	.restore_pmcs = pfm_amd64_restore_pmcs
-+};
-+
-+#define PFM_AMD64_IBSFETCHVAL	(1ULL<<49) /* valid fetch sample */
-+#define PFM_AMD64_IBSFETCHEN	(1ULL<<48) /* fetch sampling enabled */
-+#define PFM_AMD64_IBSOPVAL	(1ULL<<18) /* valid execution sample */
-+#define PFM_AMD64_IBSOPEN	(1ULL<<17) /* execution sampling enabled */
-+
-+/*
-+ * force Local APIC interrupt on overflow
-+ */
-+#define PFM_K8_VAL	(1ULL<<20)
-+#define PFM_K8_NO64	(1ULL<<20)
-+
-+/*
-+ * reserved bits must be 1
-+ *
-+ * for family 15:
-+ * - upper 32 bits are reserved
-+ * - bit 20, bit 21
-+ *
-+ * for family 16:
-+ * - bits 36-39 are reserved
-+ * - bits 42-63 are reserved
-+ * - bit 20, bit 21
-+ *
-+ * for IBS registers:
-+ * 	IBSFETCHCTL: all bits are reserved except bits 57, 48, 15:0
-+ * 	IBSOPSCTL  : all bits are reserved except bits 17, 15:0
-+ */
-+#define PFM_K8_RSVD 	((~((1ULL<<32)-1)) | (1ULL<<20) | (1ULL<<21))
-+#define PFM_16_RSVD ((0x3fffffULL<<42) | (0xfULL<<36) | (1ULL<<20) | (1ULL<<21))
-+#define PFM_AMD64_IBSFETCHCTL_RSVD	(~((1ULL<<48)|(1ULL<<57)|0xffffULL))
-+#define PFM_AMD64_IBSOPCTL_RSVD		(~((1ULL<<17)|0xffffULL))
-+
-+static struct pfm_regmap_desc pfm_amd64_pmc_desc[] = {
-+/* pmc0  */ PMC_D(PFM_REG_I64, "PERFSEL0", PFM_K8_VAL, PFM_K8_RSVD, PFM_K8_NO64, MSR_K7_EVNTSEL0),
-+/* pmc1  */ PMC_D(PFM_REG_I64, "PERFSEL1", PFM_K8_VAL, PFM_K8_RSVD, PFM_K8_NO64, MSR_K7_EVNTSEL1),
-+/* pmc2  */ PMC_D(PFM_REG_I64, "PERFSEL2", PFM_K8_VAL, PFM_K8_RSVD, PFM_K8_NO64, MSR_K7_EVNTSEL2),
-+/* pmc3  */ PMC_D(PFM_REG_I64, "PERFSEL3", PFM_K8_VAL, PFM_K8_RSVD, PFM_K8_NO64, MSR_K7_EVNTSEL3),
-+/* pmc4  */ PMC_D(PFM_REG_I,   "IBSFETCHCTL", 0, PFM_AMD64_IBSFETCHCTL_RSVD, 0, MSR_AMD64_IBSFETCHCTL),
-+/* pmc5  */ PMC_D(PFM_REG_I,   "IBSOPCTL",    0, PFM_AMD64_IBSOPCTL_RSVD,    0, MSR_AMD64_IBSOPCTL),
-+};
-+#define PFM_AMD_NUM_PMCS ARRAY_SIZE(pfm_amd64_pmc_desc)
-+
-+#define PFM_REG_IBS (PFM_REG_I|PFM_REG_INTR)
-+
-+/*
-+ * AMD64 counters are 48 bits, upper bits are reserved
-+ */
-+#define PFM_AMD64_CTR_RSVD	(~((1ULL<<48)-1))
-+
-+#define PFM_AMD_D(n) \
-+	{ .type = PFM_REG_C,			\
-+	  .desc = "PERFCTR"#n,			\
-+	  .hw_addr = MSR_K7_PERFCTR0+n,		\
-+	  .rsvd_msk = PFM_AMD64_CTR_RSVD,	\
-+	  .dep_pmcs[0] = 1ULL << n		\
-+	}
-+
-+#define PFM_AMD_IBSO(t, s, a) \
-+	{ .type = t,			\
-+	  .desc = s,			\
-+	  .hw_addr = a,			\
-+	  .rsvd_msk = 0,		\
-+	  .dep_pmcs[0] = 1ULL << 5	\
-+	}
-+
-+#define PFM_AMD_IBSF(t, s, a) \
-+	{ .type = t,			\
-+	  .desc = s,			\
-+	  .hw_addr = a,			\
-+	  .rsvd_msk = 0,		\
-+	  .dep_pmcs[0] = 1ULL << 6	\
-+	}
-+
-+static struct pfm_regmap_desc pfm_amd64_pmd_desc[] = {
-+/* pmd0  */ PFM_AMD_D(0),
-+/* pmd1  */ PFM_AMD_D(1),
-+/* pmd2  */ PFM_AMD_D(2),
-+/* pmd3  */ PFM_AMD_D(3),
-+/* pmd4  */ PFM_AMD_IBSF(PFM_REG_IBS, "IBSFETCHCTL",	MSR_AMD64_IBSFETCHCTL),
-+/* pmd5  */ PFM_AMD_IBSF(PFM_REG_IRO, "IBSFETCHLINAD",	MSR_AMD64_IBSFETCHLINAD),
-+/* pmd6  */ PFM_AMD_IBSF(PFM_REG_IRO, "IBSFETCHPHYSAD", MSR_AMD64_IBSFETCHPHYSAD),
-+/* pmd7  */ PFM_AMD_IBSO(PFM_REG_IBS, "IBSOPCTL",	MSR_AMD64_IBSOPCTL),
-+/* pmd8  */ PFM_AMD_IBSO(PFM_REG_IRO, "IBSOPRIP",	MSR_AMD64_IBSOPRIP),
-+/* pmd9  */ PFM_AMD_IBSO(PFM_REG_IRO, "IBSOPDATA",	MSR_AMD64_IBSOPDATA),
-+/* pmd10 */ PFM_AMD_IBSO(PFM_REG_IRO, "IBSOPDATA2",	MSR_AMD64_IBSOPDATA2),
-+/* pmd11 */ PFM_AMD_IBSO(PFM_REG_IRO, "IBSOPDATA3",	MSR_AMD64_IBSOPDATA3),
-+/* pmd12 */ PFM_AMD_IBSO(PFM_REG_IRO, "IBSDCLINAD",	MSR_AMD64_IBSDCLINAD),
-+/* pmd13 */ PFM_AMD_IBSO(PFM_REG_IRO, "IBSDCPHYSAD",	MSR_AMD64_IBSDCPHYSAD),
-+};
-+#define PFM_AMD_NUM_PMDS ARRAY_SIZE(pfm_amd64_pmd_desc)
-+
-+static struct pfm_context **pfm_nb_sys_owners;
-+static struct pfm_context *pfm_nb_task_owner;
-+
-+static struct pfm_pmu_config pfm_amd64_pmu_conf;
-+
-+#define is_ibs_pmc(x) (x == 4 || x == 5)
-+
-+static void pfm_amd64_setup_eilvt_per_cpu(void *info)
-+{
-+	u8 lvt_off;
-+
-+	/* program the IBS vector to the perfmon vector */
-+	lvt_off =  setup_APIC_eilvt_ibs(LOCAL_PERFMON_VECTOR,
-+					APIC_EILVT_MSG_FIX, 0);
-+	PFM_DBG("APIC_EILVT%d set to 0x%x", lvt_off, LOCAL_PERFMON_VECTOR);
-+	ibs_eilvt_off = lvt_off;
-+}
-+
-+static int pfm_amd64_setup_eilvt(void)
-+{
-+#define IBSCTL_LVTOFFSETVAL		(1 << 8)
-+#define IBSCTL				0x1cc
-+	struct pci_dev *cpu_cfg;
-+	int nodes;
-+	u32 value = 0;
-+
-+	/* per CPU setup */
-+	on_each_cpu(pfm_amd64_setup_eilvt_per_cpu, NULL, 1);
-+
-+	nodes = 0;
-+	cpu_cfg = NULL;
-+	do {
-+		cpu_cfg = pci_get_device(PCI_VENDOR_ID_AMD,
-+					 PCI_DEVICE_ID_AMD_10H_NB_MISC,
-+					 cpu_cfg);
-+		if (!cpu_cfg)
-+			break;
-+		++nodes;
-+		pci_write_config_dword(cpu_cfg, IBSCTL, ibs_eilvt_off
-+				       | IBSCTL_LVTOFFSETVAL);
-+		pci_read_config_dword(cpu_cfg, IBSCTL, &value);
-+		if (value != (ibs_eilvt_off | IBSCTL_LVTOFFSETVAL)) {
-+			PFM_DBG("Failed to setup IBS LVT offset, "
-+				"IBSCTL = 0x%08x", value);
-+			return 1;
-+		}
-+	} while (1);
-+
-+	if (!nodes) {
-+		PFM_DBG("No CPU node configured for IBS");
-+		return 1;
-+	}
-+
-+#ifdef CONFIG_NUMA
-+	/* Sanity check */
-+	/* Works only for 64bit with proper numa implementation. */
-+	if (nodes != num_possible_nodes()) {
-+		PFM_DBG("Failed to setup CPU node(s) for IBS, "
-+			"found: %d, expected %d",
-+			nodes, num_possible_nodes());
-+		return 1;
-+	}
-+#endif
-+	return 0;
-+}
-+
-+/*
-+ * There can only be one user per socket for the Northbridge (NB) events,
-+ * so we enforce mutual exclusion as follows:
-+ * 	- per-thread : only one context machine-wide can use NB events
-+ * 	- system-wide: only one context per processor socket
-+ *
-+ * Exclusion is enforced at:
-+ * 	- pfm_load_context()
-+ * 	- pfm_write_pmcs() for attached contexts
-+ *
-+ * Exclusion is released at:
-+ * 	- pfm_unload_context() or any calls that implicitely uses it
-+ *
-+ * return:
-+ * 	0  : successfully acquire NB access
-+ * 	< 0:  errno, failed to acquire NB access
-+ */
-+static int pfm_amd64_acquire_nb(struct pfm_context *ctx)
-+{
-+	struct pfm_context **entry, *old;
-+	int proc_id;
-+
-+#ifdef CONFIG_SMP
-+	proc_id = cpu_data(smp_processor_id()).phys_proc_id;
-+#else
-+	proc_id = 0;
-+#endif
-+
-+	if (ctx->flags.system)
-+		entry = &pfm_nb_sys_owners[proc_id];
-+	else
-+		entry = &pfm_nb_task_owner;
-+
-+	old = cmpxchg(entry, NULL, ctx);
-+	if (!old) {
-+		if (ctx->flags.system)
-+			PFM_DBG("acquired Northbridge event access on socket %u", proc_id);
-+		else
-+			PFM_DBG("acquired Northbridge event access globally");
-+	} else if (old != ctx) {
-+		if (ctx->flags.system)
-+			PFM_DBG("NorthBridge event conflict on socket %u", proc_id);
-+		else
-+			PFM_DBG("global NorthBridge event conflict");
-+		return -EBUSY;
-+	}
-+	return 0;
-+}
-+
-+/*
-+ * invoked from pfm_write_pmcs() when pfm_nb_sys_owners is not NULL,i.e.,
-+ * when we have detected a multi-core processor.
-+ *
-+ * context is locked, interrupts are masked
-+ */
-+static int pfm_amd64_pmc_write_check(struct pfm_context *ctx,
-+			     struct pfm_event_set *set,
-+			     struct pfarg_pmc *req)
-+{
-+	unsigned int event;
-+
-+	/*
-+	 * delay checking NB event until we load the context
-+	 */
-+	if (ctx->state == PFM_CTX_UNLOADED)
-+		return 0;
-+
-+	/*
-+	 * check event is NB event
-+	 */
-+	event = (unsigned int)(req->reg_value & 0xff);
-+	if (event < 0xee)
-+		return 0;
-+
-+	return pfm_amd64_acquire_nb(ctx);
-+}
-+
-+/*
-+ * invoked on pfm_load_context().
-+ * context is locked, interrupts are masked
-+ */
-+static int pfm_amd64_load_context(struct pfm_context *ctx)
-+{
-+	struct pfm_event_set *set;
-+	unsigned int i, n;
-+
-+	/*
-+	 * scan all sets for NB events
-+	 */
-+	list_for_each_entry(set, &ctx->set_list, list) {
-+		n = set->nused_pmcs;
-+		for (i = 0; n; i++) {
-+			if (!test_bit(i, cast_ulp(set->used_pmcs)))
-+				continue;
-+
-+			if (!is_ibs_pmc(i) && (set->pmcs[i] & 0xff) >= 0xee)
-+				goto found;
-+			n--;
-+		}
-+	}
-+	return 0;
-+found:
-+	return pfm_amd64_acquire_nb(ctx);
-+}
-+
-+/*
-+ * invoked on pfm_unload_context()
-+ */
-+static void pfm_amd64_unload_context(struct pfm_context *ctx)
-+{
-+	struct pfm_context **entry, *old;
-+	int proc_id;
-+
-+#ifdef CONFIG_SMP
-+	proc_id = cpu_data(smp_processor_id()).phys_proc_id;
-+#else
-+	proc_id = 0;
-+#endif
-+
-+	/*
-+	 * unload always happens on the monitored CPU in system-wide
-+	 */
-+	if (ctx->flags.system)
-+		entry = &pfm_nb_sys_owners[proc_id];
-+	else
-+		entry = &pfm_nb_task_owner;
-+
-+	old = cmpxchg(entry, ctx, NULL);
-+	if (old == ctx) {
-+		if (ctx->flags.system)
-+			PFM_DBG("released NorthBridge on socket %u", proc_id);
-+		else
-+			PFM_DBG("released NorthBridge events globally");
-+	}
-+}
-+
-+/*
-+ * detect if we need to activate NorthBridge event access control
-+ */
-+static int pfm_amd64_setup_nb_event_control(void)
-+{
-+	unsigned int c, n = 0;
-+	unsigned int max_phys = 0;
-+
-+#ifdef CONFIG_SMP
-+	for_each_possible_cpu(c) {
-+		if (cpu_data(c).phys_proc_id > max_phys)
-+			max_phys = cpu_data(c).phys_proc_id;
-+	}
-+#else
-+	max_phys = 0;
-+#endif
-+	if (max_phys > 255) {
-+		PFM_INFO("socket id %d is too big to handle", max_phys);
-+		return -ENOMEM;
-+	}
-+
-+	n = max_phys + 1;
-+	if (n < 2)
-+		return 0;
-+
-+	pfm_nb_sys_owners = vmalloc(n * sizeof(*pfm_nb_sys_owners));
-+	if (!pfm_nb_sys_owners)
-+		return -ENOMEM;
-+
-+	memset(pfm_nb_sys_owners, 0, n * sizeof(*pfm_nb_sys_owners));
-+	pfm_nb_task_owner = NULL;
-+
-+	/*
-+	 * activate write-checker for PMC registers
-+	 */
-+	for (c = 0; c < PFM_AMD_NUM_PMCS; c++) {
-+		if (!is_ibs_pmc(c))
-+			pfm_amd64_pmc_desc[c].type |= PFM_REG_WC;
-+	}
-+
-+	pfm_amd64_pmu_info.load_context = pfm_amd64_load_context;
-+	pfm_amd64_pmu_info.unload_context = pfm_amd64_unload_context;
-+
-+	pfm_amd64_pmu_conf.pmc_write_check = pfm_amd64_pmc_write_check;
-+
-+	PFM_INFO("NorthBridge event access control enabled");
-+
-+	return 0;
-+}
-+
-+/*
-+ * disable registers which are not available on
-+ * the host (applies to IBS registers)
-+ */
-+static void pfm_amd64_check_registers(void)
-+{
-+	u16 i;
-+
-+	PFM_DBG("has_ibs=%d", !!(ibs_status & HAS_IBS));
-+
-+	__set_bit(0, cast_ulp(enable_mask));
-+	__set_bit(1, cast_ulp(enable_mask));
-+	__set_bit(2, cast_ulp(enable_mask));
-+	__set_bit(3, cast_ulp(enable_mask));
-+	max_enable = 3+1;
-+
-+
-+	/*
-+	 * remove IBS registers if feature not present
-+	 */
-+	if (!(ibs_status & HAS_IBS)) {
-+		pfm_amd64_pmc_desc[4].type = PFM_REG_NA;
-+		pfm_amd64_pmc_desc[5].type = PFM_REG_NA;
-+		for (i = 4; i < 14; i++)
-+			pfm_amd64_pmd_desc[i].type = PFM_REG_NA;
-+	} else {
-+		__set_bit(16, cast_ulp(enable_mask));
-+		__set_bit(17, cast_ulp(enable_mask));
-+		max_enable = 17 + 1;
-+	}
-+
-+	/*
-+	 * adjust reserved bit fields for family 16
-+	 */
-+	if (current_cpu_data.x86 == 16) {
-+		for (i = 0; i < PFM_AMD_NUM_PMCS; i++)
-+			if (pfm_amd64_pmc_desc[i].rsvd_msk == PFM_K8_RSVD)
-+				pfm_amd64_pmc_desc[i].rsvd_msk = PFM_16_RSVD;
-+	}
-+}
-+
-+static int pfm_amd64_probe_pmu(void)
-+{
-+	u64 val = 0;
-+	if (current_cpu_data.x86_vendor != X86_VENDOR_AMD) {
-+		PFM_INFO("not an AMD processor");
-+		return -1;
-+	}
-+
-+	switch (current_cpu_data.x86) {
-+	case 16:
-+	case 15:
-+	case  6:
-+		break;
-+	default:
-+		PFM_INFO("unsupported family=%d", current_cpu_data.x86);
-+		return -1;
-+	}
-+
-+	/* check for IBS */
-+	if (cpu_has(&current_cpu_data, X86_FEATURE_IBS)) {
-+		ibs_status |= HAS_IBS;
-+		rdmsrl(MSR_AMD64_IBSCTL, val);
-+	}
-+
-+	PFM_INFO("found family=%d IBSCTL=0x%llx", current_cpu_data.x86, (unsigned long long)val);
-+
-+	/*
-+	 * check for local APIC (required)
-+	 */
-+	if (!cpu_has_apic) {
-+		PFM_INFO("no local APIC, unsupported");
-+		return -1;
-+	}
-+
-+	if (current_cpu_data.x86_max_cores > 1
-+	    && pfm_amd64_setup_nb_event_control())
-+		return -1;
-+
-+	if (force_nmi)
-+		pfm_amd64_pmu_info.flags |= PFM_X86_FL_USE_NMI;
-+
-+	if (ibs_status & HAS_IBS) {
-+		/* Setup extended interrupt */
-+		if (pfm_amd64_setup_eilvt()) {
-+			PFM_INFO("Failed to initialize extended interrupts "
-+				 "for IBS");
-+			ibs_status  &= ~HAS_IBS;
-+			PFM_INFO("Unable to use IBS");
-+		} else {
-+			PFM_INFO("IBS supported");
-+		}
-+	}
-+
-+	pfm_amd64_check_registers();
-+
-+	return 0;
-+}
-+
-+/*
-+ * detect is counters have overflowed.
-+ * return:
-+ * 	0 : no overflow
-+ * 	1 : at least one overflow
-+ */
-+static int __kprobes pfm_amd64_has_ovfls(struct pfm_context *ctx)
-+{
-+	struct pfm_regmap_desc *xrd;
-+	u64 *cnt_mask;
-+	u64 wmask, val;
-+	u16 i, num;
-+
-+	/*
-+	 * Check for IBS events
-+	 */
-+	if (ibs_status & HAS_IBS) {
-+		rdmsrl(MSR_AMD64_IBSFETCHCTL, val);
-+		if (val & PFM_AMD64_IBSFETCHVAL)
-+			return 1;
-+		rdmsrl(MSR_AMD64_IBSOPCTL, val);
-+		if (val & PFM_AMD64_IBSOPVAL)
-+			return 1;
-+	}
-+	/*
-+	 * Check regular counters
-+	 */
-+	cnt_mask = ctx->regs.cnt_pmds;
-+	num = ctx->regs.num_counters;
-+	wmask = 1ULL << pfm_pmu_conf->counter_width;
-+	xrd = pfm_amd64_pmd_desc;
-+
-+	for (i = 0; num; i++) {
-+		if (test_bit(i, cast_ulp(cnt_mask))) {
-+			rdmsrl(xrd[i].hw_addr, val);
-+			if (!(val & wmask))
-+				return 1;
-+			num--;
-+		}
-+	}
-+	return 0;
-+}
-+
-+/*
-+ * Must check for IBS event BEFORE stop_save_p6 because
-+ * stopping monitoring does destroy IBS state information
-+ * in IBSFETCHCTL/IBSOPCTL because they are tagged as enable
-+ * registers.
-+ */
-+static int pfm_amd64_stop_save(struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	struct pfm_arch_pmu_info *pmu_info;
-+	u64 used_mask[PFM_PMC_BV];
-+	u64 *cnt_pmds;
-+	u64 val, wmask, ovfl_mask;
-+	u32 i, count, use_ibs;
-+
-+	pmu_info = pfm_pmu_info();
-+
-+	/*
-+	 * IBS used if:
-+	 *   - on family 10h processor with IBS
-+	 *   - at least one of the IBS PMD registers is used
-+	 */
-+	use_ibs = (ibs_status & HAS_IBS)
-+		&& (test_bit(IBSFETCHCTL_PMD, cast_ulp(set->used_pmds))
-+		    || test_bit(IBSOPSCTL_PMD, cast_ulp(set->used_pmds)));
-+
-+	wmask = 1ULL << pfm_pmu_conf->counter_width;
-+
-+	bitmap_and(cast_ulp(used_mask),
-+		   cast_ulp(set->used_pmcs),
-+		   cast_ulp(enable_mask),
-+		   max_enable);
-+
-+	count = bitmap_weight(cast_ulp(used_mask), max_enable);
-+
-+	/*
-+	 * stop monitoring
-+	 * Unfortunately, this is very expensive!
-+	 * wrmsrl() is serializing.
-+	 *
-+	 * With IBS, we need to do read-modify-write to preserve the content
-+	 * for OpsCTL and FetchCTL because they are also used as PMDs and saved
-+	 * below
-+	 */
-+	if (use_ibs) {
-+		for (i = 0; count; i++) {
-+			if (test_bit(i, cast_ulp(used_mask))) {
-+				if (i == IBSFETCHCTL_PMC) {
-+					rdmsrl(pfm_pmu_conf->pmc_desc[i].hw_addr, val);
-+					val &= ~PFM_AMD64_IBSFETCHEN;
-+				} else if (i == IBSOPSCTL_PMC) {
-+					rdmsrl(pfm_pmu_conf->pmc_desc[i].hw_addr, val);
-+					val &= ~PFM_AMD64_IBSOPEN;
-+				} else
-+					val = 0;
-+				wrmsrl(pfm_pmu_conf->pmc_desc[i].hw_addr, val);
-+				count--;
-+			}
-+		}
-+	} else {
-+		for (i = 0; count; i++) {
-+			if (test_bit(i, cast_ulp(used_mask))) {
-+				wrmsrl(pfm_pmu_conf->pmc_desc[i].hw_addr, 0);
-+				count--;
-+			}
-+		}
-+	}
-+
-+	/*
-+	 * if we already having a pending overflow condition, we simply
-+	 * return to take care of this first.
-+	 */
-+	if (set->npend_ovfls)
-+		return 1;
-+
-+	ovfl_mask = pfm_pmu_conf->ovfl_mask;
-+	cnt_pmds = ctx->regs.cnt_pmds;
-+
-+	/*
-+	 * check for pending overflows and save PMDs (combo)
-+	 * we employ used_pmds because we also need to save
-+	 * and not just check for pending interrupts.
-+	 *
-+	 * Must check for counting PMDs because of virtual PMDs and IBS
-+	 */
-+	count = set->nused_pmds;
-+	for (i = 0; count; i++) {
-+		if (test_bit(i, cast_ulp(set->used_pmds))) {
-+			val = pfm_arch_read_pmd(ctx, i);
-+			if (likely(test_bit(i, cast_ulp(cnt_pmds)))) {
-+				if (!(val & wmask)) {
-+					__set_bit(i, cast_ulp(set->povfl_pmds));
-+					set->npend_ovfls++;
-+				}
-+				val = (set->pmds[i].value & ~ovfl_mask) | (val & ovfl_mask);
-+			}
-+			set->pmds[i].value = val;
-+			count--;
-+		}
-+	}
-+
-+	/*
-+	 * check if IBS contains valid data, and mark the corresponding
-+	 * PMD has overflowed
-+	 */
-+	if (use_ibs) {
-+		if (set->pmds[IBSFETCHCTL_PMD].value & PFM_AMD64_IBSFETCHVAL) {
-+			__set_bit(IBSFETCHCTL_PMD, cast_ulp(set->povfl_pmds));
-+			set->npend_ovfls++;
-+		}
-+		if (set->pmds[IBSOPSCTL_PMD].value & PFM_AMD64_IBSOPVAL) {
-+			__set_bit(IBSOPSCTL_PMD, cast_ulp(set->povfl_pmds));
-+			set->npend_ovfls++;
-+		}
-+	}
-+	/* 0 means: no need to save PMDs at upper level */
-+	return 0;
-+}
-+
-+/**
-+ * pfm_amd64_quiesce_pmu -- stop monitoring without grabbing any lock
-+ *
-+ * called from NMI interrupt handler to immediately stop monitoring
-+ * cannot grab any lock, including perfmon related locks
-+ */
-+static void __kprobes pfm_amd64_quiesce(void)
-+{
-+	/*
-+	 * quiesce PMU by clearing available registers that have
-+	 * the start/stop capability
-+	 */
-+	if (test_bit(0, cast_ulp(pfm_pmu_conf->regs_all.pmcs)))
-+		wrmsrl(MSR_K7_EVNTSEL0, 0);
-+	if (test_bit(1, cast_ulp(pfm_pmu_conf->regs_all.pmcs)))
-+		wrmsrl(MSR_K7_EVNTSEL0+1, 0);
-+	if (test_bit(2, cast_ulp(pfm_pmu_conf->regs_all.pmcs)))
-+		wrmsrl(MSR_K7_EVNTSEL0+2, 0);
-+	if (test_bit(3, cast_ulp(pfm_pmu_conf->regs_all.pmcs)))
-+		wrmsrl(MSR_K7_EVNTSEL0+3, 0);
-+
-+	if (test_bit(4, cast_ulp(pfm_pmu_conf->regs_all.pmcs)))
-+		wrmsrl(MSR_AMD64_IBSFETCHCTL, 0);
-+	if (test_bit(5, cast_ulp(pfm_pmu_conf->regs_all.pmcs)))
-+		wrmsrl(MSR_AMD64_IBSOPCTL, 0);
-+}
-+
-+/**
-+ * pfm_amd64_restore_pmcs - reload PMC registers
-+ * @ctx: context to restore from
-+ * @set: current event set
-+ *
-+ * optimized version of pfm_arch_restore_pmcs(). On AMD64, we can
-+ * afford to only restore the pmcs registers we use, because they are
-+ * all independent from each other.
-+ */
-+static void pfm_amd64_restore_pmcs(struct pfm_context *ctx,
-+				   struct pfm_event_set *set)
-+{
-+	u64 *mask;
-+	u16 i, num;
-+
-+	mask = set->used_pmcs;
-+	num = set->nused_pmcs;
-+	for (i = 0; num; i++) {
-+		if (test_bit(i, cast_ulp(mask))) {
-+			wrmsrl(pfm_amd64_pmc_desc[i].hw_addr, set->pmcs[i]);
-+			num--;
-+		}
-+	}
-+}
-+
-+static struct pfm_pmu_config pfm_amd64_pmu_conf = {
-+	.pmu_name = "AMD64",
-+	.counter_width = 47,
-+	.pmd_desc = pfm_amd64_pmd_desc,
-+	.pmc_desc = pfm_amd64_pmc_desc,
-+	.num_pmc_entries = PFM_AMD_NUM_PMCS,
-+	.num_pmd_entries = PFM_AMD_NUM_PMDS,
-+	.probe_pmu = pfm_amd64_probe_pmu,
-+	.version = "1.2",
-+	.pmu_info = &pfm_amd64_pmu_info,
-+	.flags = PFM_PMU_BUILTIN_FLAG,
-+	.owner = THIS_MODULE,
-+};
-+
-+static int __init pfm_amd64_pmu_init_module(void)
-+{
-+	return pfm_pmu_register(&pfm_amd64_pmu_conf);
-+}
-+
-+static void __exit pfm_amd64_pmu_cleanup_module(void)
-+{
-+	if (pfm_nb_sys_owners)
-+		vfree(pfm_nb_sys_owners);
-+
-+	pfm_pmu_unregister(&pfm_amd64_pmu_conf);
-+}
-+
-+module_init(pfm_amd64_pmu_init_module);
-+module_exit(pfm_amd64_pmu_cleanup_module);
-diff --git a/arch/x86/perfmon/perfmon_intel_arch.c b/arch/x86/perfmon/perfmon_intel_arch.c
-new file mode 100644
-index 0000000..e27a732
---- /dev/null
-+++ b/arch/x86/perfmon/perfmon_intel_arch.c
-@@ -0,0 +1,610 @@
-+/*
-+ * This file contains the Intel architectural perfmon v1, v2, v3
-+ * description tables.
-+ *
-+ * Architectural perfmon was introduced with Intel Core Solo/Duo
-+ * processors.
-+ *
-+ * Copyright (c) 2006-2007 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/module.h>
-+#include <linux/kprobes.h>
-+#include <linux/perfmon_kern.h>
-+#include <linux/nmi.h>
-+#include <asm/msr.h>
-+#include <asm/apic.h>
-+
-+MODULE_AUTHOR("Stephane Eranian <eranian@hpl.hp.com>");
-+MODULE_DESCRIPTION("Intel architectural perfmon v1");
-+MODULE_LICENSE("GPL");
-+
-+static int force, force_nmi;
-+MODULE_PARM_DESC(force, "bool: force module to load succesfully");
-+MODULE_PARM_DESC(force_nmi, "bool: force use of NMI for PMU interrupt");
-+module_param(force, bool, 0600);
-+module_param(force_nmi, bool, 0600);
-+
-+static u64 enable_mask[PFM_MAX_PMCS];
-+static u16 max_enable;
-+
-+/*
-+ * - upper 32 bits are reserved
-+ * - INT: APIC enable bit is reserved (forced to 1)
-+ * - bit 21 is reserved
-+ *
-+ * RSVD: reserved bits are 1
-+ */
-+#define PFM_IA_PMC_RSVD	((~((1ULL<<32)-1)) \
-+			| (1ULL<<20) \
-+			| (1ULL<<21))
-+
-+/*
-+ * force Local APIC interrupt on overflow
-+ * disable with NO_EMUL64
-+ */
-+#define PFM_IA_PMC_VAL	(1ULL<<20)
-+#define PFM_IA_NO64	(1ULL<<20)
-+
-+/*
-+ * architectuture specifies that:
-+ * IA32_PMCx MSR        : starts at 0x0c1 & occupy a contiguous block of MSR
-+ * IA32_PERFEVTSELx MSR : starts at 0x186 & occupy a contiguous block of MSR
-+ * MSR_GEN_FIXED_CTR0   : starts at 0x309 & occupy a contiguous block of MSR
-+ */
-+#define MSR_GEN_SEL_BASE	MSR_P6_EVNTSEL0
-+#define MSR_GEN_PMC_BASE	MSR_P6_PERFCTR0
-+#define MSR_GEN_FIXED_PMC_BASE	MSR_CORE_PERF_FIXED_CTR0
-+
-+/*
-+ * layout of EAX for CPUID.0xa leaf function
-+ */
-+struct pmu_eax {
-+	unsigned int version:8;		/* architectural perfmon version */
-+	unsigned int num_cnt:8; 	/* number of generic counters */
-+	unsigned int cnt_width:8;	/* width of generic counters */
-+	unsigned int ebx_length:8;	/* number of architected events */
-+};
-+
-+/*
-+ * layout of EDX for CPUID.0xa leaf function when perfmon v2 is detected
-+ */
-+struct pmu_edx {
-+	unsigned int num_cnt:5;		/* number of fixed counters */
-+	unsigned int cnt_width:8;	/* width of fixed counters */
-+	unsigned int reserved:19;
-+};
-+
-+static void pfm_intel_arch_restore_pmcs(struct pfm_context *ctx,
-+					struct pfm_event_set *set);
-+static int pfm_intel_arch_stop_save(struct pfm_context *ctx,
-+				    struct pfm_event_set *set);
-+static int pfm_intel_arch_has_ovfls(struct pfm_context *ctx);
-+static void __kprobes pfm_intel_arch_quiesce(void);
-+
-+/*
-+ * physical addresses of MSR controlling the perfevtsel and counter registers
-+ */
-+struct pfm_arch_pmu_info pfm_intel_arch_pmu_info = {
-+	.stop_save = pfm_intel_arch_stop_save,
-+	.has_ovfls = pfm_intel_arch_has_ovfls,
-+	.quiesce = pfm_intel_arch_quiesce,
-+	.restore_pmcs = pfm_intel_arch_restore_pmcs
-+};
-+
-+#define PFM_IA_C(n) {                   \
-+	.type = PFM_REG_I64,            \
-+	.desc = "PERFEVTSEL"#n,         \
-+	.dfl_val = PFM_IA_PMC_VAL,      \
-+	.rsvd_msk = PFM_IA_PMC_RSVD,    \
-+	.no_emul64_msk = PFM_IA_NO64,   \
-+	.hw_addr = MSR_GEN_SEL_BASE+(n) \
-+	}
-+
-+#define PFM_IA_D(n) \
-+	{ .type = PFM_REG_C,			\
-+	  .desc = "PMC"#n,			\
-+	  .hw_addr = MSR_P6_PERFCTR0+n,		\
-+	  .dep_pmcs[0] = 1ULL << n		\
-+	}
-+
-+#define PFM_IA_FD(n) \
-+	{ .type = PFM_REG_C,			\
-+	  .desc = "FIXED_CTR"#n,		\
-+	  .hw_addr = MSR_CORE_PERF_FIXED_CTR0+n,\
-+	  .dep_pmcs[0] = 1ULL << 16		\
-+	}
-+
-+static struct pfm_regmap_desc pfm_intel_arch_pmc_desc[] = {
-+/* pmc0  */ PFM_IA_C(0),  PFM_IA_C(1),   PFM_IA_C(2),  PFM_IA_C(3),
-+/* pmc4  */ PFM_IA_C(4),  PFM_IA_C(5),   PFM_IA_C(6),  PFM_IA_C(7),
-+/* pmc8  */ PFM_IA_C(8),  PFM_IA_C(9),  PFM_IA_C(10), PFM_IA_C(11),
-+/* pmc12 */ PFM_IA_C(12), PFM_IA_C(13), PFM_IA_C(14), PFM_IA_C(15),
-+
-+/* pmc16 */ { .type = PFM_REG_I,
-+	      .desc = "FIXED_CTRL",
-+	      .dfl_val = 0x8888888888888888ULL, /* force PMI */
-+	      .rsvd_msk = 0, /* set dynamically */
-+	      .no_emul64_msk = 0,
-+	      .hw_addr = MSR_CORE_PERF_FIXED_CTR_CTRL
-+	    },
-+};
-+#define PFM_IA_MAX_PMCS	ARRAY_SIZE(pfm_intel_arch_pmc_desc)
-+
-+static struct pfm_regmap_desc pfm_intel_arch_pmd_desc[] = {
-+/* pmd0  */  PFM_IA_D(0),  PFM_IA_D(1),  PFM_IA_D(2),  PFM_IA_D(3),
-+/* pmd4  */  PFM_IA_D(4),  PFM_IA_D(5),  PFM_IA_D(6),  PFM_IA_D(7),
-+/* pmd8  */  PFM_IA_D(8),  PFM_IA_D(9), PFM_IA_D(10), PFM_IA_D(11),
-+/* pmd12 */ PFM_IA_D(12), PFM_IA_D(13), PFM_IA_D(14), PFM_IA_D(15),
-+
-+/* pmd16 */ PFM_IA_FD(0), PFM_IA_FD(1), PFM_IA_FD(2), PFM_IA_FD(3),
-+/* pmd20 */ PFM_IA_FD(4), PFM_IA_FD(5), PFM_IA_FD(6), PFM_IA_FD(7),
-+/* pmd24 */ PFM_IA_FD(8), PFM_IA_FD(9), PFM_IA_FD(10), PFM_IA_FD(11),
-+/* pmd28 */ PFM_IA_FD(16), PFM_IA_FD(17), PFM_IA_FD(18), PFM_IA_FD(19)
-+};
-+#define PFM_IA_MAX_PMDS	ARRAY_SIZE(pfm_intel_arch_pmd_desc)
-+
-+#define PFM_IA_MAX_CNT		16 /* # generic counters in mapping table */
-+#define PFM_IA_MAX_FCNT		16 /* # of fixed counters in mapping table */
-+#define PFM_IA_FCNT_BASE	16 /* base index of fixed counters PMD */
-+
-+static struct pfm_pmu_config pfm_intel_arch_pmu_conf;
-+
-+static void pfm_intel_arch_check_errata(void)
-+{
-+	/*
-+	 * Core Duo errata AE49 (no fix). Both counters share a single
-+	 * enable bit in PERFEVTSEL0
-+	 */
-+	if (current_cpu_data.x86 == 6 && current_cpu_data.x86_model == 14)
-+		pfm_intel_arch_pmu_info.flags |= PFM_X86_FL_NO_SHARING;
-+}
-+
-+static inline void set_enable_mask(unsigned int i)
-+{
-+	__set_bit(i, cast_ulp(enable_mask));
-+
-+	/* max_enable = highest + 1 */
-+	if ((i+1) > max_enable)
-+		max_enable = i+ 1;
-+}
-+
-+static void pfm_intel_arch_setup_generic(unsigned int version,
-+					 unsigned int width,
-+					 unsigned int count)
-+{
-+	u64 rsvd;
-+	unsigned int i;
-+
-+	/*
-+	 * first we handle the generic counters:
-+	 *
-+	 * - ensure HW does not have more registers than hardcoded in the tables
-+	 * - adjust rsvd_msk to actual counter width
-+	 * - initialize enable_mask (list of PMC with start/stop capability)
-+	 * - mark unused hardcoded generic counters as unimplemented
-+	 */
-+
-+	/*
-+	 * min of number of Hw counters and hardcoded in the tables
-+	 */
-+	if (count >= PFM_IA_MAX_CNT) {
-+		printk(KERN_INFO "perfmon: Limiting number of generic counters"
-+				 " to %u, HW supports %u",
-+				 PFM_IA_MAX_CNT, count);
-+		count = PFM_IA_MAX_CNT;
-+	}
-+
-+	/*
-+	 * adjust rsvd_msk for generic counters based on actual width
-+	 * initialize enable_mask (1 per pmd)
-+	 */
-+	rsvd = ~((1ULL << width)-1);
-+	for (i = 0; i < count; i++) {
-+		pfm_intel_arch_pmd_desc[i].rsvd_msk = rsvd;
-+		set_enable_mask(i);
-+	}
-+
-+	/*
-+	 * handle version 3 new anythread bit (21)
-+	 */
-+	if (version == 3) {
-+		for (i = 0; i < count; i++)
-+			pfm_intel_arch_pmc_desc[i].rsvd_msk &= ~(1ULL << 21);
-+	}
-+
-+
-+	/*
-+	 * mark unused generic counters as not available
-+	 */
-+	for (i = count ; i < PFM_IA_MAX_CNT; i++) {
-+		pfm_intel_arch_pmd_desc[i].type = PFM_REG_NA;
-+		pfm_intel_arch_pmc_desc[i].type = PFM_REG_NA;
-+	}
-+}
-+
-+static void pfm_intel_arch_setup_fixed(unsigned int version,
-+				       unsigned int width,
-+				       unsigned int count)
-+{
-+	u64 rsvd, dfl;
-+	unsigned int i;
-+
-+	/*
-+	 * handle the fixed counters (if any):
-+	 *
-+	 * - ensure HW does not have more registers than hardcoded in the tables
-+	 * - adjust rsvd_msk to actual counter width
-+	 * - initialize enable_mask (list of PMC with start/stop capability)
-+	 * - mark unused hardcoded generic counters as unimplemented
-+	 */
-+	if (count >= PFM_IA_MAX_FCNT) {
-+		printk(KERN_INFO "perfmon: Limiting number of fixed counters"
-+				 " to %u, HW supports %u",
-+				 PFM_IA_MAX_FCNT, count);
-+		count = PFM_IA_MAX_FCNT;
-+	}
-+	/*
-+	 * adjust rsvd_msk for fixed counters based on actual width
-+	 */
-+	rsvd = ~((1ULL << width)-1);
-+	for (i = 0; i < count; i++)
-+		pfm_intel_arch_pmd_desc[PFM_IA_FCNT_BASE+i].rsvd_msk = rsvd;
-+
-+	/*
-+	 * handle version new anythread bit (bit 2)
-+	 */
-+	if (version == 3)
-+		rsvd = 1ULL << 3;
-+	else
-+		rsvd = 3ULL << 2;
-+
-+	pfm_intel_arch_pmc_desc[16].rsvd_msk = 0;
-+	for (i = 0; i < count; i++)
-+		pfm_intel_arch_pmc_desc[16].rsvd_msk |= rsvd << (i<<2);
-+
-+	/*
-+	 * mark unused fixed counters as unimplemented
-+	 *
-+	 * update the rsvd_msk, dfl_val in FIXED_CTRL:
-+	 * 	- rsvd_msk: set all 4 bits
-+	 *	- dfl_val : clear all 4 bits
-+	 */
-+	dfl = pfm_intel_arch_pmc_desc[16].dfl_val;
-+	rsvd = pfm_intel_arch_pmc_desc[16].rsvd_msk;
-+
-+	for (i = count ; i < PFM_IA_MAX_FCNT; i++) {
-+		pfm_intel_arch_pmd_desc[PFM_IA_FCNT_BASE+i].type = PFM_REG_NA;
-+		rsvd |= 0xfULL << (i<<2);
-+		dfl &= ~(0xfULL << (i<<2));
-+	}
-+
-+	/*
-+	 * FIXED_CTR_CTRL unavailable when no fixed counters are defined
-+	 */
-+	if (!count) {
-+		pfm_intel_arch_pmc_desc[16].type = PFM_REG_NA;
-+	} else {
-+		/* update rsvd_mask and dfl_val */
-+		pfm_intel_arch_pmc_desc[16].rsvd_msk = rsvd;
-+		pfm_intel_arch_pmc_desc[16].dfl_val = dfl;
-+		set_enable_mask(16);
-+	}
-+}
-+
-+static int pfm_intel_arch_probe_pmu(void)
-+{
-+	union {
-+		unsigned int val;
-+		struct pmu_eax eax;
-+		struct pmu_edx edx;
-+	} eax, edx;
-+	unsigned int ebx, ecx;
-+	unsigned int width = 0;
-+
-+	edx.val = 0;
-+
-+	if (!(cpu_has_arch_perfmon || force)) {
-+		PFM_INFO("no support for Intel architectural PMU");
-+		return -1;
-+	}
-+
-+	if (!cpu_has_apic) {
-+		PFM_INFO("no Local APIC, try rebooting with lapic option");
-+		return -1;
-+	}
-+
-+	/* cpuid() call protected by cpu_has_arch_perfmon */
-+	cpuid(0xa, &eax.val, &ebx, &ecx, &edx.val);
-+
-+	/*
-+	 * reject processors supported by perfmon_intel_core
-+	 *
-+	 * We need to do this explicitely to avoid depending
-+	 * on the link order in case, the modules are compiled as
-+	 * builtin.
-+	 *
-+	 * non Intel processors are rejected by cpu_has_arch_perfmon
-+	 */
-+	if (current_cpu_data.x86 == 6 && !force) {
-+		switch (current_cpu_data.x86_model) {
-+		case 15: /* Merom: use perfmon_intel_core  */
-+		case 23: /* Penryn: use perfmon_intel_core */
-+			return -1;
-+		default:
-+			break;
-+		}
-+	}
-+
-+	/*
-+	 * some 6/15 models have buggy BIOS
-+	 */
-+	if (eax.eax.version == 0
-+	    && current_cpu_data.x86 == 6 && current_cpu_data.x86_model == 15) {
-+		PFM_INFO("buggy v2 BIOS, adjusting for 2 generic counters");
-+		eax.eax.version = 2;
-+		eax.eax.num_cnt = 2;
-+		eax.eax.cnt_width = 40;
-+	}
-+
-+	/*
-+	 * Intel Atom processors have a buggy firmware which does not report
-+	 * the correct number of fixed counters
-+	 */
-+	if (eax.eax.version == 3 && edx.edx.num_cnt < 3
-+	    && current_cpu_data.x86 == 6 && current_cpu_data.x86_model == 28) {
-+		PFM_INFO("buggy v3 BIOS, adjusting for 3 fixed counters");
-+		edx.edx.num_cnt = 3;
-+	}
-+
-+	/*
-+	 * some v2 BIOSes are incomplete
-+	 */
-+	if (eax.eax.version == 2 && !edx.edx.num_cnt) {
-+		PFM_INFO("buggy v2 BIOS, adjusting for 3 fixed counters");
-+		edx.edx.num_cnt = 3;
-+		edx.edx.cnt_width = 40;
-+	}
-+
-+	/*
-+	 * no fixed counters on earlier versions
-+	 */
-+	if (eax.eax.version < 2) {
-+		edx.val = 0;
-+	} else {
-+		/*
-+		 * use the min value of both widths until we support
-+		 * variable width counters
-+		 */
-+		width = eax.eax.cnt_width < edx.edx.cnt_width ?
-+			eax.eax.cnt_width : edx.edx.cnt_width;
-+	}
-+
-+	PFM_INFO("detected architecural perfmon v%d", eax.eax.version);
-+	PFM_INFO("num_gen=%d width=%d num_fixed=%d width=%d",
-+		  eax.eax.num_cnt,
-+		  eax.eax.cnt_width,
-+		  edx.edx.num_cnt,
-+		  edx.edx.cnt_width);
-+
-+
-+	pfm_intel_arch_setup_generic(eax.eax.version,
-+				     width,
-+				     eax.eax.num_cnt);
-+
-+	pfm_intel_arch_setup_fixed(eax.eax.version,
-+				   width,
-+				   edx.edx.num_cnt);
-+
-+	if (force_nmi)
-+		pfm_intel_arch_pmu_info.flags |= PFM_X86_FL_USE_NMI;
-+
-+	pfm_intel_arch_check_errata();
-+
-+	return 0;
-+}
-+
-+/**
-+ * pfm_intel_arch_has_ovfls - check for pending overflow condition
-+ * @ctx: context to work on
-+ *
-+ * detect if counters have overflowed.
-+ * return:
-+ * 	0 : no overflow
-+ * 	1 : at least one overflow
-+ */
-+static int __kprobes pfm_intel_arch_has_ovfls(struct pfm_context *ctx)
-+{
-+	u64 *cnt_mask;
-+	u64 wmask, val;
-+	u16 i, num;
-+
-+	cnt_mask = ctx->regs.cnt_pmds;
-+	num = ctx->regs.num_counters;
-+	wmask = 1ULL << pfm_pmu_conf->counter_width;
-+
-+	/*
-+	 * we can leverage the fact that we know the mapping
-+	 * to hardcode the MSR address and avoid accessing
-+	 * more cachelines
-+	 *
-+	 * We need to check cnt_mask because not all registers
-+	 * may be available.
-+	 */
-+	for (i = 0; num; i++) {
-+		if (test_bit(i, cast_ulp(cnt_mask))) {
-+			rdmsrl(pfm_intel_arch_pmd_desc[i].hw_addr, val);
-+			if (!(val & wmask))
-+				return 1;
-+			num--;
-+		}
-+	}
-+	return 0;
-+}
-+
-+static int pfm_intel_arch_stop_save(struct pfm_context *ctx,
-+				    struct pfm_event_set *set)
-+{
-+	u64 used_mask[PFM_PMC_BV];
-+	u64 *cnt_pmds;
-+	u64 val, wmask, ovfl_mask;
-+	u32 i, count;
-+
-+	wmask = 1ULL << pfm_pmu_conf->counter_width;
-+
-+	bitmap_and(cast_ulp(used_mask),
-+		   cast_ulp(set->used_pmcs),
-+		   cast_ulp(enable_mask),
-+		   max_enable);
-+
-+	count = bitmap_weight(cast_ulp(used_mask), max_enable);
-+
-+	/*
-+	 * stop monitoring
-+	 * Unfortunately, this is very expensive!
-+	 * wrmsrl() is serializing.
-+	 */
-+	for (i = 0; count; i++) {
-+		if (test_bit(i, cast_ulp(used_mask))) {
-+			wrmsrl(pfm_pmu_conf->pmc_desc[i].hw_addr, 0);
-+			count--;
-+		}
-+	}
-+
-+	/*
-+	 * if we already having a pending overflow condition, we simply
-+	 * return to take care of this first.
-+	 */
-+	if (set->npend_ovfls)
-+		return 1;
-+
-+	ovfl_mask = pfm_pmu_conf->ovfl_mask;
-+	cnt_pmds = ctx->regs.cnt_pmds;
-+
-+	/*
-+	 * check for pending overflows and save PMDs (combo)
-+	 * we employ used_pmds because we also need to save
-+	 * and not just check for pending interrupts.
-+	 *
-+	 * Must check for counting PMDs because of virtual PMDs
-+	 */
-+	count = set->nused_pmds;
-+	for (i = 0; count; i++) {
-+		if (test_bit(i, cast_ulp(set->used_pmds))) {
-+			val = pfm_arch_read_pmd(ctx, i);
-+			if (likely(test_bit(i, cast_ulp(cnt_pmds)))) {
-+				if (!(val & wmask)) {
-+					__set_bit(i, cast_ulp(set->povfl_pmds));
-+					set->npend_ovfls++;
-+				}
-+				val = (set->pmds[i].value & ~ovfl_mask)
-+					| (val & ovfl_mask);
-+			}
-+			set->pmds[i].value = val;
-+			count--;
-+		}
-+	}
-+	/* 0 means: no need to save PMDs at upper level */
-+	return 0;
-+}
-+
-+/**
-+ * pfm_intel_arch_quiesce - stop monitoring without grabbing any lock
-+ *
-+ * called from NMI interrupt handler to immediately stop monitoring
-+ * cannot grab any lock, including perfmon related locks
-+ */
-+static void __kprobes pfm_intel_arch_quiesce(void)
-+{
-+	u16 i;
-+
-+	/*
-+	 * PMC16 is the fixed control control register so it has a
-+	 * distinct MSR address
-+	 *
-+	 * We do not use the hw_addr field in the table to avoid touching
-+	 * too many cachelines
-+	 */
-+	for (i = 0; i < pfm_pmu_conf->regs_all.max_pmc; i++) {
-+		if (test_bit(i, cast_ulp(pfm_pmu_conf->regs_all.pmcs))) {
-+			if (i == 16)
-+				wrmsrl(MSR_CORE_PERF_FIXED_CTR_CTRL, 0);
-+			else
-+				wrmsrl(MSR_P6_EVNTSEL0+i, 0);
-+		}
-+	}
-+}
-+
-+/**
-+ * pfm_intel_arch_restore_pmcs - reload PMC registers
-+ * @ctx: context to restore from
-+ * @set: current event set
-+ *
-+ * optimized version of pfm_arch_restore_pmcs(). On architectural perfmon,
-+ * we can afford to only restore the pmcs registers we use, because they
-+ * are all independent from each other.
-+ */
-+static void pfm_intel_arch_restore_pmcs(struct pfm_context *ctx,
-+					struct pfm_event_set *set)
-+{
-+	u64 *mask;
-+	u16 i, num;
-+
-+	mask = set->used_pmcs;
-+	num = set->nused_pmcs;
-+	for (i = 0; num; i++) {
-+		if (test_bit(i, cast_ulp(mask))) {
-+			wrmsrl(pfm_pmu_conf->pmc_desc[i].hw_addr, set->pmcs[i]);
-+			num--;
-+		}
-+	}
-+}
-+/*
-+ * Counters may have model-specific width. Yet the documentation says
-+ * that only the lower 32 bits can be written to due to the specification
-+ * of wrmsr. bits [32-(w-1)] are sign extensions of bit 31. Bits [w-63] must
-+ * not be set (see rsvd_msk for PMDs). As such the effective width of a
-+ * counter is 31 bits only regardless of what CPUID.0xa returns.
-+ *
-+ * See IA-32 Intel Architecture Software developer manual Vol 3B chapter 18
-+ */
-+static struct pfm_pmu_config pfm_intel_arch_pmu_conf = {
-+	.pmu_name = "Intel architectural",
-+	.pmd_desc = pfm_intel_arch_pmd_desc,
-+	.counter_width   = 31,
-+	.num_pmc_entries = PFM_IA_MAX_PMCS,
-+	.num_pmd_entries = PFM_IA_MAX_PMDS,
-+	.pmc_desc = pfm_intel_arch_pmc_desc,
-+	.probe_pmu = pfm_intel_arch_probe_pmu,
-+	.version = "1.0",
-+	.flags = PFM_PMU_BUILTIN_FLAG,
-+	.owner = THIS_MODULE,
-+	.pmu_info = &pfm_intel_arch_pmu_info
-+};
-+
-+static int __init pfm_intel_arch_pmu_init_module(void)
-+{
-+	return pfm_pmu_register(&pfm_intel_arch_pmu_conf);
-+}
-+
-+static void __exit pfm_intel_arch_pmu_cleanup_module(void)
-+{
-+	pfm_pmu_unregister(&pfm_intel_arch_pmu_conf);
-+}
-+
-+module_init(pfm_intel_arch_pmu_init_module);
-+module_exit(pfm_intel_arch_pmu_cleanup_module);
-diff --git a/arch/x86/perfmon/perfmon_intel_atom.c b/arch/x86/perfmon/perfmon_intel_atom.c
-new file mode 100644
-index 0000000..9b94863
---- /dev/null
-+++ b/arch/x86/perfmon/perfmon_intel_atom.c
-@@ -0,0 +1,541 @@
-+/*
-+ * perfmon support for Intel Atom (architectural perfmon v3 + PEBS)
-+ *
-+ * Copyright (c) 2008 Google,Inc
-+ * Contributed by Stephane Eranian <eranian@gmail.com>
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/module.h>
-+#include <linux/kprobes.h>
-+#include <linux/perfmon_kern.h>
-+#include <asm/msr.h>
-+
-+MODULE_AUTHOR("Stephane Eranian <eranian@gmail.com>");
-+MODULE_DESCRIPTION("Intel Atom");
-+MODULE_LICENSE("GPL");
-+
-+static int force, force_nmi;
-+MODULE_PARM_DESC(force, "bool: force module to load succesfully");
-+MODULE_PARM_DESC(force_nmi, "bool: force use of NMI for PMU interrupt");
-+module_param(force, bool, 0600);
-+module_param(force_nmi, bool, 0600);
-+
-+/*
-+ * - upper 32 bits are reserved
-+ * - INT: APIC enable bit is reserved (forced to 1)
-+ *
-+ * RSVD: reserved bits are 1
-+ */
-+#define PFM_ATOM_PMC_RSVD	((~((1ULL<<32)-1)) | (1ULL<<20))
-+
-+/*
-+ * force Local APIC interrupt on overflow
-+ * disable with NO_EMUL64
-+ */
-+#define PFM_ATOM_PMC_VAL	(1ULL<<20)
-+#define PFM_ATOM_NO64	(1ULL<<20)
-+
-+/*
-+ * Atom counters are 40-bits. 40-bits can be read but ony 31 can be written
-+ * to due to a limitation of wrmsr. Bits [[63-32] are sign extensions of bit 31.
-+ * Bits [63-40] must not be set
-+ *
-+ * See IA-32 Intel Architecture Software developer manual Vol 3B chapter 18
-+ */
-+#define PFM_ATOM_PMD_WIDTH	31
-+#define PFM_ATOM_PMD_RSVD	~((1ULL << 40)-1)
-+
-+static void pfm_intel_atom_acquire_pmu_percpu(void);
-+static void pfm_intel_atom_release_pmu_percpu(void);
-+static void pfm_intel_atom_restore_pmcs(struct pfm_context *ctx,
-+					struct pfm_event_set *set);
-+static int pfm_intel_atom_stop_save(struct pfm_context *ctx,
-+				    struct pfm_event_set *set);
-+static int pfm_intel_atom_has_ovfls(struct pfm_context *ctx);
-+static void __kprobes pfm_intel_atom_quiesce(void);
-+
-+struct pfm_arch_pmu_info pfm_intel_atom_pmu_info = {
-+	.stop_save = pfm_intel_atom_stop_save,
-+	.has_ovfls = pfm_intel_atom_has_ovfls,
-+	.quiesce = pfm_intel_atom_quiesce,
-+	.restore_pmcs = pfm_intel_atom_restore_pmcs,
-+	.acquire_pmu_percpu = pfm_intel_atom_acquire_pmu_percpu,
-+	.release_pmu_percpu = pfm_intel_atom_release_pmu_percpu
-+
-+};
-+
-+#define PFM_ATOM_C(n) {                  \
-+	.type = PFM_REG_I64,             \
-+	.desc = "PERFEVTSEL"#n,          \
-+	.dfl_val = PFM_ATOM_PMC_VAL,       \
-+	.rsvd_msk = PFM_ATOM_PMC_RSVD,     \
-+	.no_emul64_msk = PFM_ATOM_NO64,    \
-+	.hw_addr = MSR_P6_EVNTSEL0 + (n) \
-+	}
-+
-+
-+static struct pfm_regmap_desc pfm_intel_atom_pmc_desc[] = {
-+/* pmc0  */ PFM_ATOM_C(0),
-+/* pmc1  */ PFM_ATOM_C(1),
-+/* pmc2  */ PMX_NA, PMX_NA,
-+/* pmc4  */ PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc8  */ PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc12 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc16 */ { .type = PFM_REG_I,
-+	      .desc = "FIXED_CTRL",
-+	      .dfl_val = 0x0000000000000888ULL,  /* force PMI */
-+	      .rsvd_msk = 0xfffffffffffffcccULL, /* 3 fixed counters defined */
-+	      .no_emul64_msk = 0,
-+	      .hw_addr = MSR_CORE_PERF_FIXED_CTR_CTRL
-+	    },
-+/* pmc17  */{ .type = PFM_REG_W,
-+	      .desc = "PEBS_ENABLE",
-+	      .dfl_val = 0,
-+	      .rsvd_msk = 0xfffffffffffffffeULL,
-+	      .no_emul64_msk = 0,
-+	      .hw_addr = MSR_IA32_PEBS_ENABLE
-+	    }
-+};
-+#define PFM_ATOM_MAX_PMCS ARRAY_SIZE(pfm_intel_atom_pmc_desc)
-+
-+#define PFM_ATOM_D(n) \
-+	{ .type = PFM_REG_C,			\
-+	  .desc = "PMC"#n,			\
-+	  .rsvd_msk = PFM_ATOM_PMD_RSVD,	\
-+	  .hw_addr = MSR_P6_PERFCTR0+n,		\
-+	  .dep_pmcs[0] = 1ULL << n		\
-+	}
-+
-+#define PFM_ATOM_FD(n) \
-+	{ .type = PFM_REG_C,			\
-+	  .desc = "FIXED_CTR"#n,		\
-+	  .rsvd_msk = PFM_ATOM_PMD_RSVD,	\
-+	  .hw_addr = MSR_CORE_PERF_FIXED_CTR0+n,\
-+	  .dep_pmcs[0] = 1ULL << 16		\
-+	}
-+
-+static struct pfm_regmap_desc pfm_intel_atom_pmd_desc[] = {
-+/* pmd0  */ PFM_ATOM_D(0),
-+/* pmd1  */ PFM_ATOM_D(1),
-+/* pmd2  */ PMX_NA,
-+/* pmd3  */ PMX_NA,
-+/* pmd4  */ PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmd8  */ PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmd12 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmd16 */ PFM_ATOM_FD(0),
-+/* pmd17 */ PFM_ATOM_FD(1),
-+/* pmd18 */ PFM_ATOM_FD(2)
-+};
-+#define PFM_ATOM_MAX_PMDS ARRAY_SIZE(pfm_intel_atom_pmd_desc)
-+
-+static struct pfm_pmu_config pfm_intel_atom_pmu_conf;
-+
-+static int pfm_intel_atom_probe_pmu(void)
-+{
-+	if (force)
-+		goto doit;
-+
-+	if (current_cpu_data.x86_vendor != X86_VENDOR_INTEL)
-+		return -1;
-+
-+	if (current_cpu_data.x86 != 6)
-+		return -1;
-+
-+	if (current_cpu_data.x86_model != 28)
-+		return -1;
-+doit:
-+	/*
-+	 * having APIC is mandatory, so disregard force option
-+	 */
-+	if (!cpu_has_apic) {
-+		PFM_INFO("no Local APIC, try rebooting with lapic option");
-+		return -1;
-+	}
-+
-+	PFM_INFO("detected Intel Atom PMU");
-+
-+	if (force_nmi)
-+		pfm_intel_atom_pmu_info.flags |= PFM_X86_FL_USE_NMI;
-+
-+	return 0;
-+}
-+
-+/**
-+ * pfm_intel_atom_has_ovfls - check for pending overflow condition
-+ * @ctx: context to work on
-+ *
-+ * detect if counters have overflowed.
-+ * return:
-+ * 	0 : no overflow
-+ * 	1 : at least one overflow
-+ */
-+static int __kprobes pfm_intel_atom_has_ovfls(struct pfm_context *ctx)
-+{
-+	struct pfm_regmap_desc *d;
-+	u64 ovf;
-+
-+	d = pfm_pmu_conf->pmd_desc;
-+	/*
-+ 	 * read global overflow status register
-+ 	 * if sharing PMU, then not all bit are ours so must
-+ 	 * check only the ones we actually use
-+ 	 */
-+	rdmsrl(MSR_CORE_PERF_GLOBAL_STATUS, ovf);
-+
-+	/*
-+ 	 * for pmd0, we also check PEBS overflow on bit 62
-+ 	 */
-+	if ((d[0].type & PFM_REG_I) && (ovf & ((1ull << 62) | 1ull)))
-+		return 1;
-+
-+	if ((d[1].type & PFM_REG_I) && (ovf & 2ull))
-+		return 1;
-+
-+	if ((d[16].type & PFM_REG_I) && (ovf & (1ull << 32)))
-+		return 1;
-+
-+	if ((d[17].type & PFM_REG_I) && (ovf & (2ull << 32)))
-+		return 1;
-+
-+	if ((d[18].type & PFM_REG_I) && (ovf & (4ull << 32)))
-+		return 1;
-+
-+	return 0;
-+}
-+
-+/**
-+ * pfm_intel_atom_stop_save - stop monitoring, collect pending overflow, save pmds
-+ * @ctx: context to work on
-+ * @set: active set
-+ *
-+ * return:
-+ * 	1: caller needs to save pmds
-+ * 	0: caller does not need to save pmds, they have been saved by this call
-+ */
-+static int pfm_intel_atom_stop_save(struct pfm_context *ctx,
-+				    struct pfm_event_set *set)
-+{
-+#define PFM_ATOM_WMASK	(1ULL << 31)
-+#define PFM_ATOM_OMASK	((1ULL << 31)-1)
-+	u64 clear_ovf = 0;
-+	u64 ovf, ovf2, val;
-+
-+	/*
-+	 * read global overflow status register
-+	 * if sharing PMU, then not all bit are ours so must
-+	 * check only the ones we actually use.
-+	 *
-+	 * XXX: Atom seems to have a bug with the stickyness of
-+	 *      GLOBAL_STATUS. If we read GLOBAL_STATUS after we
-+	 *      clear the generic counters, then their bits in
-+	 *      GLOBAL_STATUS are cleared. This should not be the
-+	 *      case accoding to architected PMU. To workaround
-+	 *      the problem, we read GLOBAL_STATUS BEFORE we stop
-+	 *      all monitoring.
-+	 */
-+	rdmsrl(MSR_CORE_PERF_GLOBAL_STATUS, ovf);
-+
-+	/*
-+	 * stop monitoring
-+	 */
-+	if (test_bit(0, cast_ulp(set->used_pmcs)))
-+		wrmsrl(MSR_P6_EVNTSEL0, 0);
-+
-+	if (test_bit(1, cast_ulp(set->used_pmcs)))
-+		wrmsrl(MSR_P6_EVNTSEL1, 0);
-+
-+	if (test_bit(16, cast_ulp(set->used_pmcs)))
-+		wrmsrl(MSR_CORE_PERF_FIXED_CTR_CTRL, 0);
-+
-+	if (test_bit(17, cast_ulp(set->used_pmcs)))
-+		wrmsrl(MSR_IA32_PEBS_ENABLE, 0);
-+
-+	/*
-+	 * XXX: related to bug mentioned above
-+	 *
-+	 * read GLOBAL_STATUS again to avoid race condition
-+	 * with overflows happening after first read and
-+	 * before stop. That avoids missing overflows on
-+	 * the fixed counters and PEBS
-+	 */
-+	rdmsrl(MSR_CORE_PERF_GLOBAL_STATUS, ovf2);
-+	ovf |= ovf2;
-+
-+	/*
-+	 * if we already have a pending overflow condition, we simply
-+	 * return to take care of it first.
-+	 */
-+	if (set->npend_ovfls)
-+		return 1;
-+
-+	/*
-+ 	 * check PMD 0,1,16,17,18 for overflow and save their value
-+ 	 */
-+	if (test_bit(0, cast_ulp(set->used_pmds))) {
-+		rdmsrl(MSR_P6_PERFCTR0, val);
-+		if (ovf & ((1ull<<62)|1ull)) {
-+			__set_bit(0, cast_ulp(set->povfl_pmds));
-+			set->npend_ovfls++;
-+			clear_ovf = (1ull << 62) | 1ull;
-+		}
-+		val = (set->pmds[0].value & ~PFM_ATOM_OMASK)
-+		    | (val & PFM_ATOM_OMASK);
-+		set->pmds[0].value = val;
-+	}
-+
-+	if (test_bit(1, cast_ulp(set->used_pmds))) {
-+		rdmsrl(MSR_P6_PERFCTR1, val);
-+		 if (ovf & 2ull) {
-+			__set_bit(1, cast_ulp(set->povfl_pmds));
-+			set->npend_ovfls++;
-+			clear_ovf |= 2ull;
-+		}
-+		val = (set->pmds[1].value & ~PFM_ATOM_OMASK)
-+		    | (val & PFM_ATOM_OMASK);
-+		set->pmds[1].value = val;
-+	}
-+
-+	if (test_bit(16, cast_ulp(set->used_pmds))) {
-+		rdmsrl(MSR_CORE_PERF_FIXED_CTR0, val);
-+ 		if (ovf & (1ull << 32)) {
-+			__set_bit(16, cast_ulp(set->povfl_pmds));
-+			set->npend_ovfls++;
-+			clear_ovf |= 1ull << 32;
-+		}
-+		val = (set->pmds[16].value & ~PFM_ATOM_OMASK)
-+		    | (val & PFM_ATOM_OMASK);
-+		set->pmds[16].value = val;
-+	}
-+
-+	if (test_bit(17, cast_ulp(set->used_pmds))) {
-+		rdmsrl(MSR_CORE_PERF_FIXED_CTR0+1, val);
-+ 		if (ovf & (2ull << 32)) {
-+			__set_bit(17, cast_ulp(set->povfl_pmds));
-+			set->npend_ovfls++;
-+			clear_ovf |= 2ull << 32;
-+		}
-+		val = (set->pmds[17].value & ~PFM_ATOM_OMASK)
-+		    | (val & PFM_ATOM_OMASK);
-+		set->pmds[17].value = val;
-+	}
-+
-+	if (test_bit(18, cast_ulp(set->used_pmds))) {
-+		rdmsrl(MSR_CORE_PERF_FIXED_CTR0+2, val);
-+ 		if (ovf & (4ull << 32)) {
-+			__set_bit(18, cast_ulp(set->povfl_pmds));
-+			set->npend_ovfls++;
-+			clear_ovf |= 4ull << 32;
-+		}
-+		val = (set->pmds[18].value & ~PFM_ATOM_OMASK)
-+		    | (val & PFM_ATOM_OMASK);
-+		set->pmds[18].value = val;
-+	}
-+
-+	if (clear_ovf)
-+		wrmsrl(MSR_CORE_PERF_GLOBAL_OVF_CTRL, clear_ovf);
-+
-+	/* 0 means: no need to save PMDs at upper level */
-+	return 0;
-+}
-+
-+/**
-+ * pfm_intel_atom_quiesce - stop monitoring without grabbing any lock
-+ *
-+ * called from NMI interrupt handler to immediately stop monitoring
-+ * cannot grab any lock, including perfmon related locks
-+ */
-+static void __kprobes pfm_intel_atom_quiesce(void)
-+{
-+	/*
-+	 * quiesce PMU by clearing available registers that have
-+	 * the start/stop capability
-+	 */
-+	if (test_bit(0, cast_ulp(pfm_pmu_conf->regs_all.pmcs)))
-+		wrmsrl(MSR_P6_EVNTSEL0, 0);
-+
-+	if (test_bit(1, cast_ulp(pfm_pmu_conf->regs_all.pmcs)))
-+		wrmsrl(MSR_P6_EVNTSEL1, 0);
-+
-+	if (test_bit(16, cast_ulp(pfm_pmu_conf->regs_all.pmcs)))
-+		wrmsrl(MSR_CORE_PERF_FIXED_CTR_CTRL, 0);
-+
-+	if (test_bit(17, cast_ulp(pfm_pmu_conf->regs_all.pmcs)))
-+		wrmsrl(MSR_IA32_PEBS_ENABLE, 0);
-+}
-+
-+/**
-+ * pfm_intel_atom_restore_pmcs - reload PMC registers
-+ * @ctx: context to restore from
-+ * @set: current event set
-+ *
-+ * restores pmcs and also PEBS Data Save area pointer
-+ */
-+static void pfm_intel_atom_restore_pmcs(struct pfm_context *ctx,
-+					struct pfm_event_set *set)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+	u64 clear_ovf = 0;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+	/*
-+	 * must restore DS pointer before restoring PMCs
-+	 * as this can potentially reactivate monitoring
-+	 */
-+	if (ctx_arch->flags.use_ds)
-+		wrmsrl(MSR_IA32_DS_AREA, (unsigned long)ctx_arch->ds_area);
-+
-+	if (test_bit(0, cast_ulp(set->used_pmcs))) {
-+		wrmsrl(MSR_P6_EVNTSEL0, set->pmcs[0]);
-+		clear_ovf = 1ull;
-+	}
-+
-+	if (test_bit(1, cast_ulp(set->used_pmcs))) {
-+		wrmsrl(MSR_P6_EVNTSEL1, set->pmcs[1]);
-+		clear_ovf |= 2ull;
-+	}
-+
-+	if (test_bit(16, cast_ulp(set->used_pmcs))) {
-+		wrmsrl(MSR_CORE_PERF_FIXED_CTR_CTRL, set->pmcs[16]);
-+		clear_ovf |= 7ull << 32;
-+	}
-+
-+	if (test_bit(17, cast_ulp(set->used_pmcs))) {
-+		wrmsrl(MSR_IA32_PEBS_ENABLE, set->pmcs[17]);
-+		clear_ovf |= 1ull << 62;
-+	}
-+
-+	if (clear_ovf)
-+		wrmsrl(MSR_CORE_PERF_GLOBAL_OVF_CTRL, clear_ovf);
-+}
-+
-+static int pfm_intel_atom_pmc17_check(struct pfm_context *ctx,
-+			     	      struct pfm_event_set *set,
-+				      struct pfarg_pmc *req)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+	ctx_arch = pfm_ctx_arch(ctx);
-+
-+	/*
-+	 * if user activates PEBS_ENABLE, then we need to have a valid
-+	 * DS Area setup. This only happens when the PEBS sampling format is
-+	 * used in which case PFM_X86_USE_PEBS is set. We must reject all other
-+	 * requests.
-+	 *
-+	 * Otherwise we may pickup stale MSR_IA32_DS_AREA values. It appears
-+	 * that a value of 0 for this MSR does crash the system with
-+	 * PEBS_ENABLE=1.
-+	 */
-+	if (!ctx_arch->flags.use_pebs && req->reg_value) {
-+		PFM_DBG("pmc17 useable only with a PEBS sampling format");
-+		return -EINVAL;
-+	}
-+	return 0;
-+}
-+
-+DEFINE_PER_CPU(u64, saved_global_ctrl);
-+
-+/**
-+ * pfm_intel_atom_acquire_pmu_percpu - acquire PMU resource per CPU
-+ *
-+ * For Atom, it is necessary to enable all available
-+ * registers. The firmware rightfully has the fixed counters
-+ * disabled for backward compatibility with architectural perfmon
-+ * v1
-+ *
-+ * This function is invoked on each online CPU
-+ */
-+static void pfm_intel_atom_acquire_pmu_percpu(void)
-+{
-+	struct pfm_regmap_desc *d;
-+	u64 mask = 0;
-+	unsigned int i;
-+
-+	/*
-+ 	 * build bitmask of registers that are available to
-+ 	 * us. In some cases, there may be fewer registers than
-+ 	 * what Atom supports due to sharing with other kernel
-+ 	 * subsystems, such as NMI
-+ 	 */
-+	d = pfm_pmu_conf->pmd_desc;
-+	for (i=0; i < 16; i++) {
-+		if ((d[i].type & PFM_REG_I) == 0)
-+			continue;
-+		mask |= 1ull << i;
-+	}
-+	for (i=16; i < PFM_ATOM_MAX_PMDS; i++) {
-+		if ((d[i].type & PFM_REG_I) == 0)
-+			continue;
-+		mask |= 1ull << (32+i-16);
-+	}
-+
-+	/*
-+	 * keep a local copy of the current MSR_CORE_PERF_GLOBAL_CTRL
-+	 */
-+	rdmsrl(MSR_CORE_PERF_GLOBAL_CTRL, __get_cpu_var(saved_global_ctrl));
-+
-+	PFM_DBG("global=0x%llx set to 0x%llx",
-+		__get_cpu_var(saved_global_ctrl),
-+		mask);
-+
-+	/*
-+	 * enable all registers
-+	 *
-+	 * No need to quiesce PMU. If there is a overflow, it will be
-+	 * treated as spurious by the handler
-+	 */
-+	wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, mask);
-+}
-+
-+/**
-+ * pfm_intel_atom_release_pmu_percpu - release PMU resource per CPU
-+ *
-+ * For Atom, we restore MSR_CORE_PERF_GLOBAL_CTRL to its orginal value
-+ */
-+static void pfm_intel_atom_release_pmu_percpu(void)
-+{
-+	PFM_DBG("global_ctrl restored to 0x%llx\n",
-+			__get_cpu_var(saved_global_ctrl));
-+
-+	wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, __get_cpu_var(saved_global_ctrl));
-+}
-+
-+static struct pfm_pmu_config pfm_intel_atom_pmu_conf = {
-+	.pmu_name = "Intel Atom",
-+	.pmd_desc = pfm_intel_atom_pmd_desc,
-+	.counter_width   = PFM_ATOM_PMD_WIDTH,
-+	.num_pmc_entries = PFM_ATOM_MAX_PMCS,
-+	.num_pmd_entries = PFM_ATOM_MAX_PMDS,
-+	.pmc_desc = pfm_intel_atom_pmc_desc,
-+	.probe_pmu = pfm_intel_atom_probe_pmu,
-+	.version = "1.0",
-+	.flags = PFM_PMU_BUILTIN_FLAG,
-+	.owner = THIS_MODULE,
-+	.pmc_write_check = pfm_intel_atom_pmc17_check,
-+	.pmu_info = &pfm_intel_atom_pmu_info
-+};
-+
-+static int __init pfm_intel_atom_pmu_init_module(void)
-+{
-+	return pfm_pmu_register(&pfm_intel_atom_pmu_conf);
-+}
-+
-+static void __exit pfm_intel_atom_pmu_cleanup_module(void)
-+{
-+	pfm_pmu_unregister(&pfm_intel_atom_pmu_conf);
-+}
-+
-+module_init(pfm_intel_atom_pmu_init_module);
-+module_exit(pfm_intel_atom_pmu_cleanup_module);
-diff --git a/arch/x86/perfmon/perfmon_intel_core.c b/arch/x86/perfmon/perfmon_intel_core.c
-new file mode 100644
-index 0000000..fddc436
---- /dev/null
-+++ b/arch/x86/perfmon/perfmon_intel_core.c
-@@ -0,0 +1,449 @@
-+/*
-+ * This file contains the Intel Core PMU registers description tables.
-+ * Intel Core-based processors support architectural perfmon v2 + PEBS
-+ *
-+ * Copyright (c) 2006-2007 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ */
-+#include <linux/module.h>
-+#include <linux/kprobes.h>
-+#include <linux/perfmon_kern.h>
-+#include <linux/nmi.h>
-+
-+MODULE_AUTHOR("Stephane Eranian <eranian@hpl.hp.com>");
-+MODULE_DESCRIPTION("Intel Core");
-+MODULE_LICENSE("GPL");
-+
-+static int force_nmi;
-+MODULE_PARM_DESC(force_nmi, "bool: force use of NMI for PMU interrupt");
-+module_param(force_nmi, bool, 0600);
-+
-+/*
-+ * - upper 32 bits are reserved
-+ * - INT: APIC enable bit is reserved (forced to 1)
-+ * - bit 21 is reserved
-+ *
-+ *   RSVD: reserved bits must be 1
-+ */
-+#define PFM_CORE_PMC_RSVD ((~((1ULL<<32)-1)) \
-+			| (1ULL<<20)   \
-+			| (1ULL<<21))
-+
-+/*
-+ * Core counters are 40-bits
-+ */
-+#define PFM_CORE_CTR_RSVD	(~((1ULL<<40)-1))
-+
-+/*
-+ * force Local APIC interrupt on overflow
-+ * disable with NO_EMUL64
-+ */
-+#define PFM_CORE_PMC_VAL	(1ULL<<20)
-+#define PFM_CORE_NO64		(1ULL<<20)
-+
-+#define PFM_CORE_NA { .reg_type = PFM_REGT_NA}
-+
-+#define PFM_CORE_CA(m, c, t) \
-+	{ \
-+	  .addrs[0] = m, \
-+	  .ctr = c, \
-+	  .reg_type = t \
-+	}
-+
-+struct pfm_ds_area_intel_core {
-+	u64	bts_buf_base;
-+	u64	bts_index;
-+	u64	bts_abs_max;
-+	u64	bts_intr_thres;
-+	u64	pebs_buf_base;
-+	u64	pebs_index;
-+	u64	pebs_abs_max;
-+	u64	pebs_intr_thres;
-+	u64	pebs_cnt_reset;
-+};
-+
-+static void pfm_core_restore_pmcs(struct pfm_context *ctx,
-+				  struct pfm_event_set *set);
-+static int pfm_core_has_ovfls(struct pfm_context *ctx);
-+static int pfm_core_stop_save(struct pfm_context *ctx,
-+			      struct pfm_event_set *set);
-+static void __kprobes pfm_core_quiesce(void);
-+
-+static u64 enable_mask[PFM_MAX_PMCS];
-+static u16 max_enable;
-+
-+struct pfm_arch_pmu_info pfm_core_pmu_info = {
-+	.stop_save = pfm_core_stop_save,
-+	.has_ovfls = pfm_core_has_ovfls,
-+	.quiesce = pfm_core_quiesce,
-+	.restore_pmcs = pfm_core_restore_pmcs
-+};
-+
-+static struct pfm_regmap_desc pfm_core_pmc_desc[] = {
-+/* pmc0  */ {
-+	      .type = PFM_REG_I64,
-+	      .desc = "PERFEVTSEL0",
-+	      .dfl_val = PFM_CORE_PMC_VAL,
-+	      .rsvd_msk = PFM_CORE_PMC_RSVD,
-+	      .no_emul64_msk = PFM_CORE_NO64,
-+	      .hw_addr = MSR_P6_EVNTSEL0
-+	    },
-+/* pmc1  */ {
-+	      .type = PFM_REG_I64,
-+	      .desc = "PERFEVTSEL1",
-+	      .dfl_val = PFM_CORE_PMC_VAL,
-+	      .rsvd_msk = PFM_CORE_PMC_RSVD,
-+	      .no_emul64_msk = PFM_CORE_NO64,
-+	      .hw_addr = MSR_P6_EVNTSEL1
-+	    },
-+/* pmc2  */ PMX_NA, PMX_NA,
-+/* pmc4  */ PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc8  */ PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc12 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmc16 */ { .type = PFM_REG_I,
-+	      .desc = "FIXED_CTRL",
-+	      .dfl_val = 0x888ULL,
-+	      .rsvd_msk = 0xfffffffffffffcccULL,
-+	      .no_emul64_msk = 0,
-+	      .hw_addr = MSR_CORE_PERF_FIXED_CTR_CTRL
-+	    },
-+/* pmc17  */ { .type = PFM_REG_W,
-+	      .desc = "PEBS_ENABLE",
-+	      .dfl_val = 0,
-+	      .rsvd_msk = 0xfffffffffffffffeULL,
-+	      .no_emul64_msk = 0,
-+	      .hw_addr = MSR_IA32_PEBS_ENABLE
-+	    }
-+};
-+
-+#define PFM_CORE_D(n) \
-+	{ .type = PFM_REG_C,			\
-+	  .desc = "PMC"#n,			\
-+	  .rsvd_msk =  PFM_CORE_CTR_RSVD,	\
-+	  .hw_addr = MSR_P6_PERFCTR0+n,		\
-+	  .dep_pmcs[0] = 1ULL << n		\
-+	}
-+
-+#define PFM_CORE_FD(n) \
-+	{ .type = PFM_REG_C,			\
-+	  .desc = "FIXED_CTR"#n,		\
-+	  .rsvd_msk =  PFM_CORE_CTR_RSVD,	\
-+	  .hw_addr = MSR_CORE_PERF_FIXED_CTR0+n,\
-+	  .dep_pmcs[0] = 1ULL << 16		\
-+	}
-+
-+static struct pfm_regmap_desc pfm_core_pmd_desc[] = {
-+/* pmd0  */ PFM_CORE_D(0),
-+/* pmd1  */ PFM_CORE_D(1),
-+/* pmd2  */ PMX_NA, PMX_NA,
-+/* pmd4  */ PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmd8  */ PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmd12 */ PMX_NA, PMX_NA, PMX_NA, PMX_NA,
-+/* pmd16 */ PFM_CORE_FD(0),
-+/* pmd17 */ PFM_CORE_FD(1),
-+/* pmd18 */ PFM_CORE_FD(2)
-+};
-+#define PFM_CORE_NUM_PMCS	ARRAY_SIZE(pfm_core_pmc_desc)
-+#define PFM_CORE_NUM_PMDS	ARRAY_SIZE(pfm_core_pmd_desc)
-+
-+static struct pfm_pmu_config pfm_core_pmu_conf;
-+
-+static int pfm_core_probe_pmu(void)
-+{
-+	/*
-+	 * Check for Intel Core processor explicitely
-+	 * Checking for cpu_has_perfmon is not enough as this
-+	 * matches intel Core Duo/Core Solo but none supports
-+	 * PEBS.
-+	 *
-+	 * Intel Core = arch perfmon v2 + PEBS
-+	 */
-+	if (current_cpu_data.x86_vendor != X86_VENDOR_INTEL) {
-+		PFM_INFO("not an AMD processor");
-+		return -1;
-+	}
-+
-+	if (current_cpu_data.x86 != 6)
-+		return -1;
-+
-+	switch (current_cpu_data.x86_model) {
-+	case 15: /* Merom */
-+		break;
-+	case 23: /* Penryn */
-+		break;
-+	case 29: /* Dunnington */
-+		break;
-+	default:
-+		return -1;
-+	}
-+
-+	if (!cpu_has_apic) {
-+		PFM_INFO("no Local APIC, unsupported");
-+		return -1;
-+	}
-+
-+	PFM_INFO("nmi_watchdog=%d nmi_active=%d force_nmi=%d",
-+		nmi_watchdog, atomic_read(&nmi_active), force_nmi);
-+
-+	/*
-+	 * Intel Core processors implement DS and PEBS, no need to check
-+	 */
-+	if (cpu_has_pebs)
-+		PFM_INFO("PEBS supported, enabled");
-+
-+	/*
-+	 * initialize bitmask of register with enable capability, i.e.,
-+	 * startstop. This is used to restrict the number of registers to
-+	 * touch on start/stop
-+	 * max_enable: number of bits to scan in enable_mask = highest + 1
-+	 *
-+	 * may be adjusted in pfm_arch_pmu_acquire()
-+	 */
-+	__set_bit(0, cast_ulp(enable_mask));
-+	__set_bit(1, cast_ulp(enable_mask));
-+	__set_bit(16, cast_ulp(enable_mask));
-+	__set_bit(17, cast_ulp(enable_mask));
-+	max_enable = 17+1;
-+
-+	if (force_nmi)
-+		pfm_core_pmu_info.flags |= PFM_X86_FL_USE_NMI;
-+
-+	return 0;
-+}
-+
-+static int pfm_core_pmc17_check(struct pfm_context *ctx,
-+			     struct pfm_event_set *set,
-+			     struct pfarg_pmc *req)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+	ctx_arch = pfm_ctx_arch(ctx);
-+
-+	/*
-+	 * if user activates PEBS_ENABLE, then we need to have a valid
-+	 * DS Area setup. This only happens when the PEBS sampling format is
-+	 * used in which case PFM_X86_USE_PEBS is set. We must reject all other
-+	 * requests.
-+	 *
-+	 * Otherwise we may pickup stale MSR_IA32_DS_AREA values. It appears
-+	 * that a value of 0 for this MSR does crash the system with
-+	 * PEBS_ENABLE=1.
-+	 */
-+	if (!ctx_arch->flags.use_pebs && req->reg_value) {
-+		PFM_DBG("pmc17 useable only with a PEBS sampling format");
-+		return -EINVAL;
-+	}
-+	return 0;
-+}
-+
-+/*
-+ * detect is counters have overflowed.
-+ * return:
-+ * 	0 : no overflow
-+ * 	1 : at least one overflow
-+ *
-+ * used by Intel Core-based processors
-+ */
-+static int __kprobes pfm_core_has_ovfls(struct pfm_context *ctx)
-+{
-+	struct pfm_arch_pmu_info *pmu_info;
-+	u64 *cnt_mask;
-+	u64 wmask, val;
-+	u16 i, num;
-+
-+	pmu_info = &pfm_core_pmu_info;
-+	cnt_mask = ctx->regs.cnt_pmds;
-+	num = ctx->regs.num_counters;
-+	wmask = 1ULL << pfm_pmu_conf->counter_width;
-+
-+	for (i = 0; num; i++) {
-+		if (test_bit(i, cast_ulp(cnt_mask))) {
-+			rdmsrl(pfm_core_pmd_desc[i].hw_addr, val);
-+			if (!(val & wmask))
-+				return 1;
-+			num--;
-+		}
-+	}
-+	return 0;
-+}
-+
-+static int pfm_core_stop_save(struct pfm_context *ctx,
-+			      struct pfm_event_set *set)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+	struct pfm_ds_area_intel_core *ds = NULL;
-+	u64 used_mask[PFM_PMC_BV];
-+	u64 *cnt_mask;
-+	u64 val, wmask, ovfl_mask;
-+	u16 count, has_ovfl;
-+	u16 i, pebs_idx = ~0;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+
-+	wmask = 1ULL << pfm_pmu_conf->counter_width;
-+
-+	/*
-+	 * used enable pmc bitmask
-+	 */
-+	bitmap_and(cast_ulp(used_mask),
-+			cast_ulp(set->used_pmcs),
-+			cast_ulp(enable_mask),
-+			max_enable);
-+
-+	count = bitmap_weight(cast_ulp(used_mask), max_enable);
-+	/*
-+	 * stop monitoring
-+	 * Unfortunately, this is very expensive!
-+	 * wrmsrl() is serializing.
-+	 */
-+	for (i = 0; count; i++) {
-+		if (test_bit(i, cast_ulp(used_mask))) {
-+			wrmsrl(pfm_pmu_conf->pmc_desc[i].hw_addr, 0);
-+			count--;
-+		}
-+	}
-+	/*
-+	 * if we already having a pending overflow condition, we simply
-+	 * return to take care of this first.
-+	 */
-+	if (set->npend_ovfls)
-+		return 1;
-+
-+	ovfl_mask = pfm_pmu_conf->ovfl_mask;
-+	cnt_mask = ctx->regs.cnt_pmds;
-+
-+	if (ctx_arch->flags.use_pebs) {
-+		ds = ctx_arch->ds_area;
-+		pebs_idx = 0; /* PMC0/PMD0 */
-+		PFM_DBG("ds=%p pebs_idx=0x%llx thres=0x%llx",
-+			ds,
-+			(unsigned long long)ds->pebs_index,
-+			(unsigned long long)ds->pebs_intr_thres);
-+	}
-+
-+	/*
-+	 * Check for pending overflows and save PMDs (combo)
-+	 * We employ used_pmds and not intr_pmds because we must
-+	 * also saved on PMD registers.
-+	 * Must check for counting PMDs because of virtual PMDs
-+	 *
-+	 * XXX: should use the ovf_status register instead, yet
-+	 *      we would have to check if NMI is used and fallback
-+	 *      to individual pmd inspection.
-+	 */
-+	count = set->nused_pmds;
-+
-+	for (i = 0; count; i++) {
-+		if (test_bit(i, cast_ulp(set->used_pmds))) {
-+			val = pfm_arch_read_pmd(ctx, i);
-+			if (likely(test_bit(i, cast_ulp(cnt_mask)))) {
-+				if (i == pebs_idx)
-+					has_ovfl = (ds->pebs_index >=
-+						    ds->pebs_intr_thres);
-+				else
-+					has_ovfl = !(val & wmask);
-+				if (has_ovfl) {
-+					__set_bit(i, cast_ulp(set->povfl_pmds));
-+					set->npend_ovfls++;
-+				}
-+				val = (set->pmds[i].value & ~ovfl_mask)
-+				    | (val & ovfl_mask);
-+			}
-+			set->pmds[i].value = val;
-+			count--;
-+		}
-+	}
-+	/* 0 means: no need to save PMDs at upper level */
-+	return 0;
-+}
-+
-+/**
-+ * pfm_core_quiesce - stop monitoring without grabbing any lock
-+ *
-+ * called from NMI interrupt handler to immediately stop monitoring
-+ * cannot grab any lock, including perfmon related locks
-+ */
-+static void __kprobes pfm_core_quiesce(void)
-+{
-+	/*
-+	 * quiesce PMU by clearing available registers that have
-+	 * the start/stop capability
-+	 */
-+	if (test_bit(0, cast_ulp(pfm_pmu_conf->regs_all.pmcs)))
-+		wrmsrl(MSR_P6_EVNTSEL0, 0);
-+	if (test_bit(1, cast_ulp(pfm_pmu_conf->regs_all.pmcs)))
-+		wrmsrl(MSR_P6_EVNTSEL1, 0);
-+	if (test_bit(16, cast_ulp(pfm_pmu_conf->regs_all.pmcs)))
-+		wrmsrl(MSR_CORE_PERF_FIXED_CTR_CTRL, 0);
-+	if (test_bit(17, cast_ulp(pfm_pmu_conf->regs_all.pmcs)))
-+		wrmsrl(MSR_IA32_PEBS_ENABLE, 0);
-+}
-+/**
-+ * pfm_core_restore_pmcs - reload PMC registers
-+ * @ctx: context to restore from
-+ * @set: current event set
-+ *
-+ * optimized version of pfm_arch_restore_pmcs(). On Core, we can
-+ * afford to only restore the pmcs registers we use, because they are
-+ * all independent from each other.
-+ */
-+static void pfm_core_restore_pmcs(struct pfm_context *ctx,
-+				  struct pfm_event_set *set)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+	u64 *mask;
-+	u16 i, num;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+
-+	/*
-+	 * must restore DS pointer before restoring PMCs
-+	 * as this can potentially reactivate monitoring
-+	 */
-+	if (ctx_arch->flags.use_ds)
-+		wrmsrl(MSR_IA32_DS_AREA, (unsigned long)ctx_arch->ds_area);
-+
-+	mask = set->used_pmcs;
-+	num = set->nused_pmcs;
-+	for (i = 0; num; i++) {
-+		if (test_bit(i, cast_ulp(mask))) {
-+			wrmsrl(pfm_pmu_conf->pmc_desc[i].hw_addr, set->pmcs[i]);
-+			num--;
-+		}
-+	}
-+}
-+
-+/*
-+ * Counters may have model-specific width which can be probed using
-+ * the CPUID.0xa leaf. Yet, the documentation says: "
-+ * In the initial implementation, only the read bit width is reported
-+ * by CPUID, write operations are limited to the low 32 bits.
-+ * Bits [w-32] are sign extensions of bit 31. As such the effective width
-+ * of a counter is 31 bits only.
-+ */
-+static struct pfm_pmu_config pfm_core_pmu_conf = {
-+	.pmu_name = "Intel Core",
-+	.pmd_desc = pfm_core_pmd_desc,
-+	.counter_width = 31,
-+	.num_pmc_entries = PFM_CORE_NUM_PMCS,
-+	.num_pmd_entries = PFM_CORE_NUM_PMDS,
-+	.pmc_desc = pfm_core_pmc_desc,
-+	.probe_pmu = pfm_core_probe_pmu,
-+	.version = "1.2",
-+	.flags = PFM_PMU_BUILTIN_FLAG,
-+	.owner = THIS_MODULE,
-+	.pmu_info = &pfm_core_pmu_info,
-+	.pmc_write_check = pfm_core_pmc17_check
-+};
-+
-+static int __init pfm_core_pmu_init_module(void)
-+{
-+	return pfm_pmu_register(&pfm_core_pmu_conf);
-+}
-+
-+static void __exit pfm_core_pmu_cleanup_module(void)
-+{
-+	pfm_pmu_unregister(&pfm_core_pmu_conf);
-+}
-+
-+module_init(pfm_core_pmu_init_module);
-+module_exit(pfm_core_pmu_cleanup_module);
-diff --git a/arch/x86/perfmon/perfmon_p4.c b/arch/x86/perfmon/perfmon_p4.c
-new file mode 100644
-index 0000000..1ffcf3c
---- /dev/null
-+++ b/arch/x86/perfmon/perfmon_p4.c
-@@ -0,0 +1,913 @@
-+/*
-+ * This file contains the P4/Xeon PMU register description tables
-+ * for both 32 and 64 bit modes.
-+ *
-+ * Copyright (c) 2005 Intel Corporation
-+ * Contributed by Bryan Wilkerson <bryan.p.wilkerson@intel.com>
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+  */
-+#include <linux/module.h>
-+#include <linux/perfmon_kern.h>
-+#include <linux/kprobes.h>
-+#include <linux/nmi.h>
-+#include <asm/msr.h>
-+#include <asm/apic.h>
-+
-+MODULE_AUTHOR("Bryan Wilkerson <bryan.p.wilkerson@intel.com>");
-+MODULE_DESCRIPTION("P4/Xeon/EM64T PMU description table");
-+MODULE_LICENSE("GPL");
-+
-+static int force;
-+MODULE_PARM_DESC(force, "bool: force module to load succesfully");
-+module_param(force, bool, 0600);
-+
-+static int force_nmi;
-+MODULE_PARM_DESC(force_nmi, "bool: force use of NMI for PMU interrupt");
-+module_param(force_nmi, bool, 0600);
-+
-+/*
-+ * For extended register information in addition to address that is used
-+ * at runtime to figure out the mapping of reg addresses to logical procs
-+ * and association of registers to hardware specific features
-+ */
-+struct pfm_p4_regmap {
-+	/*
-+	 * one each for the logical CPUs.  Index 0 corresponds to T0 and
-+	 * index 1 corresponds to T1.  Index 1 can be zero if no T1
-+	 * complement reg exists.
-+	 */
-+	unsigned long addrs[2]; /* 2 = number of threads */
-+	unsigned int ctr;	/* for CCCR/PERFEVTSEL, associated counter */
-+	unsigned int reg_type;
-+};
-+
-+/*
-+ * bitmask for pfm_p4_regmap.reg_type
-+ */
-+#define PFM_REGT_NA		0x0000	/* not available */
-+#define PFM_REGT_EN		0x0001	/* has enable bit (cleared on ctxsw) */
-+#define PFM_REGT_ESCR		0x0002	/* P4: ESCR */
-+#define PFM_REGT_CCCR		0x0004	/* P4: CCCR */
-+#define PFM_REGT_PEBS		0x0010	/* PEBS related */
-+#define PFM_REGT_NOHT		0x0020	/* unavailable with HT */
-+#define PFM_REGT_CTR		0x0040	/* counter */
-+
-+/*
-+ * architecture specific context extension.
-+ * located at: (struct pfm_arch_context *)(ctx+1)
-+ */
-+struct pfm_arch_p4_context {
-+	u32	npend_ovfls;	/* P4 NMI #pending ovfls */
-+	u32	reserved;
-+	u64	povfl_pmds[PFM_PMD_BV]; /* P4 NMI overflowed counters */
-+	u64	saved_cccrs[PFM_MAX_PMCS];
-+};
-+
-+/*
-+ * ESCR reserved bitmask:
-+ * - bits 31 - 63 reserved
-+ * - T1_OS and T1_USR bits are reserved - set depending on logical proc
-+ *      user mode application should use T0_OS and T0_USR to indicate
-+ * RSVD: reserved bits must be 1
-+ */
-+#define PFM_ESCR_RSVD  ~0x000000007ffffffcULL
-+
-+/*
-+ * CCCR default value:
-+ * 	- OVF_PMI_T0=1 (bit 26)
-+ * 	- OVF_PMI_T1=0 (bit 27) (set if necessary in pfm_write_reg())
-+ * 	- all other bits are zero
-+ *
-+ * OVF_PMI is forced to zero if PFM_REGFL_NO_EMUL64 is set on CCCR
-+ */
-+#define PFM_CCCR_DFL	(1ULL<<26) | (3ULL<<16)
-+
-+/*
-+ * CCCR reserved fields:
-+ * 	- bits 0-11, 25-29, 31-63
-+ * 	- OVF_PMI (26-27), override with REGFL_NO_EMUL64
-+ *
-+ * RSVD: reserved bits must be 1
-+ */
-+#define PFM_CCCR_RSVD     ~((0xfull<<12)  \
-+			| (0x7full<<18) \
-+			| (0x1ull<<30))
-+
-+#define PFM_P4_NO64	(3ULL<<26) /* use 3 even in non HT mode */
-+
-+#define PEBS_PMD	8  /* thread0: IQ_CTR4, thread1: IQ_CTR5 */
-+
-+/*
-+ * With HyperThreading enabled:
-+ *
-+ *  The ESCRs and CCCRs are divided in half with the top half
-+ *  belonging to logical processor 0 and the bottom half going to
-+ *  logical processor 1. Thus only half of the PMU resources are
-+ *  accessible to applications.
-+ *
-+ *  PEBS is not available due to the fact that:
-+ *  	- MSR_PEBS_MATRIX_VERT is shared between the threads
-+ *      - IA32_PEBS_ENABLE is shared between the threads
-+ *
-+ * With HyperThreading disabled:
-+ *
-+ * The full set of PMU resources is exposed to applications.
-+ *
-+ * The mapping is chosen such that PMCxx -> MSR is the same
-+ * in HT and non HT mode, if register is present in HT mode.
-+ *
-+ */
-+#define PFM_REGT_NHTESCR (PFM_REGT_ESCR|PFM_REGT_NOHT)
-+#define PFM_REGT_NHTCCCR (PFM_REGT_CCCR|PFM_REGT_NOHT|PFM_REGT_EN)
-+#define PFM_REGT_NHTPEBS (PFM_REGT_PEBS|PFM_REGT_NOHT|PFM_REGT_EN)
-+#define PFM_REGT_NHTCTR  (PFM_REGT_CTR|PFM_REGT_NOHT)
-+#define PFM_REGT_ENAC    (PFM_REGT_CCCR|PFM_REGT_EN)
-+
-+static void pfm_p4_write_pmc(struct pfm_context *ctx, unsigned int cnum, u64 value);
-+static void pfm_p4_write_pmd(struct pfm_context *ctx, unsigned int cnum, u64 value);
-+static u64 pfm_p4_read_pmd(struct pfm_context *ctx, unsigned int cnum);
-+static u64 pfm_p4_read_pmc(struct pfm_context *ctx, unsigned int cnum);
-+static int pfm_p4_create_context(struct pfm_context *ctx, u32 ctx_flags);
-+static void pfm_p4_free_context(struct pfm_context *ctx);
-+static int pfm_p4_has_ovfls(struct pfm_context *ctx);
-+static int pfm_p4_stop_save(struct pfm_context *ctx, struct pfm_event_set *set);
-+static void pfm_p4_restore_pmcs(struct pfm_context *ctx, struct pfm_event_set *set);
-+static void pfm_p4_nmi_copy_state(struct pfm_context *ctx);
-+static void __kprobes pfm_p4_quiesce(void);
-+
-+static u64 enable_mask[PFM_MAX_PMCS];
-+static u16 max_enable;
-+
-+static struct pfm_p4_regmap pmc_addrs[PFM_MAX_PMCS] = {
-+	/*pmc 0 */    {{MSR_P4_BPU_ESCR0, MSR_P4_BPU_ESCR1}, 0, PFM_REGT_ESCR}, /*   BPU_ESCR0,1 */
-+	/*pmc 1 */    {{MSR_P4_IS_ESCR0, MSR_P4_IS_ESCR1}, 0, PFM_REGT_ESCR}, /*    IS_ESCR0,1 */
-+	/*pmc 2 */    {{MSR_P4_MOB_ESCR0, MSR_P4_MOB_ESCR1}, 0, PFM_REGT_ESCR}, /*   MOB_ESCR0,1 */
-+	/*pmc 3 */    {{MSR_P4_ITLB_ESCR0, MSR_P4_ITLB_ESCR1}, 0, PFM_REGT_ESCR}, /*  ITLB_ESCR0,1 */
-+	/*pmc 4 */    {{MSR_P4_PMH_ESCR0, MSR_P4_PMH_ESCR1}, 0, PFM_REGT_ESCR}, /*   PMH_ESCR0,1 */
-+	/*pmc 5 */    {{MSR_P4_IX_ESCR0, MSR_P4_IX_ESCR1}, 0, PFM_REGT_ESCR}, /*    IX_ESCR0,1 */
-+	/*pmc 6 */    {{MSR_P4_FSB_ESCR0, MSR_P4_FSB_ESCR1}, 0, PFM_REGT_ESCR}, /*   FSB_ESCR0,1 */
-+	/*pmc 7 */    {{MSR_P4_BSU_ESCR0, MSR_P4_BSU_ESCR1}, 0, PFM_REGT_ESCR}, /*   BSU_ESCR0,1 */
-+	/*pmc 8 */    {{MSR_P4_MS_ESCR0, MSR_P4_MS_ESCR1}, 0, PFM_REGT_ESCR}, /*    MS_ESCR0,1 */
-+	/*pmc 9 */    {{MSR_P4_TC_ESCR0, MSR_P4_TC_ESCR1}, 0, PFM_REGT_ESCR}, /*    TC_ESCR0,1 */
-+	/*pmc 10*/    {{MSR_P4_TBPU_ESCR0, MSR_P4_TBPU_ESCR1}, 0, PFM_REGT_ESCR}, /*  TBPU_ESCR0,1 */
-+	/*pmc 11*/    {{MSR_P4_FLAME_ESCR0, MSR_P4_FLAME_ESCR1}, 0, PFM_REGT_ESCR}, /* FLAME_ESCR0,1 */
-+	/*pmc 12*/    {{MSR_P4_FIRM_ESCR0, MSR_P4_FIRM_ESCR1}, 0, PFM_REGT_ESCR}, /*  FIRM_ESCR0,1 */
-+	/*pmc 13*/    {{MSR_P4_SAAT_ESCR0, MSR_P4_SAAT_ESCR1}, 0, PFM_REGT_ESCR}, /*  SAAT_ESCR0,1 */
-+	/*pmc 14*/    {{MSR_P4_U2L_ESCR0, MSR_P4_U2L_ESCR1}, 0, PFM_REGT_ESCR}, /*   U2L_ESCR0,1 */
-+	/*pmc 15*/    {{MSR_P4_DAC_ESCR0, MSR_P4_DAC_ESCR1}, 0, PFM_REGT_ESCR}, /*   DAC_ESCR0,1 */
-+	/*pmc 16*/    {{MSR_P4_IQ_ESCR0, MSR_P4_IQ_ESCR1}, 0, PFM_REGT_ESCR}, /*    IQ_ESCR0,1 (only model 1 and 2) */
-+	/*pmc 17*/    {{MSR_P4_ALF_ESCR0, MSR_P4_ALF_ESCR1}, 0, PFM_REGT_ESCR}, /*   ALF_ESCR0,1 */
-+	/*pmc 18*/    {{MSR_P4_RAT_ESCR0, MSR_P4_RAT_ESCR1}, 0, PFM_REGT_ESCR}, /*   RAT_ESCR0,1 */
-+	/*pmc 19*/    {{MSR_P4_SSU_ESCR0, 0}, 0, PFM_REGT_ESCR}, /*   SSU_ESCR0   */
-+	/*pmc 20*/    {{MSR_P4_CRU_ESCR0, MSR_P4_CRU_ESCR1}, 0, PFM_REGT_ESCR}, /*   CRU_ESCR0,1 */
-+	/*pmc 21*/    {{MSR_P4_CRU_ESCR2, MSR_P4_CRU_ESCR3}, 0, PFM_REGT_ESCR}, /*   CRU_ESCR2,3 */
-+	/*pmc 22*/    {{MSR_P4_CRU_ESCR4, MSR_P4_CRU_ESCR5}, 0, PFM_REGT_ESCR}, /*   CRU_ESCR4,5 */
-+
-+	/*pmc 23*/    {{MSR_P4_BPU_CCCR0, MSR_P4_BPU_CCCR2}, 0, PFM_REGT_ENAC}, /*   BPU_CCCR0,2 */
-+	/*pmc 24*/    {{MSR_P4_BPU_CCCR1, MSR_P4_BPU_CCCR3}, 1, PFM_REGT_ENAC}, /*   BPU_CCCR1,3 */
-+	/*pmc 25*/    {{MSR_P4_MS_CCCR0, MSR_P4_MS_CCCR2}, 2, PFM_REGT_ENAC}, /*    MS_CCCR0,2 */
-+	/*pmc 26*/    {{MSR_P4_MS_CCCR1, MSR_P4_MS_CCCR3}, 3, PFM_REGT_ENAC}, /*    MS_CCCR1,3 */
-+	/*pmc 27*/    {{MSR_P4_FLAME_CCCR0, MSR_P4_FLAME_CCCR2}, 4, PFM_REGT_ENAC}, /* FLAME_CCCR0,2 */
-+	/*pmc 28*/    {{MSR_P4_FLAME_CCCR1, MSR_P4_FLAME_CCCR3}, 5, PFM_REGT_ENAC}, /* FLAME_CCCR1,3 */
-+	/*pmc 29*/    {{MSR_P4_IQ_CCCR0, MSR_P4_IQ_CCCR2}, 6, PFM_REGT_ENAC}, /*    IQ_CCCR0,2 */
-+	/*pmc 30*/    {{MSR_P4_IQ_CCCR1, MSR_P4_IQ_CCCR3}, 7, PFM_REGT_ENAC}, /*    IQ_CCCR1,3 */
-+	/*pmc 31*/    {{MSR_P4_IQ_CCCR4, MSR_P4_IQ_CCCR5}, 8, PFM_REGT_ENAC}, /*    IQ_CCCR4,5 */
-+	/* non HT extensions */
-+	/*pmc 32*/    {{MSR_P4_BPU_ESCR1,    0},  0, PFM_REGT_NHTESCR}, /*   BPU_ESCR1   */
-+	/*pmc 33*/    {{MSR_P4_IS_ESCR1,     0},  0, PFM_REGT_NHTESCR}, /*    IS_ESCR1   */
-+	/*pmc 34*/    {{MSR_P4_MOB_ESCR1,    0},  0, PFM_REGT_NHTESCR}, /*   MOB_ESCR1   */
-+	/*pmc 35*/    {{MSR_P4_ITLB_ESCR1,   0},  0, PFM_REGT_NHTESCR}, /*  ITLB_ESCR1   */
-+	/*pmc 36*/    {{MSR_P4_PMH_ESCR1,    0},  0, PFM_REGT_NHTESCR}, /*   PMH_ESCR1   */
-+	/*pmc 37*/    {{MSR_P4_IX_ESCR1,     0},  0, PFM_REGT_NHTESCR}, /*    IX_ESCR1   */
-+	/*pmc 38*/    {{MSR_P4_FSB_ESCR1,    0},  0, PFM_REGT_NHTESCR}, /*   FSB_ESCR1   */
-+	/*pmc 39*/    {{MSR_P4_BSU_ESCR1,    0},  0, PFM_REGT_NHTESCR}, /*   BSU_ESCR1   */
-+	/*pmc 40*/    {{MSR_P4_MS_ESCR1,     0},  0, PFM_REGT_NHTESCR}, /*    MS_ESCR1   */
-+	/*pmc 41*/    {{MSR_P4_TC_ESCR1,     0},  0, PFM_REGT_NHTESCR}, /*    TC_ESCR1   */
-+	/*pmc 42*/    {{MSR_P4_TBPU_ESCR1,   0},  0, PFM_REGT_NHTESCR}, /*  TBPU_ESCR1   */
-+	/*pmc 43*/    {{MSR_P4_FLAME_ESCR1,  0},  0, PFM_REGT_NHTESCR}, /* FLAME_ESCR1   */
-+	/*pmc 44*/    {{MSR_P4_FIRM_ESCR1,   0},  0, PFM_REGT_NHTESCR}, /*  FIRM_ESCR1   */
-+	/*pmc 45*/    {{MSR_P4_SAAT_ESCR1,   0},  0, PFM_REGT_NHTESCR}, /*  SAAT_ESCR1   */
-+	/*pmc 46*/    {{MSR_P4_U2L_ESCR1,    0},  0, PFM_REGT_NHTESCR}, /*   U2L_ESCR1   */
-+	/*pmc 47*/    {{MSR_P4_DAC_ESCR1,    0},  0, PFM_REGT_NHTESCR}, /*   DAC_ESCR1   */
-+	/*pmc 48*/    {{MSR_P4_IQ_ESCR1,     0},  0, PFM_REGT_NHTESCR}, /*    IQ_ESCR1   (only model 1 and 2) */
-+	/*pmc 49*/    {{MSR_P4_ALF_ESCR1,    0},  0, PFM_REGT_NHTESCR}, /*   ALF_ESCR1   */
-+	/*pmc 50*/    {{MSR_P4_RAT_ESCR1,    0},  0, PFM_REGT_NHTESCR}, /*   RAT_ESCR1   */
-+	/*pmc 51*/    {{MSR_P4_CRU_ESCR1,    0},  0, PFM_REGT_NHTESCR}, /*   CRU_ESCR1   */
-+	/*pmc 52*/    {{MSR_P4_CRU_ESCR3,    0},  0, PFM_REGT_NHTESCR}, /*   CRU_ESCR3   */
-+	/*pmc 53*/    {{MSR_P4_CRU_ESCR5,    0},  0, PFM_REGT_NHTESCR}, /*   CRU_ESCR5   */
-+	/*pmc 54*/    {{MSR_P4_BPU_CCCR1,    0},  9, PFM_REGT_NHTCCCR}, /*   BPU_CCCR1   */
-+	/*pmc 55*/    {{MSR_P4_BPU_CCCR3,    0}, 10, PFM_REGT_NHTCCCR}, /*   BPU_CCCR3   */
-+	/*pmc 56*/    {{MSR_P4_MS_CCCR1,     0}, 11, PFM_REGT_NHTCCCR}, /*    MS_CCCR1   */
-+	/*pmc 57*/    {{MSR_P4_MS_CCCR3,     0}, 12, PFM_REGT_NHTCCCR}, /*    MS_CCCR3   */
-+	/*pmc 58*/    {{MSR_P4_FLAME_CCCR1,  0}, 13, PFM_REGT_NHTCCCR}, /* FLAME_CCCR1   */
-+	/*pmc 59*/    {{MSR_P4_FLAME_CCCR3,  0}, 14, PFM_REGT_NHTCCCR}, /* FLAME_CCCR3   */
-+	/*pmc 60*/    {{MSR_P4_IQ_CCCR2,     0}, 15, PFM_REGT_NHTCCCR}, /*    IQ_CCCR2   */
-+	/*pmc 61*/    {{MSR_P4_IQ_CCCR3,     0}, 16, PFM_REGT_NHTCCCR}, /*    IQ_CCCR3   */
-+	/*pmc 62*/    {{MSR_P4_IQ_CCCR5,     0}, 17, PFM_REGT_NHTCCCR}, /*    IQ_CCCR5   */
-+	/*pmc 63*/    {{0x3f2,     0}, 0, PFM_REGT_NHTPEBS},/* PEBS_MATRIX_VERT */
-+	/*pmc 64*/    {{0x3f1,     0}, 0, PFM_REGT_NHTPEBS} /* PEBS_ENABLE   */
-+};
-+
-+static struct pfm_p4_regmap pmd_addrs[PFM_MAX_PMDS] = {
-+	/*pmd 0 */    {{MSR_P4_BPU_PERFCTR0, MSR_P4_BPU_PERFCTR2}, 0, PFM_REGT_CTR},  /*   BPU_CTR0,2  */
-+	/*pmd 1 */    {{MSR_P4_BPU_PERFCTR1, MSR_P4_BPU_PERFCTR3}, 0, PFM_REGT_CTR},  /*   BPU_CTR1,3  */
-+	/*pmd 2 */    {{MSR_P4_MS_PERFCTR0, MSR_P4_MS_PERFCTR2}, 0, PFM_REGT_CTR},  /*    MS_CTR0,2  */
-+	/*pmd 3 */    {{MSR_P4_MS_PERFCTR1, MSR_P4_MS_PERFCTR3}, 0, PFM_REGT_CTR},  /*    MS_CTR1,3  */
-+	/*pmd 4 */    {{MSR_P4_FLAME_PERFCTR0, MSR_P4_FLAME_PERFCTR2}, 0, PFM_REGT_CTR},  /* FLAME_CTR0,2  */
-+	/*pmd 5 */    {{MSR_P4_FLAME_PERFCTR1, MSR_P4_FLAME_PERFCTR3}, 0, PFM_REGT_CTR},  /* FLAME_CTR1,3  */
-+	/*pmd 6 */    {{MSR_P4_IQ_PERFCTR0, MSR_P4_IQ_PERFCTR2}, 0, PFM_REGT_CTR},  /*    IQ_CTR0,2  */
-+	/*pmd 7 */    {{MSR_P4_IQ_PERFCTR1, MSR_P4_IQ_PERFCTR3}, 0, PFM_REGT_CTR},  /*    IQ_CTR1,3  */
-+	/*pmd 8 */    {{MSR_P4_IQ_PERFCTR4, MSR_P4_IQ_PERFCTR5}, 0, PFM_REGT_CTR},  /*    IQ_CTR4,5  */
-+	/*
-+	 * non HT extensions
-+	 */
-+	/*pmd 9 */    {{MSR_P4_BPU_PERFCTR2,     0}, 0, PFM_REGT_NHTCTR},  /*   BPU_CTR2    */
-+	/*pmd 10*/    {{MSR_P4_BPU_PERFCTR3,     0}, 0, PFM_REGT_NHTCTR},  /*   BPU_CTR3    */
-+	/*pmd 11*/    {{MSR_P4_MS_PERFCTR2,     0}, 0, PFM_REGT_NHTCTR},  /*    MS_CTR2    */
-+	/*pmd 12*/    {{MSR_P4_MS_PERFCTR3,     0}, 0, PFM_REGT_NHTCTR},  /*    MS_CTR3    */
-+	/*pmd 13*/    {{MSR_P4_FLAME_PERFCTR2,     0}, 0, PFM_REGT_NHTCTR},  /* FLAME_CTR2    */
-+	/*pmd 14*/    {{MSR_P4_FLAME_PERFCTR3,     0}, 0, PFM_REGT_NHTCTR},  /* FLAME_CTR3    */
-+	/*pmd 15*/    {{MSR_P4_IQ_PERFCTR2,     0}, 0, PFM_REGT_NHTCTR},  /*    IQ_CTR2    */
-+	/*pmd 16*/    {{MSR_P4_IQ_PERFCTR3,     0}, 0, PFM_REGT_NHTCTR},  /*    IQ_CTR3    */
-+	/*pmd 17*/    {{MSR_P4_IQ_PERFCTR5,     0}, 0, PFM_REGT_NHTCTR},  /*    IQ_CTR5    */
-+};
-+
-+static struct pfm_arch_pmu_info pfm_p4_pmu_info = {
-+	.write_pmc = pfm_p4_write_pmc,
-+	.write_pmd = pfm_p4_write_pmd,
-+	.read_pmc = pfm_p4_read_pmc,
-+	.read_pmd = pfm_p4_read_pmd,
-+	.create_context = pfm_p4_create_context,
-+	.free_context = pfm_p4_free_context,
-+	.has_ovfls = pfm_p4_has_ovfls,
-+	.stop_save = pfm_p4_stop_save,
-+	.restore_pmcs = pfm_p4_restore_pmcs,
-+	.nmi_copy_state = pfm_p4_nmi_copy_state,
-+	.quiesce = pfm_p4_quiesce
-+};
-+
-+static struct pfm_regmap_desc pfm_p4_pmc_desc[] = {
-+/* pmc0  */ PMC_D(PFM_REG_I, "BPU_ESCR0"  , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_BPU_ESCR0),
-+/* pmc1  */ PMC_D(PFM_REG_I, "IS_ESCR0"   , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_IQ_ESCR0),
-+/* pmc2  */ PMC_D(PFM_REG_I, "MOB_ESCR0"  , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_MOB_ESCR0),
-+/* pmc3  */ PMC_D(PFM_REG_I, "ITLB_ESCR0" , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_ITLB_ESCR0),
-+/* pmc4  */ PMC_D(PFM_REG_I, "PMH_ESCR0"  , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_PMH_ESCR0),
-+/* pmc5  */ PMC_D(PFM_REG_I, "IX_ESCR0"   , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_IX_ESCR0),
-+/* pmc6  */ PMC_D(PFM_REG_I, "FSB_ESCR0"  , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_FSB_ESCR0),
-+/* pmc7  */ PMC_D(PFM_REG_I, "BSU_ESCR0"  , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_BSU_ESCR0),
-+/* pmc8  */ PMC_D(PFM_REG_I, "MS_ESCR0"   , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_MS_ESCR0),
-+/* pmc9  */ PMC_D(PFM_REG_I, "TC_ESCR0"   , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_TC_ESCR0),
-+/* pmc10 */ PMC_D(PFM_REG_I, "TBPU_ESCR0" , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_TBPU_ESCR0),
-+/* pmc11 */ PMC_D(PFM_REG_I, "FLAME_ESCR0", 0x0, PFM_ESCR_RSVD, 0, MSR_P4_FLAME_ESCR0),
-+/* pmc12 */ PMC_D(PFM_REG_I, "FIRM_ESCR0" , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_FIRM_ESCR0),
-+/* pmc13 */ PMC_D(PFM_REG_I, "SAAT_ESCR0" , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_SAAT_ESCR0),
-+/* pmc14 */ PMC_D(PFM_REG_I, "U2L_ESCR0"  , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_U2L_ESCR0),
-+/* pmc15 */ PMC_D(PFM_REG_I, "DAC_ESCR0"  , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_DAC_ESCR0),
-+/* pmc16 */ PMC_D(PFM_REG_I, "IQ_ESCR0"   , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_IQ_ESCR0), /* only model 1 and 2*/
-+/* pmc17 */ PMC_D(PFM_REG_I, "ALF_ESCR0"  , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_ALF_ESCR0),
-+/* pmc18 */ PMC_D(PFM_REG_I, "RAT_ESCR0"  , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_RAT_ESCR0),
-+/* pmc19 */ PMC_D(PFM_REG_I, "SSU_ESCR0"  , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_SSU_ESCR0),
-+/* pmc20 */ PMC_D(PFM_REG_I, "CRU_ESCR0"  , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_CRU_ESCR0),
-+/* pmc21 */ PMC_D(PFM_REG_I, "CRU_ESCR2"  , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_CRU_ESCR2),
-+/* pmc22 */ PMC_D(PFM_REG_I, "CRU_ESCR4"  , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_CRU_ESCR4),
-+/* pmc23 */ PMC_D(PFM_REG_I64, "BPU_CCCR0"  , PFM_CCCR_DFL, PFM_CCCR_RSVD, PFM_P4_NO64, MSR_P4_BPU_CCCR0),
-+/* pmc24 */ PMC_D(PFM_REG_I64, "BPU_CCCR1"  , PFM_CCCR_DFL, PFM_CCCR_RSVD, PFM_P4_NO64, MSR_P4_BPU_CCCR1),
-+/* pmc25 */ PMC_D(PFM_REG_I64, "MS_CCCR0"   , PFM_CCCR_DFL, PFM_CCCR_RSVD, PFM_P4_NO64, MSR_P4_MS_CCCR0),
-+/* pmc26 */ PMC_D(PFM_REG_I64, "MS_CCCR1"   , PFM_CCCR_DFL, PFM_CCCR_RSVD, PFM_P4_NO64, MSR_P4_MS_CCCR1),
-+/* pmc27 */ PMC_D(PFM_REG_I64, "FLAME_CCCR0", PFM_CCCR_DFL, PFM_CCCR_RSVD, PFM_P4_NO64, MSR_P4_FLAME_CCCR0),
-+/* pmc28 */ PMC_D(PFM_REG_I64, "FLAME_CCCR1", PFM_CCCR_DFL, PFM_CCCR_RSVD, PFM_P4_NO64, MSR_P4_FLAME_CCCR1),
-+/* pmc29 */ PMC_D(PFM_REG_I64, "IQ_CCCR0"   , PFM_CCCR_DFL, PFM_CCCR_RSVD, PFM_P4_NO64, MSR_P4_IQ_CCCR0),
-+/* pmc30 */ PMC_D(PFM_REG_I64, "IQ_CCCR1"   , PFM_CCCR_DFL, PFM_CCCR_RSVD, PFM_P4_NO64, MSR_P4_IQ_CCCR1),
-+/* pmc31 */ PMC_D(PFM_REG_I64, "IQ_CCCR4"   , PFM_CCCR_DFL, PFM_CCCR_RSVD, PFM_P4_NO64, MSR_P4_IQ_CCCR4),
-+		/* No HT extension */
-+/* pmc32 */ PMC_D(PFM_REG_I, "BPU_ESCR1"  , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_BPU_ESCR1),
-+/* pmc33 */ PMC_D(PFM_REG_I, "IS_ESCR1"   , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_IS_ESCR1),
-+/* pmc34 */ PMC_D(PFM_REG_I, "MOB_ESCR1"  , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_MOB_ESCR1),
-+/* pmc35 */ PMC_D(PFM_REG_I, "ITLB_ESCR1" , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_ITLB_ESCR1),
-+/* pmc36 */ PMC_D(PFM_REG_I, "PMH_ESCR1"  , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_PMH_ESCR1),
-+/* pmc37 */ PMC_D(PFM_REG_I, "IX_ESCR1"   , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_IX_ESCR1),
-+/* pmc38 */ PMC_D(PFM_REG_I, "FSB_ESCR1"  , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_FSB_ESCR1),
-+/* pmc39 */ PMC_D(PFM_REG_I, "BSU_ESCR1"  , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_BSU_ESCR1),
-+/* pmc40 */ PMC_D(PFM_REG_I, "MS_ESCR1"   , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_MS_ESCR1),
-+/* pmc41 */ PMC_D(PFM_REG_I, "TC_ESCR1"   , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_TC_ESCR1),
-+/* pmc42 */ PMC_D(PFM_REG_I, "TBPU_ESCR1" , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_TBPU_ESCR1),
-+/* pmc43 */ PMC_D(PFM_REG_I, "FLAME_ESCR1", 0x0, PFM_ESCR_RSVD, 0, MSR_P4_FLAME_ESCR1),
-+/* pmc44 */ PMC_D(PFM_REG_I, "FIRM_ESCR1" , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_FIRM_ESCR1),
-+/* pmc45 */ PMC_D(PFM_REG_I, "SAAT_ESCR1" , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_SAAT_ESCR1),
-+/* pmc46 */ PMC_D(PFM_REG_I, "U2L_ESCR1"  , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_U2L_ESCR1),
-+/* pmc47 */ PMC_D(PFM_REG_I, "DAC_ESCR1"  , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_DAC_ESCR1),
-+/* pmc48 */ PMC_D(PFM_REG_I, "IQ_ESCR1"   , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_IQ_ESCR1), /* only model 1 and 2 */
-+/* pmc49 */ PMC_D(PFM_REG_I, "ALF_ESCR1"  , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_ALF_ESCR1),
-+/* pmc50 */ PMC_D(PFM_REG_I, "RAT_ESCR1"  , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_RAT_ESCR1),
-+/* pmc51 */ PMC_D(PFM_REG_I, "CRU_ESCR1"  , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_CRU_ESCR1),
-+/* pmc52 */ PMC_D(PFM_REG_I, "CRU_ESCR3"  , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_CRU_ESCR3),
-+/* pmc53 */ PMC_D(PFM_REG_I, "CRU_ESCR5"  , 0x0, PFM_ESCR_RSVD, 0, MSR_P4_CRU_ESCR5),
-+/* pmc54 */ PMC_D(PFM_REG_I64, "BPU_CCCR2"  , PFM_CCCR_DFL, PFM_CCCR_RSVD, PFM_P4_NO64, MSR_P4_BPU_CCCR2),
-+/* pmc55 */ PMC_D(PFM_REG_I64, "BPU_CCCR3"  , PFM_CCCR_DFL, PFM_CCCR_RSVD, PFM_P4_NO64, MSR_P4_BPU_CCCR3),
-+/* pmc56 */ PMC_D(PFM_REG_I64, "MS_CCCR2"   , PFM_CCCR_DFL, PFM_CCCR_RSVD, PFM_P4_NO64, MSR_P4_MS_CCCR2),
-+/* pmc57 */ PMC_D(PFM_REG_I64, "MS_CCCR3"   , PFM_CCCR_DFL, PFM_CCCR_RSVD, PFM_P4_NO64, MSR_P4_MS_CCCR3),
-+/* pmc58 */ PMC_D(PFM_REG_I64, "FLAME_CCCR2", PFM_CCCR_DFL, PFM_CCCR_RSVD, PFM_P4_NO64, MSR_P4_FLAME_CCCR2),
-+/* pmc59 */ PMC_D(PFM_REG_I64, "FLAME_CCCR3", PFM_CCCR_DFL, PFM_CCCR_RSVD, PFM_P4_NO64, MSR_P4_FLAME_CCCR3),
-+/* pmc60 */ PMC_D(PFM_REG_I64, "IQ_CCCR2"   , PFM_CCCR_DFL, PFM_CCCR_RSVD, PFM_P4_NO64, MSR_P4_IQ_CCCR2),
-+/* pmc61 */ PMC_D(PFM_REG_I64, "IQ_CCCR3"   , PFM_CCCR_DFL, PFM_CCCR_RSVD, PFM_P4_NO64, MSR_P4_IQ_CCCR3),
-+/* pmc62 */ PMC_D(PFM_REG_I64, "IQ_CCCR5"   , PFM_CCCR_DFL, PFM_CCCR_RSVD, PFM_P4_NO64, MSR_P4_IQ_CCCR5),
-+/* pmc63 */ PMC_D(PFM_REG_I, "PEBS_MATRIX_VERT", 0, 0xffffffffffffffecULL, 0, 0x3f2),
-+/* pmc64 */ PMC_D(PFM_REG_I, "PEBS_ENABLE", 0, 0xfffffffff8ffe000ULL, 0, 0x3f1)
-+};
-+#define PFM_P4_NUM_PMCS ARRAY_SIZE(pfm_p4_pmc_desc)
-+
-+/*
-+ * See section 15.10.6.6 for details about the IQ block
-+ */
-+static struct pfm_regmap_desc pfm_p4_pmd_desc[] = {
-+/* pmd0  */ PMD_D(PFM_REG_C, "BPU_CTR0", MSR_P4_BPU_PERFCTR0),
-+/* pmd1  */ PMD_D(PFM_REG_C, "BPU_CTR1", MSR_P4_BPU_PERFCTR1),
-+/* pmd2  */ PMD_D(PFM_REG_C, "MS_CTR0", MSR_P4_MS_PERFCTR0),
-+/* pmd3  */ PMD_D(PFM_REG_C, "MS_CTR1", MSR_P4_MS_PERFCTR1),
-+/* pmd4  */ PMD_D(PFM_REG_C, "FLAME_CTR0", MSR_P4_FLAME_PERFCTR0),
-+/* pmd5  */ PMD_D(PFM_REG_C, "FLAME_CTR1", MSR_P4_FLAME_PERFCTR1),
-+/* pmd6  */ PMD_D(PFM_REG_C, "IQ_CTR0", MSR_P4_IQ_PERFCTR0),
-+/* pmd7  */ PMD_D(PFM_REG_C, "IQ_CTR1", MSR_P4_IQ_PERFCTR1),
-+/* pmd8  */ PMD_D(PFM_REG_C, "IQ_CTR4", MSR_P4_IQ_PERFCTR4),
-+		/* no HT extension */
-+/* pmd9  */ PMD_D(PFM_REG_C, "BPU_CTR2", MSR_P4_BPU_PERFCTR2),
-+/* pmd10 */ PMD_D(PFM_REG_C, "BPU_CTR3", MSR_P4_BPU_PERFCTR3),
-+/* pmd11 */ PMD_D(PFM_REG_C, "MS_CTR2", MSR_P4_MS_PERFCTR2),
-+/* pmd12 */ PMD_D(PFM_REG_C, "MS_CTR3", MSR_P4_MS_PERFCTR3),
-+/* pmd13 */ PMD_D(PFM_REG_C, "FLAME_CTR2", MSR_P4_FLAME_PERFCTR2),
-+/* pmd14 */ PMD_D(PFM_REG_C, "FLAME_CTR3", MSR_P4_FLAME_PERFCTR3),
-+/* pmd15 */ PMD_D(PFM_REG_C, "IQ_CTR2", MSR_P4_IQ_PERFCTR2),
-+/* pmd16 */ PMD_D(PFM_REG_C, "IQ_CTR3", MSR_P4_IQ_PERFCTR3),
-+/* pmd17 */ PMD_D(PFM_REG_C, "IQ_CTR5", MSR_P4_IQ_PERFCTR5)
-+};
-+#define PFM_P4_NUM_PMDS ARRAY_SIZE(pfm_p4_pmd_desc)
-+
-+/*
-+ * Due to hotplug CPU support, threads may not necessarily
-+ * be activated at the time the module is inserted. We need
-+ * to check whether  they could be activated by looking at
-+ * the present CPU (present != online).
-+ */
-+static int pfm_p4_probe_pmu(void)
-+{
-+	unsigned int i;
-+	int ht_enabled;
-+
-+	/*
-+	 * only works on Intel processors
-+	 */
-+	if (current_cpu_data.x86_vendor != X86_VENDOR_INTEL) {
-+		PFM_INFO("not running on Intel processor");
-+		return -1;
-+	}
-+
-+	if (current_cpu_data.x86 != 15) {
-+		PFM_INFO("unsupported family=%d", current_cpu_data.x86);
-+		return -1;
-+	}
-+
-+	switch (current_cpu_data.x86_model) {
-+	case 0 ... 2:
-+		break;
-+	case 3 ... 6:
-+		/*
-+		 * IQ_ESCR0, IQ_ESCR1 only present on model 1, 2
-+		 */
-+		pfm_p4_pmc_desc[16].type = PFM_REG_NA;
-+		pfm_p4_pmc_desc[48].type = PFM_REG_NA;
-+		break;
-+	default:
-+		/*
-+		 * do not know if they all work the same, so reject
-+		 * for now
-+		 */
-+		if (!force) {
-+			PFM_INFO("unsupported model %d",
-+				 current_cpu_data.x86_model);
-+			return -1;
-+		}
-+	}
-+
-+	/*
-+	 * check for local APIC (required)
-+	 */
-+	if (!cpu_has_apic) {
-+		PFM_INFO("no local APIC, unsupported");
-+		return -1;
-+	}
-+#ifdef CONFIG_SMP
-+	ht_enabled = (cpus_weight(__get_cpu_var(cpu_core_map))
-+		   / current_cpu_data.x86_max_cores) > 1;
-+#else
-+	ht_enabled = 0;
-+#endif
-+	if (cpu_has_ht) {
-+
-+		PFM_INFO("HyperThreading supported, status %s",
-+			 ht_enabled ? "on": "off");
-+		/*
-+		 * disable registers not supporting HT
-+		 */
-+		if (ht_enabled) {
-+			PFM_INFO("disabling half the registers for HT");
-+			for (i = 0; i < PFM_P4_NUM_PMCS; i++) {
-+				if (pmc_addrs[(i)].reg_type & PFM_REGT_NOHT)
-+					pfm_p4_pmc_desc[i].type = PFM_REG_NA;
-+			}
-+			for (i = 0; i < PFM_P4_NUM_PMDS; i++) {
-+				if (pmd_addrs[(i)].reg_type & PFM_REGT_NOHT)
-+					pfm_p4_pmd_desc[i].type = PFM_REG_NA;
-+			}
-+		}
-+	}
-+
-+	if (cpu_has_ds) {
-+		PFM_INFO("Data Save Area (DS) supported");
-+
-+		if (cpu_has_pebs) {
-+			/*
-+			 * PEBS does not work with HyperThreading enabled
-+			 */
-+			if (ht_enabled)
-+				PFM_INFO("PEBS supported, status off (because of HT)");
-+			else
-+				PFM_INFO("PEBS supported, status on");
-+		}
-+	}
-+
-+	/*
-+	 * build enable mask
-+	 */
-+	for (i = 0; i < PFM_P4_NUM_PMCS; i++) {
-+		if (pmc_addrs[(i)].reg_type & PFM_REGT_EN) {
-+			__set_bit(i, cast_ulp(enable_mask));
-+			max_enable = i + 1;
-+		}
-+	}
-+
-+	if (force_nmi)
-+		pfm_p4_pmu_info.flags |= PFM_X86_FL_USE_NMI;
-+	return 0;
-+}
-+static inline int get_smt_id(void)
-+{
-+#ifdef CONFIG_SMP
-+	int cpu = smp_processor_id();
-+	return (cpu != first_cpu(__get_cpu_var(cpu_sibling_map)));
-+#else
-+	return 0;
-+#endif
-+}
-+
-+static void __pfm_write_reg_p4(const struct pfm_p4_regmap *xreg, u64 val)
-+{
-+	u64 pmi;
-+	int smt_id;
-+
-+	smt_id = get_smt_id();
-+	/*
-+	 * HT is only supported by P4-style PMU
-+	 *
-+	 * Adjust for T1 if necessary:
-+	 *
-+	 * - move the T0_OS/T0_USR bits into T1 slots
-+	 * - move the OVF_PMI_T0 bits into T1 slot
-+	 *
-+	 * The P4/EM64T T1 is cleared by description table.
-+	 * User only works with T0.
-+	 */
-+	if (smt_id) {
-+		if (xreg->reg_type & PFM_REGT_ESCR) {
-+
-+			/* copy T0_USR & T0_OS to T1 */
-+			val |= ((val & 0xc) >> 2);
-+
-+			/* clear bits T0_USR & T0_OS */
-+			val &= ~0xc;
-+
-+		} else if (xreg->reg_type & PFM_REGT_CCCR) {
-+			pmi = (val >> 26) & 0x1;
-+			if (pmi) {
-+				val &= ~(1UL<<26);
-+				val |= 1UL<<27;
-+			}
-+		}
-+	}
-+	if (xreg->addrs[smt_id])
-+		wrmsrl(xreg->addrs[smt_id], val);
-+}
-+
-+void __pfm_read_reg_p4(const struct pfm_p4_regmap *xreg, u64 *val)
-+{
-+	int smt_id;
-+
-+	smt_id = get_smt_id();
-+
-+	if (likely(xreg->addrs[smt_id])) {
-+		rdmsrl(xreg->addrs[smt_id], *val);
-+		/*
-+		 * HT is only supported by P4-style PMU
-+		 *
-+		 * move the Tx_OS and Tx_USR bits into
-+		 * T0 slots setting the T1 slots to zero
-+		 */
-+		if (xreg->reg_type & PFM_REGT_ESCR) {
-+			if (smt_id)
-+				*val |= (((*val) & 0x3) << 2);
-+
-+			/*
-+			 * zero out bits that are reserved
-+			 * (including T1_OS and T1_USR)
-+			 */
-+			*val &= PFM_ESCR_RSVD;
-+		}
-+	} else {
-+		*val = 0;
-+	}
-+}
-+static void pfm_p4_write_pmc(struct pfm_context *ctx, unsigned int cnum, u64 value)
-+{
-+	__pfm_write_reg_p4(&pmc_addrs[cnum], value);
-+}
-+
-+static void pfm_p4_write_pmd(struct pfm_context *ctx, unsigned int cnum, u64 value)
-+{
-+	__pfm_write_reg_p4(&pmd_addrs[cnum], value);
-+}
-+
-+static u64 pfm_p4_read_pmd(struct pfm_context *ctx, unsigned int cnum)
-+{
-+	u64 tmp;
-+	__pfm_read_reg_p4(&pmd_addrs[cnum], &tmp);
-+	return tmp;
-+}
-+
-+static u64 pfm_p4_read_pmc(struct pfm_context *ctx, unsigned int cnum)
-+{
-+	u64 tmp;
-+	__pfm_read_reg_p4(&pmc_addrs[cnum], &tmp);
-+	return tmp;
-+}
-+
-+struct pfm_ds_area_p4 {
-+	unsigned long	bts_buf_base;
-+	unsigned long	bts_index;
-+	unsigned long	bts_abs_max;
-+	unsigned long	bts_intr_thres;
-+	unsigned long	pebs_buf_base;
-+	unsigned long	pebs_index;
-+	unsigned long	pebs_abs_max;
-+	unsigned long	pebs_intr_thres;
-+	u64		pebs_cnt_reset;
-+};
-+
-+
-+static int pfm_p4_stop_save(struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	struct pfm_arch_pmu_info *pmu_info;
-+	struct pfm_arch_context *ctx_arch;
-+	struct pfm_ds_area_p4 *ds = NULL;
-+	u64 used_mask[PFM_PMC_BV];
-+	u16 i, j, count, pebs_idx = ~0;
-+	u16 max_pmc;
-+	u64 cccr, ctr1, ctr2, ovfl_mask;
-+
-+	pmu_info = &pfm_p4_pmu_info;
-+	ctx_arch = pfm_ctx_arch(ctx);
-+	max_pmc = ctx->regs.max_pmc;
-+	ovfl_mask = pfm_pmu_conf->ovfl_mask;
-+
-+	/*
-+	 * build used enable PMC bitmask
-+	 * if user did not set any CCCR, then mask is
-+	 * empty and there is nothing to do because nothing
-+	 * was started
-+	 */
-+	bitmap_and(cast_ulp(used_mask),
-+		   cast_ulp(set->used_pmcs),
-+		   cast_ulp(enable_mask),
-+		   max_enable);
-+
-+	count = bitmap_weight(cast_ulp(used_mask), max_enable);
-+
-+	PFM_DBG_ovfl("npend=%u ena_mask=0x%llx u_pmcs=0x%llx count=%u num=%u",
-+		set->npend_ovfls,
-+		(unsigned long long)enable_mask[0],
-+		(unsigned long long)set->used_pmcs[0],
-+		count, max_enable);
-+
-+	/*
-+	 * ensures we do not destroy pending overflow
-+	 * information. If pended interrupts are already
-+	 * known, then we just stop monitoring.
-+	 */
-+	if (set->npend_ovfls) {
-+		/*
-+		 * clear enable bit
-+		 * unfortunately, this is very expensive!
-+		 */
-+		for (i = 0; count; i++) {
-+			if (test_bit(i, cast_ulp(used_mask))) {
-+				__pfm_write_reg_p4(pmc_addrs+i, 0);
-+				count--;
-+			}
-+		}
-+		/* need save PMDs at upper level */
-+		return 1;
-+	}
-+
-+	if (ctx_arch->flags.use_pebs) {
-+		ds = ctx_arch->ds_area;
-+		pebs_idx = PEBS_PMD;
-+		PFM_DBG("ds=%p pebs_idx=0x%llx thres=0x%llx",
-+			ds,
-+			(unsigned long long)ds->pebs_index,
-+			(unsigned long long)ds->pebs_intr_thres);
-+	}
-+
-+	/*
-+	 * stop monitoring AND collect pending overflow information AND
-+	 * save pmds.
-+	 *
-+	 * We need to access the CCCR twice, once to get overflow info
-+	 * and a second to stop monitoring (which destroys the OVF flag)
-+	 * Similarly, we need to read the counter twice to check whether
-+	 * it did overflow between the CCR read and the CCCR write.
-+	 */
-+	for (i = 0; count; i++) {
-+		if (i != pebs_idx && test_bit(i, cast_ulp(used_mask))) {
-+			/*
-+			 * controlled counter
-+			 */
-+			j = pmc_addrs[i].ctr;
-+
-+			/* read CCCR (PMC) value */
-+			__pfm_read_reg_p4(pmc_addrs+i, &cccr);
-+
-+			/* read counter (PMD) controlled by PMC */
-+			__pfm_read_reg_p4(pmd_addrs+j, &ctr1);
-+
-+			/* clear CCCR value: stop counter but destroy OVF */
-+			__pfm_write_reg_p4(pmc_addrs+i, 0);
-+
-+			/* read counter controlled by CCCR again */
-+			__pfm_read_reg_p4(pmd_addrs+j, &ctr2);
-+
-+			/*
-+			 * there is an overflow if either:
-+			 * 	- CCCR.ovf is set (and we just cleared it)
-+			 * 	- ctr2 < ctr1
-+			 * in that case we set the bit corresponding to the
-+			 * overflowed PMD  in povfl_pmds.
-+			 */
-+			if ((cccr & (1ULL<<31)) || (ctr2 < ctr1)) {
-+				__set_bit(j, cast_ulp(set->povfl_pmds));
-+				set->npend_ovfls++;
-+			}
-+			ctr2 = (set->pmds[j].value & ~ovfl_mask) | (ctr2 & ovfl_mask);
-+			set->pmds[j].value = ctr2;
-+			count--;
-+		}
-+	}
-+	/*
-+	 * check for PEBS buffer full and set the corresponding PMD overflow
-+	 */
-+	if (ctx_arch->flags.use_pebs) {
-+		PFM_DBG("ds=%p pebs_idx=0x%lx thres=0x%lx", ds, ds->pebs_index, ds->pebs_intr_thres);
-+		if (ds->pebs_index >= ds->pebs_intr_thres
-+		    && test_bit(PEBS_PMD, cast_ulp(set->used_pmds))) {
-+			__set_bit(PEBS_PMD, cast_ulp(set->povfl_pmds));
-+			set->npend_ovfls++;
-+		}
-+	}
-+	/* 0 means: no need to save the PMD at higher level */
-+	return 0;
-+}
-+
-+static int pfm_p4_create_context(struct pfm_context *ctx, u32 ctx_flags)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+
-+	ctx_arch->data = kzalloc(sizeof(struct pfm_arch_p4_context), GFP_KERNEL);
-+	if (!ctx_arch->data)
-+		return -ENOMEM;
-+
-+	return 0;
-+}
-+
-+static void pfm_p4_free_context(struct pfm_context *ctx)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+	/*
-+	 * we do not check if P4, because it would be NULL and
-+	 * kfree can deal with NULL
-+	 */
-+	kfree(ctx_arch->data);
-+}
-+
-+/*
-+ * detect is counters have overflowed.
-+ * return:
-+ * 	0 : no overflow
-+ * 	1 : at least one overflow
-+ *
-+ * used by Intel P4
-+ */
-+static int __kprobes pfm_p4_has_ovfls(struct pfm_context *ctx)
-+{
-+	struct pfm_arch_pmu_info *pmu_info;
-+	struct pfm_p4_regmap *xrc, *xrd;
-+	struct pfm_arch_context *ctx_arch;
-+	struct pfm_arch_p4_context *p4;
-+	u64 ena_mask[PFM_PMC_BV];
-+	u64 cccr, ctr1, ctr2;
-+	int n, i, j;
-+
-+	pmu_info = &pfm_p4_pmu_info;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+	xrc = pmc_addrs;
-+	xrd = pmd_addrs;
-+	p4 = ctx_arch->data;
-+
-+	bitmap_and(cast_ulp(ena_mask),
-+		   cast_ulp(ctx->regs.pmcs),
-+		   cast_ulp(enable_mask),
-+		   max_enable);
-+
-+	n = bitmap_weight(cast_ulp(ena_mask), max_enable);
-+
-+	for (i = 0; n; i++) {
-+		if (!test_bit(i, cast_ulp(ena_mask)))
-+			continue;
-+		/*
-+		 * controlled counter
-+		 */
-+		j = xrc[i].ctr;
-+
-+		/* read CCCR (PMC) value */
-+		__pfm_read_reg_p4(xrc+i, &cccr);
-+
-+		/* read counter (PMD) controlled by PMC */
-+		__pfm_read_reg_p4(xrd+j, &ctr1);
-+
-+		/* clear CCCR value: stop counter but destroy OVF */
-+		__pfm_write_reg_p4(xrc+i, 0);
-+
-+		/* read counter controlled by CCCR again */
-+		__pfm_read_reg_p4(xrd+j, &ctr2);
-+
-+		/*
-+		 * there is an overflow if either:
-+		 * 	- CCCR.ovf is set (and we just cleared it)
-+		 * 	- ctr2 < ctr1
-+		 * in that case we set the bit corresponding to the
-+		 * overflowed PMD in povfl_pmds.
-+		 */
-+		if ((cccr & (1ULL<<31)) || (ctr2 < ctr1)) {
-+			__set_bit(j, cast_ulp(p4->povfl_pmds));
-+			p4->npend_ovfls++;
-+		}
-+		p4->saved_cccrs[i] = cccr;
-+		n--;
-+	}
-+	/*
-+	 * if there was no overflow, then it means the NMI was not really
-+	 * for us, so we have to resume monitoring
-+	 */
-+	if (unlikely(!p4->npend_ovfls)) {
-+		for (i = 0; n; i++) {
-+			if (!test_bit(i, cast_ulp(ena_mask)))
-+				continue;
-+			__pfm_write_reg_p4(xrc+i, p4->saved_cccrs[i]);
-+		}
-+	}
-+	return 0;
-+}
-+
-+void pfm_p4_restore_pmcs(struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	struct pfm_arch_pmu_info *pmu_info;
-+	struct pfm_arch_context *ctx_arch;
-+	u64 *mask;
-+	u16 i, num;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+	pmu_info = pfm_pmu_info();
-+
-+	/*
-+	 * must restore DS pointer before restoring PMCs
-+	 * as this can potentially reactivate monitoring
-+	 */
-+	if (ctx_arch->flags.use_ds)
-+		wrmsrl(MSR_IA32_DS_AREA, (unsigned long)ctx_arch->ds_area);
-+
-+	/*
-+	 * must restore everything because there are some dependencies
-+	 * (e.g., ESCR and CCCR)
-+	 */
-+	num = ctx->regs.num_pmcs;
-+	mask = ctx->regs.pmcs;
-+	for (i = 0; num; i++) {
-+		if (test_bit(i, cast_ulp(mask))) {
-+			pfm_arch_write_pmc(ctx, i, set->pmcs[i]);
-+			num--;
-+		}
-+	}
-+}
-+
-+/*
-+ * invoked only when NMI is used. Called from the LOCAL_PERFMON_VECTOR
-+ * handler to copy P4 overflow state captured when the NMI triggered.
-+ * Given that on P4, stopping monitoring destroy the overflow information
-+ * we save it in pfm_has_ovfl_p4() where monitoring is also stopped.
-+ *
-+ * Here we propagate the overflow state to current active set. The
-+ * freeze_pmu() call we not overwrite this state because npend_ovfls
-+ * is non-zero.
-+ */
-+static void pfm_p4_nmi_copy_state(struct pfm_context *ctx)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+	struct pfm_event_set *set;
-+	struct pfm_arch_p4_context *p4;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+	p4 = ctx_arch->data;
-+	set = ctx->active_set;
-+
-+	if (p4->npend_ovfls) {
-+		set->npend_ovfls = p4->npend_ovfls;
-+
-+		bitmap_copy(cast_ulp(set->povfl_pmds),
-+			    cast_ulp(p4->povfl_pmds),
-+			    ctx->regs.max_pmd);
-+
-+		p4->npend_ovfls = 0;
-+	}
-+}
-+
-+/**
-+ * pfm_p4_quiesce - stop monitoring without grabbing any lock
-+ *
-+ * called from NMI interrupt handler to immediately stop monitoring
-+ * cannot grab any lock, including perfmon related locks
-+ */
-+static void __kprobes pfm_p4_quiesce(void)
-+{
-+	u16 i;
-+	/*
-+	 * quiesce PMU by clearing available registers that have
-+	 * the start/stop capability
-+	 */
-+	for (i = 0; i < pfm_pmu_conf->regs_all.max_pmc; i++) {
-+		if (test_bit(i, cast_ulp(pfm_pmu_conf->regs_all.pmcs))
-+		    && test_bit(i, cast_ulp(enable_mask)))
-+			__pfm_write_reg_p4(pmc_addrs+i, 0);
-+	}
-+}
-+
-+
-+static struct pfm_pmu_config pfm_p4_pmu_conf = {
-+	.pmu_name = "Intel P4",
-+	.counter_width = 40,
-+	.pmd_desc = pfm_p4_pmd_desc,
-+	.pmc_desc = pfm_p4_pmc_desc,
-+	.num_pmc_entries = PFM_P4_NUM_PMCS,
-+	.num_pmd_entries = PFM_P4_NUM_PMDS,
-+	.probe_pmu = pfm_p4_probe_pmu,
-+	.version = "1.0",
-+	.flags = PFM_PMU_BUILTIN_FLAG,
-+	.owner = THIS_MODULE,
-+	.pmu_info = &pfm_p4_pmu_info
-+};
-+
-+static int __init pfm_p4_pmu_init_module(void)
-+{
-+	return pfm_pmu_register(&pfm_p4_pmu_conf);
-+}
-+
-+static void __exit pfm_p4_pmu_cleanup_module(void)
-+{
-+	pfm_pmu_unregister(&pfm_p4_pmu_conf);
-+}
-+
-+module_init(pfm_p4_pmu_init_module);
-+module_exit(pfm_p4_pmu_cleanup_module);
-diff --git a/arch/x86/perfmon/perfmon_p6.c b/arch/x86/perfmon/perfmon_p6.c
-new file mode 100644
-index 0000000..47c0a46
---- /dev/null
-+++ b/arch/x86/perfmon/perfmon_p6.c
-@@ -0,0 +1,310 @@
-+/*
-+ * This file contains the P6 family processor PMU register description tables
-+ *
-+ * This module supports original P6 processors
-+ * (Pentium II, Pentium Pro, Pentium III) and Pentium M.
-+ *
-+ * Copyright (c) 2005-2007 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+  */
-+#include <linux/module.h>
-+#include <linux/kprobes.h>
-+#include <linux/perfmon_kern.h>
-+#include <linux/nmi.h>
-+#include <asm/msr.h>
-+
-+MODULE_AUTHOR("Stephane Eranian <eranian@hpl.hp.com>");
-+MODULE_DESCRIPTION("P6 PMU description table");
-+MODULE_LICENSE("GPL");
-+
-+static int force_nmi;
-+MODULE_PARM_DESC(force_nmi, "bool: force use of NMI for PMU interrupt");
-+module_param(force_nmi, bool, 0600);
-+
-+/*
-+ * - upper 32 bits are reserved
-+ * - INT: APIC enable bit is reserved (forced to 1)
-+ * - bit 21 is reserved
-+ * - bit 22 is reserved on PEREVNTSEL1
-+ *
-+ * RSVD: reserved bits are 1
-+ */
-+#define PFM_P6_PMC0_RSVD ((~((1ULL<<32)-1)) | (1ULL<<20) | (1ULL<<21))
-+#define PFM_P6_PMC1_RSVD ((~((1ULL<<32)-1)) | (1ULL<<20) | (3ULL<<21))
-+
-+/*
-+ * force Local APIC interrupt on overflow
-+ * disable with NO_EMUL64
-+ */
-+#define PFM_P6_PMC_VAL  (1ULL<<20)
-+#define PFM_P6_NO64	(1ULL<<20)
-+
-+
-+static void __kprobes pfm_p6_quiesce(void);
-+static int pfm_p6_has_ovfls(struct pfm_context *ctx);
-+static int pfm_p6_stop_save(struct pfm_context *ctx,
-+			    struct pfm_event_set *set);
-+
-+static u64 enable_mask[PFM_MAX_PMCS];
-+static u16 max_enable;
-+
-+/*
-+ * PFM_X86_FL_NO_SHARING: because of the single enable bit on MSR_P6_EVNTSEL0
-+ * the PMU cannot be shared with NMI watchdog or Oprofile
-+ */
-+struct pfm_arch_pmu_info pfm_p6_pmu_info = {
-+	.stop_save = pfm_p6_stop_save,
-+	.has_ovfls = pfm_p6_has_ovfls,
-+	.quiesce = pfm_p6_quiesce,
-+	.flags = PFM_X86_FL_NO_SHARING,
-+};
-+
-+static struct pfm_regmap_desc pfm_p6_pmc_desc[] = {
-+/* pmc0  */ PMC_D(PFM_REG_I64, "PERFEVTSEL0", PFM_P6_PMC_VAL, PFM_P6_PMC0_RSVD, PFM_P6_NO64, MSR_P6_EVNTSEL0),
-+/* pmc1  */ PMC_D(PFM_REG_I64, "PERFEVTSEL1", PFM_P6_PMC_VAL, PFM_P6_PMC1_RSVD, PFM_P6_NO64, MSR_P6_EVNTSEL1)
-+};
-+#define PFM_P6_NUM_PMCS	ARRAY_SIZE(pfm_p6_pmc_desc)
-+
-+#define PFM_P6_D(n) \
-+	{ .type = PFM_REG_C,			\
-+	  .desc = "PERFCTR"#n,			\
-+	  .hw_addr = MSR_P6_PERFCTR0+n,		\
-+	  .rsvd_msk = 0,			\
-+	  .dep_pmcs[0] = 1ULL << n		\
-+	}
-+
-+static struct pfm_regmap_desc pfm_p6_pmd_desc[] = {
-+/* pmd0  */ PFM_P6_D(0),
-+/* pmd1  */ PFM_P6_D(1)
-+};
-+#define PFM_P6_NUM_PMDS ARRAY_SIZE(pfm_p6_pmd_desc)
-+
-+static int pfm_p6_probe_pmu(void)
-+{
-+	int high, low;
-+
-+	if (current_cpu_data.x86_vendor != X86_VENDOR_INTEL) {
-+		PFM_INFO("not an Intel processor");
-+		return -1;
-+	}
-+
-+	/*
-+	 * check for P6 processor family
-+	 */
-+	if (current_cpu_data.x86 != 6) {
-+		PFM_INFO("unsupported family=%d", current_cpu_data.x86);
-+		return -1;
-+	}
-+
-+	switch (current_cpu_data.x86_model) {
-+	case 1: /* Pentium Pro */
-+	case 3:
-+	case 5: /* Pentium II Deschutes */
-+	case 7 ... 11:
-+		break;
-+	case 13:
-+		/* for Pentium M, we need to check if PMU exist */
-+		rdmsr(MSR_IA32_MISC_ENABLE, low, high);
-+		if (low & (1U << 7))
-+			break;
-+	default:
-+		PFM_INFO("unsupported CPU model %d",
-+			 current_cpu_data.x86_model);
-+		return -1;
-+
-+	}
-+
-+	if (!cpu_has_apic) {
-+		PFM_INFO("no Local APIC, try rebooting with lapic");
-+		return -1;
-+	}
-+	__set_bit(0, cast_ulp(enable_mask));
-+	__set_bit(1, cast_ulp(enable_mask));
-+	max_enable = 1 + 1;
-+	/*
-+	 * force NMI interrupt?
-+	 */
-+	if (force_nmi)
-+		pfm_p6_pmu_info.flags |= PFM_X86_FL_USE_NMI;
-+
-+	return 0;
-+}
-+
-+/**
-+ * pfm_p6_has_ovfls - check for pending overflow condition
-+ * @ctx: context to work on
-+ *
-+ * detect if counters have overflowed.
-+ * return:
-+ * 	0 : no overflow
-+ * 	1 : at least one overflow
-+ */
-+static int __kprobes pfm_p6_has_ovfls(struct pfm_context *ctx)
-+{
-+	u64 *cnt_mask;
-+	u64 wmask, val;
-+	u16 i, num;
-+
-+	cnt_mask = ctx->regs.cnt_pmds;
-+	num = ctx->regs.num_counters;
-+	wmask = 1ULL << pfm_pmu_conf->counter_width;
-+
-+	/*
-+	 * we can leverage the fact that we know the mapping
-+	 * to hardcode the MSR address and avoid accessing
-+	 * more cachelines
-+	 *
-+	 * We need to check cnt_mask because not all registers
-+	 * may be available.
-+	 */
-+	for (i = 0; num; i++) {
-+		if (test_bit(i, cast_ulp(cnt_mask))) {
-+			rdmsrl(MSR_P6_PERFCTR0+i, val);
-+			if (!(val & wmask))
-+				return 1;
-+			num--;
-+		}
-+	}
-+	return 0;
-+}
-+
-+/**
-+ * pfm_p6_stop_save -- stop monitoring and save PMD values
-+ * @ctx: context to work on
-+ * @set: current event set
-+ *
-+ * return value:
-+ * 	0 - no need to save PMDs in caller
-+ * 	1 - need to save PMDs in caller
-+ */
-+static int pfm_p6_stop_save(struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	struct pfm_arch_pmu_info *pmu_info;
-+	u64 used_mask[PFM_PMC_BV];
-+	u64 *cnt_pmds;
-+	u64 val, wmask, ovfl_mask;
-+	u32 i, count;
-+
-+	pmu_info = pfm_pmu_info();
-+
-+	wmask = 1ULL << pfm_pmu_conf->counter_width;
-+	bitmap_and(cast_ulp(used_mask),
-+		   cast_ulp(set->used_pmcs),
-+		   cast_ulp(enable_mask),
-+		   max_enable);
-+
-+	count = bitmap_weight(cast_ulp(used_mask), ctx->regs.max_pmc);
-+
-+	/*
-+	 * stop monitoring
-+	 * Unfortunately, this is very expensive!
-+	 * wrmsrl() is serializing.
-+	 */
-+	for (i = 0; count; i++) {
-+		if (test_bit(i, cast_ulp(used_mask))) {
-+			wrmsrl(MSR_P6_EVNTSEL0+i, 0);
-+			count--;
-+		}
-+	}
-+
-+	/*
-+	 * if we already having a pending overflow condition, we simply
-+	 * return to take care of this first.
-+	 */
-+	if (set->npend_ovfls)
-+		return 1;
-+
-+	ovfl_mask = pfm_pmu_conf->ovfl_mask;
-+	cnt_pmds = ctx->regs.cnt_pmds;
-+
-+	/*
-+	 * check for pending overflows and save PMDs (combo)
-+	 * we employ used_pmds because we also need to save
-+	 * and not just check for pending interrupts.
-+	 *
-+	 * Must check for counting PMDs because of virtual PMDs
-+	 */
-+	count = set->nused_pmds;
-+	for (i = 0; count; i++) {
-+		if (test_bit(i, cast_ulp(set->used_pmds))) {
-+			val = pfm_arch_read_pmd(ctx, i);
-+			if (likely(test_bit(i, cast_ulp(cnt_pmds)))) {
-+				if (!(val & wmask)) {
-+					__set_bit(i, cast_ulp(set->povfl_pmds));
-+					set->npend_ovfls++;
-+				}
-+				val = (set->pmds[i].value & ~ovfl_mask) | (val & ovfl_mask);
-+			}
-+			set->pmds[i].value = val;
-+			count--;
-+		}
-+	}
-+	/* 0 means: no need to save PMDs at upper level */
-+	return 0;
-+}
-+
-+/**
-+ * pfm_p6_quiesce_pmu -- stop monitoring without grabbing any lock
-+ *
-+ * called from NMI interrupt handler to immediately stop monitoring
-+ * cannot grab any lock, including perfmon related locks
-+ */
-+static void __kprobes pfm_p6_quiesce(void)
-+{
-+	/*
-+	 * quiesce PMU by clearing available registers that have
-+	 * the start/stop capability
-+	 *
-+	 * P6 processors only have enable bit on PERFEVTSEL0
-+	 */
-+	if (test_bit(0, cast_ulp(pfm_pmu_conf->regs_all.pmcs)))
-+		wrmsrl(MSR_P6_EVNTSEL0, 0);
-+}
-+
-+/*
-+ * Counters have 40 bits implemented. However they are designed such
-+ * that bits [32-39] are sign extensions of bit 31. As such the
-+ * effective width of a counter for P6-like PMU is 31 bits only.
-+ *
-+ * See IA-32 Intel Architecture Software developer manual Vol 3B
-+ */
-+static struct pfm_pmu_config pfm_p6_pmu_conf = {
-+	.pmu_name = "Intel P6 processor Family",
-+	.counter_width = 31,
-+	.pmd_desc = pfm_p6_pmd_desc,
-+	.pmc_desc = pfm_p6_pmc_desc,
-+	.num_pmc_entries = PFM_P6_NUM_PMCS,
-+	.num_pmd_entries = PFM_P6_NUM_PMDS,
-+	.probe_pmu = pfm_p6_probe_pmu,
-+	.version = "1.0",
-+	.flags = PFM_PMU_BUILTIN_FLAG,
-+	.owner = THIS_MODULE,
-+	.pmu_info = &pfm_p6_pmu_info
-+};
-+
-+static int __init pfm_p6_pmu_init_module(void)
-+{
-+	return pfm_pmu_register(&pfm_p6_pmu_conf);
-+}
-+
-+static void __exit pfm_p6_pmu_cleanup_module(void)
-+{
-+	pfm_pmu_unregister(&pfm_p6_pmu_conf);
-+}
-+
-+module_init(pfm_p6_pmu_init_module);
-+module_exit(pfm_p6_pmu_cleanup_module);
-diff --git a/arch/x86/perfmon/perfmon_pebs_core_smpl.c b/arch/x86/perfmon/perfmon_pebs_core_smpl.c
-new file mode 100644
-index 0000000..eeb9174
---- /dev/null
-+++ b/arch/x86/perfmon/perfmon_pebs_core_smpl.c
-@@ -0,0 +1,256 @@
-+/*
-+ * Copyright (c) 2005-2007 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This file implements the Precise Event Based Sampling (PEBS)
-+ * sampling format for Intel Core and Atom  processors.
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+  */
-+#include <linux/kernel.h>
-+#include <linux/types.h>
-+#include <linux/module.h>
-+#include <linux/init.h>
-+#include <linux/smp.h>
-+#include <linux/perfmon_kern.h>
-+
-+#include <asm/msr.h>
-+#include <asm/perfmon_pebs_core_smpl.h>
-+
-+MODULE_AUTHOR("Stephane Eranian <eranian@hpl.hp.com>");
-+MODULE_DESCRIPTION("Intel Core Precise Event-Based Sampling (PEBS)");
-+MODULE_LICENSE("GPL");
-+
-+#define ALIGN_PEBS(a, order) \
-+		((a)+(1UL<<(order))-1) & ~((1UL<<(order))-1)
-+
-+#define PEBS_PADDING_ORDER 8 /* log2(256) padding for PEBS alignment constraint */
-+
-+static int pfm_pebs_core_fmt_validate(u32 flags, u16 npmds, void *data)
-+{
-+	struct pfm_pebs_core_smpl_arg *arg = data;
-+	size_t min_buf_size;
-+
-+	/*
-+	 * need to define at least the size of the buffer
-+	 */
-+	if (data == NULL) {
-+		PFM_DBG("no argument passed");
-+		return -EINVAL;
-+	}
-+
-+	/*
-+	 * compute min buf size. npmds is the maximum number
-+	 * of implemented PMD registers.
-+	 */
-+	min_buf_size = sizeof(struct pfm_pebs_core_smpl_hdr)
-+		     + sizeof(struct pfm_pebs_core_smpl_entry)
-+		     + (1UL<<PEBS_PADDING_ORDER); /* padding for alignment */
-+
-+	PFM_DBG("validate flags=0x%x min_buf_size=%zu buf_size=%zu",
-+		  flags,
-+		  min_buf_size,
-+		  arg->buf_size);
-+
-+	/*
-+	 * must hold at least the buffer header + one minimally sized entry
-+	 */
-+	if (arg->buf_size < min_buf_size)
-+		return -EINVAL;
-+
-+	return 0;
-+}
-+
-+static int pfm_pebs_core_fmt_get_size(unsigned int flags, void *data, size_t *size)
-+{
-+	struct pfm_pebs_core_smpl_arg *arg = data;
-+
-+	/*
-+	 * size has been validated in pfm_pebs_core_fmt_validate()
-+	 */
-+	*size = arg->buf_size + (1UL<<PEBS_PADDING_ORDER);
-+
-+	return 0;
-+}
-+
-+static int pfm_pebs_core_fmt_init(struct pfm_context *ctx, void *buf,
-+			     u32 flags, u16 npmds, void *data)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+	struct pfm_pebs_core_smpl_hdr *hdr;
-+	struct pfm_pebs_core_smpl_arg *arg = data;
-+	u64 pebs_start, pebs_end;
-+	struct pfm_ds_area_core *ds;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+
-+	hdr = buf;
-+	ds = &hdr->ds;
-+
-+	/*
-+	 * align PEBS buffer base
-+	 */
-+	pebs_start = ALIGN_PEBS((unsigned long)(hdr+1), PEBS_PADDING_ORDER);
-+	pebs_end = pebs_start + arg->buf_size + 1;
-+
-+	hdr->version = PFM_PEBS_CORE_SMPL_VERSION;
-+	hdr->buf_size = arg->buf_size;
-+	hdr->overflows = 0;
-+
-+	/*
-+	 * express PEBS buffer base as offset from the end of the header
-+	 */
-+	hdr->start_offs = pebs_start - (unsigned long)(hdr+1);
-+
-+	/*
-+	 * PEBS buffer boundaries
-+	 */
-+	ds->pebs_buf_base = pebs_start;
-+	ds->pebs_abs_max = pebs_end;
-+
-+	/*
-+	 * PEBS starting position
-+	 */
-+	ds->pebs_index = pebs_start;
-+
-+	/*
-+	 * PEBS interrupt threshold
-+	 */
-+	ds->pebs_intr_thres = pebs_start
-+			    + arg->intr_thres
-+			    * sizeof(struct pfm_pebs_core_smpl_entry);
-+
-+	/*
-+	 * save counter reset value for PEBS counter
-+	 */
-+	ds->pebs_cnt_reset = arg->cnt_reset;
-+
-+	/*
-+	 * keep track of DS AREA
-+	 */
-+	ctx_arch->ds_area = ds;
-+	ctx_arch->flags.use_ds = 1;
-+	ctx_arch->flags.use_pebs = 1;
-+
-+	PFM_DBG("buffer=%p buf_size=%llu offs=%llu pebs_start=0x%llx "
-+		  "pebs_end=0x%llx ds=%p pebs_thres=0x%llx cnt_reset=0x%llx",
-+		  buf,
-+		  (unsigned long long)hdr->buf_size,
-+		  (unsigned long long)hdr->start_offs,
-+		  (unsigned long long)pebs_start,
-+		  (unsigned long long)pebs_end,
-+		  ds,
-+		  (unsigned long long)ds->pebs_intr_thres,
-+		  (unsigned long long)ds->pebs_cnt_reset);
-+
-+	return 0;
-+}
-+
-+static int pfm_pebs_core_fmt_handler(struct pfm_context *ctx,
-+			       unsigned long ip, u64 tstamp, void *data)
-+{
-+	struct pfm_pebs_core_smpl_hdr *hdr;
-+	struct pfm_ovfl_arg *arg;
-+
-+	hdr = ctx->smpl_addr;
-+	arg = &ctx->ovfl_arg;
-+
-+	PFM_DBG_ovfl("buffer full");
-+	/*
-+	 * increment number of buffer overflows.
-+	 * important to detect duplicate set of samples.
-+	 */
-+	hdr->overflows++;
-+
-+	/*
-+	 * request notification and masking of monitoring.
-+	 * Notification is still subject to the overflowed
-+	 * register having the FL_NOTIFY flag set.
-+	 */
-+	arg->ovfl_ctrl = PFM_OVFL_CTRL_NOTIFY | PFM_OVFL_CTRL_MASK;
-+
-+	return -ENOBUFS; /* we are full, sorry */
-+}
-+
-+static int pfm_pebs_core_fmt_restart(int is_active, u32 *ovfl_ctrl,
-+				void *buf)
-+{
-+	struct pfm_pebs_core_smpl_hdr *hdr = buf;
-+
-+	/*
-+	 * reset index to base of buffer
-+	 */
-+	hdr->ds.pebs_index = hdr->ds.pebs_buf_base;
-+
-+	*ovfl_ctrl = PFM_OVFL_CTRL_RESET;
-+
-+	return 0;
-+}
-+
-+static int pfm_pebs_core_fmt_exit(void *buf)
-+{
-+	return 0;
-+}
-+
-+static struct pfm_smpl_fmt pebs_core_fmt = {
-+	.fmt_name = PFM_PEBS_CORE_SMPL_NAME,
-+	.fmt_version = 0x1,
-+	.fmt_arg_size = sizeof(struct pfm_pebs_core_smpl_arg),
-+	.fmt_validate = pfm_pebs_core_fmt_validate,
-+	.fmt_getsize = pfm_pebs_core_fmt_get_size,
-+	.fmt_init = pfm_pebs_core_fmt_init,
-+	.fmt_handler = pfm_pebs_core_fmt_handler,
-+	.fmt_restart = pfm_pebs_core_fmt_restart,
-+	.fmt_exit = pfm_pebs_core_fmt_exit,
-+	.fmt_flags = PFM_FMT_BUILTIN_FLAG,
-+	.owner = THIS_MODULE,
-+};
-+
-+static int __init pfm_pebs_core_fmt_init_module(void)
-+{
-+	if (!cpu_has_pebs) {
-+		PFM_INFO("processor does not have PEBS support");
-+		return -1;
-+	}
-+	/*
-+	 * cpu_has_pebs is not enough to identify Intel Core PEBS
-+	 * which is different fro Pentium 4 PEBS. Therefore we do
-+	 * a more detailed check here
-+	 */
-+	if (current_cpu_data.x86 != 6) {
-+		PFM_INFO("not a supported Intel processor");
-+		return -1;
-+	}
-+
-+	switch (current_cpu_data.x86_model) {
-+	case 15: /* Merom */
-+	case 23: /* Penryn */
-+	case 28: /* Atom (Silverthorne) */
-+	case 29: /* Dunnington */
-+		break;
-+	default:
-+		PFM_INFO("not a supported Intel processor");
-+		return -1;
-+	}
-+	return pfm_fmt_register(&pebs_core_fmt);
-+}
-+
-+static void __exit pfm_pebs_core_fmt_cleanup_module(void)
-+{
-+	pfm_fmt_unregister(&pebs_core_fmt);
-+}
-+
-+module_init(pfm_pebs_core_fmt_init_module);
-+module_exit(pfm_pebs_core_fmt_cleanup_module);
-diff --git a/arch/x86/perfmon/perfmon_pebs_p4_smpl.c b/arch/x86/perfmon/perfmon_pebs_p4_smpl.c
-new file mode 100644
-index 0000000..f4e9fd2
---- /dev/null
-+++ b/arch/x86/perfmon/perfmon_pebs_p4_smpl.c
-@@ -0,0 +1,253 @@
-+/*
-+ * Copyright (c) 2005-2007 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This file implements the Precise Event Based Sampling (PEBS)
-+ * sampling format. It supports the following processors:
-+ *	- 32-bit Pentium 4 or other Netburst-based processors
-+ *	- 64-bit Pentium 4 or other Netburst-based processors
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+  */
-+#include <linux/kernel.h>
-+#include <linux/types.h>
-+#include <linux/module.h>
-+#include <linux/init.h>
-+#include <linux/smp.h>
-+#include <linux/perfmon_kern.h>
-+
-+#include <asm/msr.h>
-+#include <asm/perfmon_pebs_p4_smpl.h>
-+
-+MODULE_AUTHOR("Stephane Eranian <eranian@hpl.hp.com>");
-+MODULE_DESCRIPTION("Intel P4 Precise Event-Based Sampling (PEBS)");
-+MODULE_LICENSE("GPL");
-+
-+#define ALIGN_PEBS(a, order) \
-+		((a)+(1UL<<(order))-1) & ~((1UL<<(order))-1)
-+
-+#define PEBS_PADDING_ORDER 8 /* log2(256) padding for PEBS alignment constraint */
-+
-+static int pfm_pebs_p4_fmt_validate(u32 flags, u16 npmds, void *data)
-+{
-+	struct pfm_pebs_p4_smpl_arg *arg = data;
-+	size_t min_buf_size;
-+
-+	/*
-+	 * need to define at least the size of the buffer
-+	 */
-+	if (data == NULL) {
-+		PFM_DBG("no argument passed");
-+		return -EINVAL;
-+	}
-+
-+	/*
-+	 * compute min buf size. npmds is the maximum number
-+	 * of implemented PMD registers.
-+	 */
-+	min_buf_size = sizeof(struct pfm_pebs_p4_smpl_hdr)
-+		+ sizeof(struct pfm_pebs_p4_smpl_entry)
-+		+ (1UL<<PEBS_PADDING_ORDER); /* padding for alignment */
-+
-+	PFM_DBG("validate flags=0x%x min_buf_size=%zu buf_size=%zu",
-+		  flags,
-+		  min_buf_size,
-+		  arg->buf_size);
-+
-+	/*
-+	 * must hold at least the buffer header + one minimally sized entry
-+	 */
-+	if (arg->buf_size < min_buf_size)
-+		return -EINVAL;
-+
-+	return 0;
-+}
-+
-+static int pfm_pebs_p4_fmt_get_size(unsigned int flags, void *data, size_t *size)
-+{
-+	struct pfm_pebs_p4_smpl_arg *arg = data;
-+
-+	/*
-+	 * size has been validated in pfm_pebs_p4_fmt_validate()
-+	 */
-+	*size = arg->buf_size + (1UL<<PEBS_PADDING_ORDER);
-+
-+	return 0;
-+}
-+
-+static int pfm_pebs_p4_fmt_init(struct pfm_context *ctx, void *buf,
-+				u32 flags, u16 npmds, void *data)
-+{
-+	struct pfm_arch_context *ctx_arch;
-+	struct pfm_pebs_p4_smpl_hdr *hdr;
-+	struct pfm_pebs_p4_smpl_arg *arg = data;
-+	unsigned long pebs_start, pebs_end;
-+	struct pfm_ds_area_p4 *ds;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+
-+	hdr = buf;
-+	ds = &hdr->ds;
-+
-+	/*
-+	 * align PEBS buffer base
-+	 */
-+	pebs_start = ALIGN_PEBS((unsigned long)(hdr+1), PEBS_PADDING_ORDER);
-+	pebs_end = pebs_start + arg->buf_size + 1;
-+
-+	hdr->version = PFM_PEBS_P4_SMPL_VERSION;
-+	hdr->buf_size = arg->buf_size;
-+	hdr->overflows = 0;
-+
-+	/*
-+	 * express PEBS buffer base as offset from the end of the header
-+	 */
-+	hdr->start_offs = pebs_start - (unsigned long)(hdr+1);
-+
-+	/*
-+	 * PEBS buffer boundaries
-+	 */
-+	ds->pebs_buf_base = pebs_start;
-+	ds->pebs_abs_max = pebs_end;
-+
-+	/*
-+	 * PEBS starting position
-+	 */
-+	ds->pebs_index = pebs_start;
-+
-+	/*
-+	 * PEBS interrupt threshold
-+	 */
-+	ds->pebs_intr_thres = pebs_start
-+		+ arg->intr_thres * sizeof(struct pfm_pebs_p4_smpl_entry);
-+
-+	/*
-+	 * save counter reset value for PEBS counter
-+	 */
-+	ds->pebs_cnt_reset = arg->cnt_reset;
-+
-+	/*
-+	 * keep track of DS AREA
-+	 */
-+	ctx_arch->ds_area = ds;
-+	ctx_arch->flags.use_pebs = 1;
-+	ctx_arch->flags.use_ds = 1;
-+
-+	PFM_DBG("buffer=%p buf_size=%llu offs=%llu pebs_start=0x%lx "
-+		  "pebs_end=0x%lx ds=%p pebs_thres=0x%lx cnt_reset=0x%llx",
-+		  buf,
-+		  (unsigned long long)hdr->buf_size,
-+		  (unsigned long long)hdr->start_offs,
-+		  pebs_start,
-+		  pebs_end,
-+		  ds,
-+		  ds->pebs_intr_thres,
-+		  (unsigned long long)ds->pebs_cnt_reset);
-+
-+	return 0;
-+}
-+
-+static int pfm_pebs_p4_fmt_handler(struct pfm_context *ctx,
-+				   unsigned long ip, u64 tstamp, void *data)
-+{
-+	struct pfm_pebs_p4_smpl_hdr *hdr;
-+	struct pfm_ovfl_arg *arg;
-+
-+	hdr = ctx->smpl_addr;
-+	arg = &ctx->ovfl_arg;
-+
-+	PFM_DBG_ovfl("buffer full");
-+	/*
-+	 * increment number of buffer overflows.
-+	 * important to detect duplicate set of samples.
-+	 */
-+	hdr->overflows++;
-+
-+	/*
-+	 * request notification and masking of monitoring.
-+	 * Notification is still subject to the overflowed
-+	 * register having the FL_NOTIFY flag set.
-+	 */
-+	arg->ovfl_ctrl = PFM_OVFL_CTRL_NOTIFY | PFM_OVFL_CTRL_MASK;
-+
-+	return -ENOBUFS; /* we are full, sorry */
-+}
-+
-+static int pfm_pebs_p4_fmt_restart(int is_active, u32 *ovfl_ctrl,
-+				void *buf)
-+{
-+	struct pfm_pebs_p4_smpl_hdr *hdr = buf;
-+
-+	/*
-+	 * reset index to base of buffer
-+	 */
-+	hdr->ds.pebs_index = hdr->ds.pebs_buf_base;
-+
-+	*ovfl_ctrl = PFM_OVFL_CTRL_RESET;
-+
-+	return 0;
-+}
-+
-+static int pfm_pebs_p4_fmt_exit(void *buf)
-+{
-+	return 0;
-+}
-+
-+static struct pfm_smpl_fmt pebs_p4_fmt = {
-+	.fmt_name = PFM_PEBS_P4_SMPL_NAME,
-+	.fmt_version = 0x1,
-+	.fmt_arg_size = sizeof(struct pfm_pebs_p4_smpl_arg),
-+	.fmt_validate = pfm_pebs_p4_fmt_validate,
-+	.fmt_getsize = pfm_pebs_p4_fmt_get_size,
-+	.fmt_init = pfm_pebs_p4_fmt_init,
-+	.fmt_handler = pfm_pebs_p4_fmt_handler,
-+	.fmt_restart = pfm_pebs_p4_fmt_restart,
-+	.fmt_exit = pfm_pebs_p4_fmt_exit,
-+	.fmt_flags = PFM_FMT_BUILTIN_FLAG,
-+	.owner = THIS_MODULE,
-+};
-+
-+static int __init pfm_pebs_p4_fmt_init_module(void)
-+{
-+	int ht_enabled;
-+
-+	if (!cpu_has_pebs) {
-+		PFM_INFO("processor does not have PEBS support");
-+		return -1;
-+	}
-+	if (current_cpu_data.x86 != 15) {
-+		PFM_INFO("not an Intel Pentium 4");
-+		return -1;
-+	}
-+#ifdef CONFIG_SMP
-+	ht_enabled = (cpus_weight(__get_cpu_var(cpu_core_map))
-+		   / current_cpu_data.x86_max_cores) > 1;
-+#else
-+	ht_enabled = 0;
-+#endif
-+	if (ht_enabled) {
-+		PFM_INFO("PEBS not available because HyperThreading is on");
-+		return -1;
-+	}
-+	return pfm_fmt_register(&pebs_p4_fmt);
-+}
-+
-+static void __exit pfm_pebs_p4_fmt_cleanup_module(void)
-+{
-+	pfm_fmt_unregister(&pebs_p4_fmt);
-+}
-+
-+module_init(pfm_pebs_p4_fmt_init_module);
-+module_exit(pfm_pebs_p4_fmt_cleanup_module);
-diff --git a/include/asm-mips/Kbuild b/include/asm-mips/Kbuild
-index 7897f05..7ed16fc 100644
---- a/include/asm-mips/Kbuild
-+++ b/include/asm-mips/Kbuild
-@@ -1,3 +1,4 @@
- include include/asm-generic/Kbuild.asm
- 
- header-y += cachectl.h sgidefs.h sysmips.h
-+header-y += perfmon.h
-diff --git a/include/asm-mips/perfmon.h b/include/asm-mips/perfmon.h
-new file mode 100644
-index 0000000..7915c17
---- /dev/null
-+++ b/include/asm-mips/perfmon.h
-@@ -0,0 +1,34 @@
-+/*
-+ * Copyright (c) 2007 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This file contains mips64 specific definitions for the perfmon
-+ * interface.
-+ *
-+ * This file MUST never be included directly. Use linux/perfmon.h.
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+  */
-+#ifndef _ASM_MIPS64_PERFMON_H_
-+#define _ASM_MIPS64_PERFMON_H_
-+
-+/*
-+ * arch-specific user visible interface definitions
-+ */
-+
-+#define PFM_ARCH_MAX_PMCS	(256+64) /* 256 HW 64 SW */
-+#define PFM_ARCH_MAX_PMDS	(256+64) /* 256 HW 64 SW */
-+
-+#endif /* _ASM_MIPS64_PERFMON_H_ */
-diff --git a/include/asm-mips/perfmon_kern.h b/include/asm-mips/perfmon_kern.h
-new file mode 100644
-index 0000000..7d213df
---- /dev/null
-+++ b/include/asm-mips/perfmon_kern.h
-@@ -0,0 +1,412 @@
-+/*
-+ * Copyright (c) 2005 Philip Mucci.
-+ *
-+ * Based on other versions:
-+ * Copyright (c) 2005-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This file contains mips64 specific definitions for the perfmon
-+ * interface.
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+  */
-+#ifndef _ASM_MIPS64_PERFMON_KERN_H_
-+#define _ASM_MIPS64_PERFMON_KERN_H_
-+
-+#ifdef __KERNEL__
-+
-+#ifdef CONFIG_PERFMON
-+#include <linux/unistd.h>
-+#include <asm/cacheflush.h>
-+
-+#define PFM_ARCH_PMD_STK_ARG	2
-+#define PFM_ARCH_PMC_STK_ARG	2
-+
-+struct pfm_arch_pmu_info {
-+	u32 pmu_style;
-+};
-+
-+#define MIPS64_CONFIG_PMC_MASK (1 << 4)
-+#define MIPS64_PMC_INT_ENABLE_MASK (1 << 4)
-+#define MIPS64_PMC_CNT_ENABLE_MASK (0xf)
-+#define MIPS64_PMC_EVT_MASK (0x7 << 6)
-+#define MIPS64_PMC_CTR_MASK (1 << 31)
-+#define MIPS64_PMD_INTERRUPT (1 << 31)
-+
-+/* Coprocessor register 25 contains the PMU interface. */
-+/* Sel 0 is control for counter 0 */
-+/* Sel 1 is count for counter 0. */
-+/* Sel 2 is control for counter 1. */
-+/* Sel 3 is count for counter 1. */
-+
-+/*
-+
-+31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4  3 2 1 0
-+M  0--------------------------------------------------------------0 Event-- IE U S K EXL
-+
-+M 31 If this bit is one, another pair of Performance Control
-+and Counter registers is implemented at a MTC0
-+
-+Event 8:5 Counter event enabled for this counter. Possible events
-+are listed in Table 6-30. R/W Undefined
-+
-+IE 4 Counter Interrupt Enable. This bit masks bit 31 of the
-+associated count register from the interrupt exception
-+request output. R/W 0
-+
-+U 3 Count in User Mode. When this bit is set, the specified
-+event is counted in User Mode. R/W Undefined
-+
-+S 2 Count in Supervisor Mode. When this bit is set, the
-+specified event is counted in Supervisor Mode. R/W Undefined
-+
-+K 1 Count in Kernel Mode. When this bit is set, count the
-+event in Kernel Mode when EXL and ERL both are 0. R/W Undefined
-+
-+EXL 0 Count when EXL. When this bit is set, count the event
-+when EXL = 1 and ERL = 0. R/W Undefined
-+*/
-+
-+static inline void pfm_arch_resend_irq(struct pfm_context *ctx)
-+{}
-+
-+static inline void pfm_arch_clear_pmd_ovfl_cond(struct pfm_context *ctx,
-+					        struct pfm_event_set *set)
-+{}
-+
-+static inline void pfm_arch_serialize(void)
-+{}
-+
-+
-+/*
-+ * MIPS does not save the PMDs during pfm_arch_intr_freeze_pmu(), thus
-+ * this routine needs to do it when switching sets on overflow
-+ */
-+static inline void pfm_arch_save_pmds_from_intr(struct pfm_context *ctx,
-+						struct pfm_event_set *set)
-+{
-+	pfm_save_pmds(ctx, set);
-+}
-+
-+static inline void pfm_arch_write_pmc(struct pfm_context *ctx,
-+				      unsigned int cnum, u64 value)
-+{
-+	/*
-+	 * we only write to the actual register when monitoring is
-+	 * active (pfm_start was issued)
-+	 */
-+	if (ctx && (ctx->flags.started == 0))
-+		return;
-+
-+	switch (pfm_pmu_conf->pmc_desc[cnum].hw_addr) {
-+	case 0:
-+		write_c0_perfctrl0(value);
-+		break;
-+	case 1:
-+		write_c0_perfctrl1(value);
-+		break;
-+	case 2:
-+		write_c0_perfctrl2(value);
-+		break;
-+	case 3:
-+		write_c0_perfctrl3(value);
-+		break;
-+	default:
-+		BUG();
-+	}
-+}
-+
-+static inline void pfm_arch_write_pmd(struct pfm_context *ctx,
-+				      unsigned int cnum, u64 value)
-+{
-+	value &= pfm_pmu_conf->ovfl_mask;
-+
-+	switch (pfm_pmu_conf->pmd_desc[cnum].hw_addr) {
-+	case 0:
-+		write_c0_perfcntr0(value);
-+		break;
-+	case 1:
-+		write_c0_perfcntr1(value);
-+		break;
-+	case 2:
-+		write_c0_perfcntr2(value);
-+		break;
-+	case 3:
-+		write_c0_perfcntr3(value);
-+		break;
-+	default:
-+		BUG();
-+	}
-+}
-+
-+static inline u64 pfm_arch_read_pmd(struct pfm_context *ctx, unsigned int cnum)
-+{
-+	switch (pfm_pmu_conf->pmd_desc[cnum].hw_addr) {
-+	case 0:
-+		return read_c0_perfcntr0();
-+		break;
-+	case 1:
-+		return read_c0_perfcntr1();
-+		break;
-+	case 2:
-+		return read_c0_perfcntr2();
-+		break;
-+	case 3:
-+		return read_c0_perfcntr3();
-+		break;
-+	default:
-+		BUG();
-+		return 0;
-+	}
-+}
-+
-+static inline u64 pfm_arch_read_pmc(struct pfm_context *ctx, unsigned int cnum)
-+{
-+	switch (pfm_pmu_conf->pmc_desc[cnum].hw_addr) {
-+	case 0:
-+		return read_c0_perfctrl0();
-+		break;
-+	case 1:
-+		return read_c0_perfctrl1();
-+		break;
-+	case 2:
-+		return read_c0_perfctrl2();
-+		break;
-+	case 3:
-+		return read_c0_perfctrl3();
-+		break;
-+	default:
-+		BUG();
-+		return 0;
-+	}
-+}
-+
-+/*
-+ * For some CPUs, the upper bits of a counter must be set in order for the
-+ * overflow interrupt to happen. On overflow, the counter has wrapped around,
-+ * and the upper bits are cleared. This function may be used to set them back.
-+ */
-+static inline void pfm_arch_ovfl_reset_pmd(struct pfm_context *ctx,
-+					   unsigned int cnum)
-+{
-+  u64 val;
-+  val = pfm_arch_read_pmd(ctx, cnum);
-+  /* This masks out overflow bit 31 */
-+  pfm_arch_write_pmd(ctx, cnum, val);
-+}
-+
-+/*
-+ * At certain points, perfmon needs to know if monitoring has been
-+ * explicitely started/stopped by user via pfm_start/pfm_stop. The
-+ * information is tracked in ctx.flags.started. However on certain
-+ * architectures, it may be possible to start/stop directly from
-+ * user level with a single assembly instruction bypassing
-+ * the kernel. This function must be used to determine by
-+ * an arch-specific mean if monitoring is actually started/stopped.
-+ */
-+static inline int pfm_arch_is_active(struct pfm_context *ctx)
-+{
-+	return ctx->flags.started;
-+}
-+
-+static inline void pfm_arch_ctxswout_sys(struct task_struct *task,
-+					 struct pfm_context *ctx)
-+{}
-+
-+static inline void pfm_arch_ctxswin_sys(struct task_struct *task,
-+					struct pfm_context *ctx)
-+{}
-+
-+static inline void pfm_arch_ctxswin_thread(struct task_struct *task,
-+					   struct pfm_context *ctx)
-+{}
-+int  pfm_arch_ctxswout_thread(struct task_struct *task,
-+			      struct pfm_context *ctx);
-+
-+int  pfm_arch_is_monitoring_active(struct pfm_context *ctx);
-+void pfm_arch_stop(struct task_struct *task, struct pfm_context *ctx);
-+void pfm_arch_start(struct task_struct *task, struct pfm_context *ctx);
-+void pfm_arch_restore_pmds(struct pfm_context *ctx, struct pfm_event_set *set);
-+void pfm_arch_restore_pmcs(struct pfm_context *ctx, struct pfm_event_set *set);
-+char *pfm_arch_get_pmu_module_name(void);
-+
-+static inline void pfm_arch_intr_freeze_pmu(struct pfm_context *ctx,
-+					    struct pfm_event_set *set)
-+{
-+	pfm_arch_stop(current, ctx);
-+	/*
-+	 * we mark monitoring as stopped to avoid
-+	 * certain side effects especially in
-+	 * pfm_switch_sets_from_intr() on
-+	 * pfm_arch_restore_pmcs()
-+	 */
-+	ctx->flags.started = 0;
-+}
-+
-+/*
-+ * unfreeze PMU from pfm_do_interrupt_handler()
-+ * ctx may be NULL for spurious
-+ */
-+static inline void pfm_arch_intr_unfreeze_pmu(struct pfm_context *ctx)
-+{
-+	if (!ctx)
-+		return;
-+
-+	PFM_DBG_ovfl("state=%d", ctx->state);
-+
-+	ctx->flags.started = 1;
-+
-+	if (ctx->state == PFM_CTX_MASKED)
-+		return;
-+
-+	pfm_arch_restore_pmcs(ctx, ctx->active_set);
-+}
-+
-+/*
-+ * this function is called from the PMU interrupt handler ONLY.
-+ * On MIPS, the PMU is frozen via arch_stop, masking would be implemented
-+ * via arch-stop as well. Given that the PMU is already stopped when
-+ * entering the interrupt handler, we do not need to stop it again, so
-+ * this function is a nop.
-+ */
-+static inline void pfm_arch_mask_monitoring(struct pfm_context *ctx,
-+					    struct pfm_event_set *set)
-+{}
-+
-+/*
-+ * on MIPS masking/unmasking uses the start/stop mechanism, so we simply
-+ * need to start here.
-+ */
-+static inline void pfm_arch_unmask_monitoring(struct pfm_context *ctx,
-+					      struct pfm_event_set *set)
-+{
-+	pfm_arch_start(current, ctx);
-+}
-+
-+static inline int pfm_arch_context_create(struct pfm_context *ctx,
-+					  u32 ctx_flags)
-+{
-+	return 0;
-+}
-+
-+static inline void pfm_arch_context_free(struct pfm_context *ctx)
-+{}
-+
-+
-+
-+
-+
-+/*
-+ * function called from pfm_setfl_sane(). Context is locked
-+ * and interrupts are masked.
-+ * The value of flags is the value of ctx_flags as passed by
-+ * user.
-+ *
-+ * function must check arch-specific set flags.
-+ * Return:
-+ * 	1 when flags are valid
-+ *      0 on error
-+ */
-+static inline int
-+pfm_arch_setfl_sane(struct pfm_context *ctx, u32 flags)
-+{
-+	return 0;
-+}
-+
-+static inline int pfm_arch_init(void)
-+{
-+	return 0;
-+}
-+
-+static inline void pfm_arch_init_percpu(void)
-+{}
-+
-+static inline int pfm_arch_load_context(struct pfm_context *ctx)
-+{
-+	return 0;
-+}
-+
-+static inline void pfm_arch_unload_context(struct pfm_context *ctx)
-+{}
-+
-+static inline int pfm_arch_pmu_acquire(u64 *unavail_pmcs, u64 *unavail_pmds)
-+{
-+	return 0;
-+}
-+
-+static inline void pfm_arch_pmu_release(void)
-+{}
-+
-+#ifdef CONFIG_PERFMON_FLUSH
-+/*
-+ * due to cache aliasing problem on MIPS, it is necessary to flush
-+ * pages out of the cache when they are modified.
-+ */
-+static inline void pfm_cacheflush(void *addr, unsigned int len)
-+{
-+	unsigned long start, end;
-+
-+	start = (unsigned long)addr & PAGE_MASK;
-+	end = ((unsigned long)addr + len + PAGE_SIZE - 1) & PAGE_MASK;
-+
-+	while (start < end) {
-+		flush_data_cache_page(start);
-+		start += PAGE_SIZE;
-+	}
-+}
-+#else
-+static inline void pfm_cacheflush(void *addr, unsigned int len)
-+{}
-+#endif
-+
-+static inline void pfm_arch_arm_handle_work(struct task_struct *task)
-+{}
-+
-+static inline void pfm_arch_disarm_handle_work(struct task_struct *task)
-+{}
-+
-+static inline int pfm_arch_pmu_config_init(struct pfm_pmu_config *cfg)
-+{
-+	return 0;
-+}
-+
-+static inline int pfm_arch_get_base_syscall(void)
-+{
-+	if (test_thread_flag(TIF_32BIT_ADDR)) {
-+		if (test_thread_flag(TIF_32BIT_REGS))
-+			return __NR_O32_Linux+330;
-+		return __NR_N32_Linux+293;
-+	}
-+	return __NR_64_Linux+289;
-+}
-+
-+struct pfm_arch_context {
-+	/* empty */
-+};
-+
-+#define PFM_ARCH_CTX_SIZE	sizeof(struct pfm_arch_context)
-+/*
-+ * MIPS may need extra alignment requirements for the sampling buffer
-+ */
-+#ifdef CONFIG_PERFMON_SMPL_ALIGN
-+#define PFM_ARCH_SMPL_ALIGN_SIZE	0x4000
-+#else
-+#define PFM_ARCH_SMPL_ALIGN_SIZE	0
-+#endif
-+
-+#endif /* CONFIG_PERFMON */
-+
-+#endif /* __KERNEL__ */
-+#endif /* _ASM_MIPS64_PERFMON_KERN_H_ */
-diff --git a/include/asm-mips/system.h b/include/asm-mips/system.h
-index a944eda..470cdfc 100644
---- a/include/asm-mips/system.h
-+++ b/include/asm-mips/system.h
-@@ -67,6 +67,10 @@ do {									\
- 	__mips_mt_fpaff_switch_to(prev);				\
- 	if (cpu_has_dsp)						\
- 		__save_dsp(prev);					\
-+	if (test_tsk_thread_flag(prev, TIF_PERFMON_CTXSW))		\
-+		pfm_ctxsw_out(prev, next);				\
-+	if (test_tsk_thread_flag(next, TIF_PERFMON_CTXSW))		\
-+		pfm_ctxsw_in(prev, next);				\
- 	(last) = resume(prev, next, task_thread_info(next));		\
- } while (0)
- 
-diff --git a/include/asm-mips/thread_info.h b/include/asm-mips/thread_info.h
-index bb30606..34fd6aa 100644
---- a/include/asm-mips/thread_info.h
-+++ b/include/asm-mips/thread_info.h
-@@ -114,6 +114,7 @@ register struct thread_info *__current_thread_info __asm__("$28");
- #define TIF_NEED_RESCHED	2	/* rescheduling necessary */
- #define TIF_SYSCALL_AUDIT	3	/* syscall auditing active */
- #define TIF_SECCOMP		4	/* secure computing */
-+#define TIF_PERFMON_WORK	5	/* work for pfm_handle_work() */
- #define TIF_RESTORE_SIGMASK	9	/* restore signal mask in do_signal() */
- #define TIF_USEDFPU		16	/* FPU was used by this task this quantum (SMP) */
- #define TIF_POLLING_NRFLAG	17	/* true if poll_idle() is polling TIF_NEED_RESCHED */
-@@ -124,6 +125,7 @@ register struct thread_info *__current_thread_info __asm__("$28");
- #define TIF_32BIT_REGS		22	/* also implies 16/32 fprs */
- #define TIF_32BIT_ADDR		23	/* 32-bit address space (o32/n32) */
- #define TIF_FPUBOUND		24	/* thread bound to FPU-full CPU set */
-+#define TIF_PERFMON_CTXSW	25	/* perfmon needs ctxsw calls */
- #define TIF_SYSCALL_TRACE	31	/* syscall trace active */
- 
- #define _TIF_SYSCALL_TRACE	(1<<TIF_SYSCALL_TRACE)
-@@ -140,6 +142,8 @@ register struct thread_info *__current_thread_info __asm__("$28");
- #define _TIF_32BIT_REGS		(1<<TIF_32BIT_REGS)
- #define _TIF_32BIT_ADDR		(1<<TIF_32BIT_ADDR)
- #define _TIF_FPUBOUND		(1<<TIF_FPUBOUND)
-+#define _TIF_PERFMON_WORK	(1<<TIF_PERFMON_WORK)
-+#define _TIF_PERFMON_CTXSW	(1<<TIF_PERFMON_CTXSW)
- 
- /* work to do on interrupt/exception return */
- #define _TIF_WORK_MASK		(0x0000ffef & ~_TIF_SECCOMP)
-diff --git a/include/asm-mips/unistd.h b/include/asm-mips/unistd.h
-index a73e153..200f654 100644
---- a/include/asm-mips/unistd.h
-+++ b/include/asm-mips/unistd.h
-@@ -350,11 +350,23 @@
- #define __NR_dup3			(__NR_Linux + 327)
- #define __NR_pipe2			(__NR_Linux + 328)
- #define __NR_inotify_init1		(__NR_Linux + 329)
-+#define __NR_pfm_create_context         (__NR_Linux + 330)
-+#define __NR_pfm_write_pmcs		(__NR_pfm_create_context+1)
-+#define __NR_pfm_write_pmds		(__NR_pfm_create_context+2)
-+#define __NR_pfm_read_pmds		(__NR_pfm_create_context+3)
-+#define __NR_pfm_load_context		(__NR_pfm_create_context+4)
-+#define __NR_pfm_start			(__NR_pfm_create_context+5)
-+#define __NR_pfm_stop			(__NR_pfm_create_context+6)
-+#define __NR_pfm_restart		(__NR_pfm_create_context+7)
-+#define __NR_pfm_create_evtsets		(__NR_pfm_create_context+8)
-+#define __NR_pfm_getinfo_evtsets 	(__NR_pfm_create_context+9)
-+#define __NR_pfm_delete_evtsets 	(__NR_pfm_create_context+10)
-+#define __NR_pfm_unload_context		(__NR_pfm_create_context+11)
- 
- /*
-  * Offset of the last Linux o32 flavoured syscall
-  */
--#define __NR_Linux_syscalls		329
-+#define __NR_Linux_syscalls		341
- 
- #endif /* _MIPS_SIM == _MIPS_SIM_ABI32 */
- 
-@@ -656,16 +668,28 @@
- #define __NR_dup3			(__NR_Linux + 286)
- #define __NR_pipe2			(__NR_Linux + 287)
- #define __NR_inotify_init1		(__NR_Linux + 288)
-+#define __NR_pfm_create_context         (__NR_Linux + 289)
-+#define __NR_pfm_write_pmcs		(__NR_pfm_create_context+1)
-+#define __NR_pfm_write_pmds		(__NR_pfm_create_context+2)
-+#define __NR_pfm_read_pmds		(__NR_pfm_create_context+3)
-+#define __NR_pfm_load_context		(__NR_pfm_create_context+4)
-+#define __NR_pfm_start			(__NR_pfm_create_context+5)
-+#define __NR_pfm_stop			(__NR_pfm_create_context+6)
-+#define __NR_pfm_restart		(__NR_pfm_create_context+7)
-+#define __NR_pfm_create_evtsets		(__NR_pfm_create_context+8)
-+#define __NR_pfm_getinfo_evtsets 	(__NR_pfm_create_context+9)
-+#define __NR_pfm_delete_evtsets 	(__NR_pfm_create_context+10)
-+#define __NR_pfm_unload_context		(__NR_pfm_create_context+11)
- 
- /*
-  * Offset of the last Linux 64-bit flavoured syscall
-  */
--#define __NR_Linux_syscalls		288
-+#define __NR_Linux_syscalls		300
- 
- #endif /* _MIPS_SIM == _MIPS_SIM_ABI64 */
- 
- #define __NR_64_Linux			5000
--#define __NR_64_Linux_syscalls		288
-+#define __NR_64_Linux_syscalls		300
- 
- #if _MIPS_SIM == _MIPS_SIM_NABI32
- 
-@@ -966,16 +990,28 @@
- #define __NR_dup3			(__NR_Linux + 290)
- #define __NR_pipe2			(__NR_Linux + 291)
- #define __NR_inotify_init1		(__NR_Linux + 292)
-+#define __NR_pfm_create_context         (__NR_Linux + 293)
-+#define __NR_pfm_write_pmcs		(__NR_pfm_create_context+1)
-+#define __NR_pfm_write_pmds		(__NR_pfm_create_context+2)
-+#define __NR_pfm_read_pmds		(__NR_pfm_create_context+3)
-+#define __NR_pfm_load_context		(__NR_pfm_create_context+4)
-+#define __NR_pfm_start			(__NR_pfm_create_context+5)
-+#define __NR_pfm_stop			(__NR_pfm_create_context+6)
-+#define __NR_pfm_restart		(__NR_pfm_create_context+7)
-+#define __NR_pfm_create_evtsets		(__NR_pfm_create_context+8)
-+#define __NR_pfm_getinfo_evtsets 	(__NR_pfm_create_context+9)
-+#define __NR_pfm_delete_evtsets 	(__NR_pfm_create_context+10)
-+#define __NR_pfm_unload_context		(__NR_pfm_create_context+11)
- 
- /*
-  * Offset of the last N32 flavoured syscall
-  */
--#define __NR_Linux_syscalls		292
-+#define __NR_Linux_syscalls		304
- 
- #endif /* _MIPS_SIM == _MIPS_SIM_NABI32 */
- 
- #define __NR_N32_Linux			6000
--#define __NR_N32_Linux_syscalls		292
-+#define __NR_N32_Linux_syscalls		304
- 
- #ifdef __KERNEL__
- 
-diff --git a/include/asm-x86/Kbuild b/include/asm-x86/Kbuild
-index 4a8e80c..d7d819e 100644
---- a/include/asm-x86/Kbuild
-+++ b/include/asm-x86/Kbuild
-@@ -9,6 +9,7 @@ header-y += prctl.h
- header-y += ptrace-abi.h
- header-y += sigcontext32.h
- header-y += ucontext.h
-+header-y += perfmon.h
- header-y += processor-flags.h
- 
- unifdef-y += e820.h
-diff --git a/include/asm-x86/ia32_unistd.h b/include/asm-x86/ia32_unistd.h
-index 61cea9e..275e015 100644
---- a/include/asm-x86/ia32_unistd.h
-+++ b/include/asm-x86/ia32_unistd.h
-@@ -8,11 +8,12 @@
-  * the number. This should be otherwise in sync with asm-x86/unistd_32.h. -AK
-  */
- 
--#define __NR_ia32_restart_syscall 0
--#define __NR_ia32_exit		  1
--#define __NR_ia32_read		  3
--#define __NR_ia32_write		  4
--#define __NR_ia32_sigreturn	119
--#define __NR_ia32_rt_sigreturn	173
-+#define __NR_ia32_restart_syscall    0
-+#define __NR_ia32_exit		     1
-+#define __NR_ia32_read		     3
-+#define __NR_ia32_write		     4
-+#define __NR_ia32_sigreturn	     119
-+#define __NR_ia32_rt_sigreturn	     173
-+#define __NR_ia32_pfm_create_context 333
- 
- #endif /* _ASM_X86_64_IA32_UNISTD_H_ */
-diff --git a/include/asm-x86/irq_vectors.h b/include/asm-x86/irq_vectors.h
-index a48c7f2..892fe8f 100644
---- a/include/asm-x86/irq_vectors.h
-+++ b/include/asm-x86/irq_vectors.h
-@@ -92,6 +92,11 @@
- #define LOCAL_TIMER_VECTOR	0xef
- 
- /*
-+ * Perfmon PMU interrupt vector
-+ */
-+#define LOCAL_PERFMON_VECTOR	0xee
-+
-+/*
-  * First APIC vector available to drivers: (vectors 0x30-0xee) we
-  * start at 0x31(0x41) to spread out vectors evenly between priority
-  * levels. (0x80 is the syscall vector)
-diff --git a/include/asm-x86/mach-default/entry_arch.h b/include/asm-x86/mach-default/entry_arch.h
-index 9283b60..ac31c2d 100644
---- a/include/asm-x86/mach-default/entry_arch.h
-+++ b/include/asm-x86/mach-default/entry_arch.h
-@@ -32,4 +32,8 @@ BUILD_INTERRUPT(spurious_interrupt,SPURIOUS_APIC_VECTOR)
- BUILD_INTERRUPT(thermal_interrupt,THERMAL_APIC_VECTOR)
- #endif
- 
-+#ifdef CONFIG_PERFMON
-+BUILD_INTERRUPT(pmu_interrupt,LOCAL_PERFMON_VECTOR)
-+#endif
-+
- #endif
-diff --git a/include/asm-x86/perfmon.h b/include/asm-x86/perfmon.h
-new file mode 100644
-index 0000000..906f4b2
---- /dev/null
-+++ b/include/asm-x86/perfmon.h
-@@ -0,0 +1,34 @@
-+/*
-+ * Copyright (c) 2007 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This file contains i386/x86_64 specific definitions for the perfmon
-+ * interface.
-+ *
-+ * This file MUST never be included directly. Use linux/perfmon.h.
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+  */
-+#ifndef _ASM_X86_PERFMON__H_
-+#define _ASM_X86_PERFMON__H_
-+
-+/*
-+ * arch-specific user visible interface definitions
-+ */
-+
-+#define PFM_ARCH_MAX_PMCS	(256+64) /* 256 HW 64 SW */
-+#define PFM_ARCH_MAX_PMDS	(256+64) /* 256 HW 64 SW */
-+
-+#endif /* _ASM_X86_PERFMON_H_ */
-diff --git a/include/asm-x86/perfmon_kern.h b/include/asm-x86/perfmon_kern.h
-new file mode 100644
-index 0000000..0e5d3a5
---- /dev/null
-+++ b/include/asm-x86/perfmon_kern.h
-@@ -0,0 +1,548 @@
-+/*
-+ * Copyright (c) 2005-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * Copyright (c) 2007 Advanced Micro Devices, Inc.
-+ * Contributed by Robert Richter <robert.richter@amd.com>
-+ *
-+ * This file contains X86 Processor Family specific definitions
-+ * for the perfmon interface. This covers P6, Pentium M, P4/Xeon
-+ * (32-bit and 64-bit, i.e., EM64T) and AMD X86-64.
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+  */
-+#ifndef _ASM_X86_PERFMON_KERN_H_
-+#define _ASM_X86_PERFMON_KERN_H_
-+
-+#ifdef CONFIG_PERFMON
-+#include <linux/unistd.h>
-+#ifdef CONFIG_4KSTACKS
-+#define PFM_ARCH_PMD_STK_ARG	2
-+#define PFM_ARCH_PMC_STK_ARG	2
-+#else
-+#define PFM_ARCH_PMD_STK_ARG	4 /* about 700 bytes of stack space */
-+#define PFM_ARCH_PMC_STK_ARG	4 /* about 200 bytes of stack space */
-+#endif
-+
-+struct pfm_arch_pmu_info {
-+	u32 flags;		/* PMU feature flags */
-+	/*
-+	 * mandatory model-specific callbacks
-+	 */
-+	int  (*stop_save)(struct pfm_context *ctx, struct pfm_event_set *set);
-+	int  (*has_ovfls)(struct pfm_context *ctx);
-+	void (*quiesce)(void);
-+
-+	/*
-+	 * optional model-specific callbacks
-+	 */
-+	void (*acquire_pmu_percpu)(void);
-+	void (*release_pmu_percpu)(void);
-+	int (*create_context)(struct pfm_context *ctx, u32 ctx_flags);
-+	void (*free_context)(struct pfm_context *ctx);
-+	int (*load_context)(struct pfm_context *ctx);
-+	void (*unload_context)(struct pfm_context *ctx);
-+	void (*write_pmc)(struct pfm_context *ctx, unsigned int cnum, u64 value);
-+	void (*write_pmd)(struct pfm_context *ctx, unsigned int cnum, u64 value);
-+	u64  (*read_pmd)(struct pfm_context *ctx, unsigned int cnum);
-+	u64  (*read_pmc)(struct pfm_context *ctx, unsigned int cnum);
-+	void (*nmi_copy_state)(struct pfm_context *ctx);
-+	void (*restore_pmcs)(struct pfm_context *ctx,
-+			     struct pfm_event_set *set);
-+	void (*restore_pmds)(struct pfm_context *ctx,
-+			     struct pfm_event_set *set);
-+};
-+
-+/*
-+ * PMU feature flags
-+ */
-+#define PFM_X86_FL_USE_NMI	0x01	/* user asking for NMI */
-+#define PFM_X86_FL_NO_SHARING	0x02	/* no sharing with other subsystems */
-+#define PFM_X86_FL_SHARING	0x04	/* PMU is being shared */
-+
-+struct pfm_x86_ctx_flags {
-+	unsigned int insecure:1;  /* rdpmc per-thread self-monitoring */
-+	unsigned int use_pebs:1;  /* PEBS used */
-+	unsigned int use_ds:1;    /* DS used */
-+	unsigned int reserved:29; /* for future use */
-+};
-+
-+struct pfm_arch_context {
-+	u64 saved_real_iip;		/* instr pointer of last NMI intr */
-+	struct pfm_x86_ctx_flags flags;	/* flags */
-+	void *ds_area;			/* address of DS area (to go away) */
-+	void *data;			/* model-specific data */
-+};
-+
-+/*
-+ * functions implemented as inline on x86
-+ */
-+
-+/**
-+ * pfm_arch_write_pmc - write a single PMC register
-+ * @ctx: context to work on
-+ * @cnum: PMC index
-+ * @value: PMC 64-bit value
-+ *
-+ * in certain situations, ctx may be NULL
-+ */
-+static inline void pfm_arch_write_pmc(struct pfm_context *ctx,
-+				      unsigned int cnum, u64 value)
-+{
-+	struct pfm_arch_pmu_info *pmu_info;
-+
-+	pmu_info = pfm_pmu_info();
-+
-+	/*
-+	 * we only write to the actual register when monitoring is
-+	 * active (pfm_start was issued)
-+	 */
-+	if (ctx && ctx->flags.started == 0)
-+		return;
-+
-+	/*
-+	 * model-specific override, if any
-+	 */
-+	if (pmu_info->write_pmc) {
-+		pmu_info->write_pmc(ctx, cnum, value);
-+		return;
-+	}
-+
-+	PFM_DBG_ovfl("pfm_arch_write_pmc(0x%lx, 0x%Lx)",
-+		     pfm_pmu_conf->pmc_desc[cnum].hw_addr,
-+		     (unsigned long long) value);
-+
-+	wrmsrl(pfm_pmu_conf->pmc_desc[cnum].hw_addr, value);
-+}
-+
-+/**
-+ * pfm_arch_write_pmd - write a single PMD register
-+ * @ctx: context to work on
-+ * @cnum: PMD index
-+ * @value: PMD 64-bit value
-+ */
-+static inline void pfm_arch_write_pmd(struct pfm_context *ctx,
-+				      unsigned int cnum, u64 value)
-+{
-+	struct pfm_arch_pmu_info *pmu_info;
-+
-+	pmu_info = pfm_pmu_info();
-+
-+	/*
-+	 * to make sure the counter overflows, we set the
-+	 * upper bits. we also clear any other unimplemented
-+	 * bits as this may cause crash on some processors.
-+	 */
-+	if (pfm_pmu_conf->pmd_desc[cnum].type & PFM_REG_C64)
-+		value = (value | ~pfm_pmu_conf->ovfl_mask)
-+		      & ~pfm_pmu_conf->pmd_desc[cnum].rsvd_msk;
-+
-+	PFM_DBG_ovfl("pfm_arch_write_pmd(0x%lx, 0x%Lx)",
-+		     pfm_pmu_conf->pmd_desc[cnum].hw_addr,
-+		     (unsigned long long) value);
-+
-+	/*
-+	 * model-specific override, if any
-+	 */
-+	if (pmu_info->write_pmd) {
-+		pmu_info->write_pmd(ctx, cnum, value);
-+		return;
-+	}
-+
-+	wrmsrl(pfm_pmu_conf->pmd_desc[cnum].hw_addr, value);
-+}
-+
-+/**
-+ * pfm_arch_read_pmd - read a single PMD register
-+ * @ctx: context to work on
-+ * @cnum: PMD index
-+ *
-+ * return value is register 64-bit value
-+ */
-+static inline u64 pfm_arch_read_pmd(struct pfm_context *ctx, unsigned int cnum)
-+{
-+	struct pfm_arch_pmu_info *pmu_info;
-+	u64 tmp;
-+
-+	pmu_info = pfm_pmu_info();
-+
-+	/*
-+	 * model-specific override, if any
-+	 */
-+	if (pmu_info->read_pmd)
-+		tmp = pmu_info->read_pmd(ctx, cnum);
-+	else
-+		rdmsrl(pfm_pmu_conf->pmd_desc[cnum].hw_addr, tmp);
-+
-+	PFM_DBG_ovfl("pfm_arch_read_pmd(0x%lx) = 0x%Lx",
-+		     pfm_pmu_conf->pmd_desc[cnum].hw_addr,
-+		     (unsigned long long) tmp);
-+	return tmp;
-+}
-+
-+/**
-+ * pfm_arch_read_pmc - read a single PMC register
-+ * @ctx: context to work on
-+ * @cnum: PMC index
-+ *
-+ * return value is register 64-bit value
-+ */
-+static inline u64 pfm_arch_read_pmc(struct pfm_context *ctx, unsigned int cnum)
-+{
-+	struct pfm_arch_pmu_info *pmu_info;
-+	u64 tmp;
-+
-+	pmu_info = pfm_pmu_info();
-+
-+	/*
-+	 * model-specific override, if any
-+	 */
-+	if (pmu_info->read_pmc)
-+		tmp = pmu_info->read_pmc(ctx, cnum);
-+	else
-+		rdmsrl(pfm_pmu_conf->pmc_desc[cnum].hw_addr, tmp);
-+
-+	PFM_DBG_ovfl("pfm_arch_read_pmc(0x%lx) = 0x%016Lx",
-+		     pfm_pmu_conf->pmc_desc[cnum].hw_addr,
-+		     (unsigned long long) tmp);
-+	return tmp;
-+}
-+
-+/**
-+ * pfm_arch_is_active - return non-zero is monitoring has been started
-+ * @ctx: context to check
-+ *
-+ * At certain points, perfmon needs to know if monitoring has been
-+ * explicitly started.
-+ *
-+ * On x86, there is not other way but to use pfm_start/pfm_stop
-+ * to activate monitoring, thus we can simply check flags.started
-+ */
-+static inline int pfm_arch_is_active(struct pfm_context *ctx)
-+{
-+	return ctx->flags.started;
-+}
-+
-+
-+/**
-+ * pfm_arch_unload_context - detach context from thread or CPU
-+ * @ctx: context to detach
-+ *
-+ * in system-wide ctx->task is NULL, otherwise it points to the
-+ * attached thread
-+ */
-+static inline void pfm_arch_unload_context(struct pfm_context *ctx)
-+{
-+	struct pfm_arch_pmu_info *pmu_info;
-+	struct pfm_arch_context *ctx_arch;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+	pmu_info = pfm_pmu_info();
-+
-+	if (ctx_arch->flags.insecure) {
-+		PFM_DBG("clear cr4.pce");
-+		clear_in_cr4(X86_CR4_PCE);
-+	}
-+
-+	if (pmu_info->unload_context)
-+		pmu_info->unload_context(ctx);
-+}
-+
-+/**
-+ * pfm_arch_load_context - attach context to thread or CPU
-+ * @ctx: context to attach
-+ */
-+static inline int pfm_arch_load_context(struct pfm_context *ctx)
-+{
-+	struct pfm_arch_pmu_info *pmu_info;
-+	struct pfm_arch_context *ctx_arch;
-+	int ret = 0;
-+
-+	ctx_arch = pfm_ctx_arch(ctx);
-+	pmu_info = pfm_pmu_info();
-+
-+	/*
-+	 * RDPMC authorized in system-wide and
-+	 * per-thread self-monitoring.
-+	 *
-+	 * RDPMC only gives access to counts.
-+	 *
-+	 * The context-switch routine code does not restore
-+	 * all the PMD registers (optimization), thus there
-+	 * is a possible leak of counts there in per-thread
-+	 * mode.
-+	 */
-+	if (ctx->task == current || ctx->flags.system) {
-+		PFM_DBG("set cr4.pce");
-+		set_in_cr4(X86_CR4_PCE);
-+		ctx_arch->flags.insecure = 1;
-+	}
-+
-+	if (pmu_info->load_context)
-+		ret = pmu_info->load_context(ctx);
-+
-+	return ret;
-+}
-+
-+void pfm_arch_restore_pmcs(struct pfm_context *ctx, struct pfm_event_set *set);
-+void pfm_arch_start(struct task_struct *task, struct pfm_context *ctx);
-+void pfm_arch_stop(struct task_struct *task, struct pfm_context *ctx);
-+
-+/**
-+ * pfm_arch_unmask_monitoring - unmask monitoring
-+ * @ctx: context to mask
-+ * @set: current event set
-+ *
-+ * masking is slightly different from stopping in that, it does not undo
-+ * the pfm_start() issued by user. This is used in conjunction with
-+ * sampling. Masking means stop monitoring, but do not authorize user
-+ * to issue pfm_start/stop during that time. Unmasking is achieved via
-+ * pfm_restart() and also may also depend on the sampling format used.
-+ *
-+ * on x86 masking/unmasking use the start/stop mechanism, except
-+ * that flags.started is not modified.
-+ */
-+static inline void pfm_arch_unmask_monitoring(struct pfm_context *ctx,
-+					      struct pfm_event_set *set)
-+{
-+	pfm_arch_start(current, ctx);
-+}
-+
-+/**
-+ * pfm_arch_intr_freeze_pmu - stop monitoring when handling PMU interrupt
-+ * @ctx: current context
-+ * @set: current event set
-+ *
-+ * called from __pfm_interrupt_handler().
-+ * ctx is not NULL. ctx is locked. interrupts are masked
-+ *
-+ * The following actions must take place:
-+ *  - stop all monitoring to ensure handler has consistent view.
-+ *  - collect overflowed PMDs bitmask into povfls_pmds and
-+ *    npend_ovfls. If no interrupt detected then npend_ovfls
-+ *    must be set to zero.
-+ */
-+static inline void pfm_arch_intr_freeze_pmu(struct pfm_context *ctx,
-+					    struct pfm_event_set *set)
-+{
-+	/*
-+	 * on X86, freezing is equivalent to stopping
-+	 */
-+	pfm_arch_stop(current, ctx);
-+
-+	/*
-+	 * we mark monitoring as stopped to avoid
-+	 * certain side effects especially in
-+	 * pfm_switch_sets_from_intr() and
-+	 * pfm_arch_restore_pmcs()
-+	 */
-+	ctx->flags.started = 0;
-+}
-+
-+/**
-+ * pfm_arch_intr_unfreeze_pmu - conditionally reactive monitoring
-+ * @ctx: current context
-+ *
-+ * current context may be not when dealing when spurious interrupts
-+ *
-+ * Must re-activate monitoring if context is not MASKED.
-+ * interrupts are masked.
-+ */
-+static inline void pfm_arch_intr_unfreeze_pmu(struct pfm_context *ctx)
-+{
-+	if (ctx == NULL)
-+		return;
-+
-+	PFM_DBG_ovfl("state=%d", ctx->state);
-+
-+	/*
-+	 * restore flags.started which is cleared in
-+	 * pfm_arch_intr_freeze_pmu()
-+	 */
-+	ctx->flags.started = 1;
-+
-+	if (ctx->state == PFM_CTX_MASKED)
-+		return;
-+
-+	pfm_arch_restore_pmcs(ctx, ctx->active_set);
-+}
-+
-+/**
-+ * pfm_arch_setfl_sane - check arch/model specific event set flags
-+ * @ctx: context to work on
-+ * @flags: event set flags as passed by user
-+ *
-+ * called from pfm_setfl_sane(). Context is locked. Interrupts are masked.
-+ *
-+ * Return:
-+ *      0 when flags are valid
-+ *      1 on error
-+ */
-+static inline int pfm_arch_setfl_sane(struct pfm_context *ctx, u32 flags)
-+{
-+	return 0;
-+}
-+
-+/**
-+ * pfm_arch_ovfl_reset_pmd - reset pmd on overflow
-+ * @ctx: current context
-+ * @cnum: PMD index
-+ *
-+ * On some CPUs, the upper bits of a counter must be set in order for the
-+ * overflow interrupt to happen. On overflow, the counter has wrapped around,
-+ * and the upper bits are cleared. This function may be used to set them back.
-+ *
-+ * For x86, the current version loses whatever is remaining in the counter,
-+ * which is usually has a small count. In order not to loose this count,
-+ * we do a read-modify-write to set the upper bits while preserving the
-+ * low-order bits. This is slow but works.
-+ */
-+static inline void pfm_arch_ovfl_reset_pmd(struct pfm_context *ctx, unsigned int cnum)
-+{
-+	u64 val;
-+	val = pfm_arch_read_pmd(ctx, cnum);
-+	pfm_arch_write_pmd(ctx, cnum, val);
-+}
-+
-+/**
-+ * pfm_arch_context_create - create context
-+ * @ctx: newly created context
-+ * @flags: context flags as passed by user
-+ *
-+ * called from __pfm_create_context()
-+ */
-+static inline int pfm_arch_context_create(struct pfm_context *ctx, u32 ctx_flags)
-+{
-+	struct pfm_arch_pmu_info *pmu_info;
-+
-+	pmu_info = pfm_pmu_info();
-+
-+	if (pmu_info->create_context)
-+		return pmu_info->create_context(ctx, ctx_flags);
-+
-+	return 0;
-+}
-+
-+/**
-+ * pfm_arch_context_free - free context
-+ * @ctx: context to free
-+ */
-+static inline void pfm_arch_context_free(struct pfm_context *ctx)
-+{
-+	struct pfm_arch_pmu_info *pmu_info;
-+
-+	pmu_info = pfm_pmu_info();
-+
-+	if (pmu_info->free_context)
-+		pmu_info->free_context(ctx);
-+}
-+
-+/*
-+ * pfm_arch_clear_pmd_ovfl_cond - alter the pmds in such a way that they
-+ * will not cause cause interrupts when unused.
-+ *
-+ * This is a nop on x86
-+ */
-+static inline void pfm_arch_clear_pmd_ovfl_cond(struct pfm_context *ctx,
-+					        struct pfm_event_set *set)
-+{}
-+
-+/*
-+ * functions implemented in arch/x86/perfmon/perfmon.c
-+ */
-+int  pfm_arch_init(void);
-+void pfm_arch_resend_irq(struct pfm_context *ctx);
-+
-+int  pfm_arch_ctxswout_thread(struct task_struct *task, struct pfm_context *ctx);
-+void pfm_arch_ctxswin_thread(struct task_struct *task, struct pfm_context *ctx);
-+
-+void pfm_arch_restore_pmds(struct pfm_context *ctx, struct pfm_event_set *set);
-+int  pfm_arch_pmu_config_init(struct pfm_pmu_config *cfg);
-+void pfm_arch_pmu_config_remove(void);
-+char *pfm_arch_get_pmu_module_name(void);
-+int pfm_arch_pmu_acquire(u64 *unavail_pmcs, u64 *unavail_pmds);
-+void pfm_arch_pmu_release(void);
-+
-+/*
-+ * pfm_arch_serialize - make PMU modifications visible to subsequent instructions
-+ *
-+ * This is a nop on x86
-+ */
-+static inline void pfm_arch_serialize(void)
-+{}
-+
-+/*
-+ * on x86, the PMDs are already saved by pfm_arch_freeze_pmu()
-+ * when entering the PMU interrupt handler, thus, we do not need
-+ * to save them again in pfm_switch_sets_from_intr()
-+ */
-+static inline void pfm_arch_save_pmds_from_intr(struct pfm_context *ctx,
-+						struct pfm_event_set *set)
-+{}
-+
-+
-+static inline void pfm_arch_ctxswout_sys(struct task_struct *task,
-+					 struct pfm_context *ctx)
-+{}
-+
-+static inline void pfm_arch_ctxswin_sys(struct task_struct *task,
-+					struct pfm_context *ctx)
-+{}
-+
-+static inline void pfm_arch_init_percpu(void)
-+{}
-+
-+static inline void pfm_cacheflush(void *addr, unsigned int len)
-+{}
-+
-+/*
-+ * this function is called from the PMU interrupt handler ONLY.
-+ * On x86, the PMU is frozen via arch_stop, masking would be implemented
-+ * via arch-stop as well. Given that the PMU is already stopped when
-+ * entering the interrupt handler, we do not need to stop it again, so
-+ * this function is a nop.
-+ */
-+static inline void pfm_arch_mask_monitoring(struct pfm_context *ctx,
-+					    struct pfm_event_set *set)
-+{}
-+
-+
-+static inline void pfm_arch_arm_handle_work(struct task_struct *task)
-+{}
-+
-+static inline void pfm_arch_disarm_handle_work(struct task_struct *task)
-+{}
-+
-+static inline int pfm_arch_get_base_syscall(void)
-+{
-+#ifdef __x86_64__
-+	/* 32-bit syscall definition coming from ia32_unistd.h */
-+	if (test_thread_flag(TIF_IA32))
-+		return __NR_ia32_pfm_create_context;
-+#endif
-+	return __NR_pfm_create_context;
-+}
-+
-+#define PFM_ARCH_CTX_SIZE	(sizeof(struct pfm_arch_context))
-+/*
-+ * x86 does not need extra alignment requirements for the sampling buffer
-+ */
-+#define PFM_ARCH_SMPL_ALIGN_SIZE	0
-+
-+asmlinkage void  pmu_interrupt(void);
-+
-+#endif /* CONFIG_PEFMON */
-+
-+#endif /* _ASM_X86_PERFMON_KERN_H_ */
-diff --git a/include/asm-x86/perfmon_pebs_core_smpl.h b/include/asm-x86/perfmon_pebs_core_smpl.h
-new file mode 100644
-index 0000000..4a12e0d
---- /dev/null
-+++ b/include/asm-x86/perfmon_pebs_core_smpl.h
-@@ -0,0 +1,164 @@
-+/*
-+ * Copyright (c) 2005-2007 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ *
-+ * This file implements the sampling format to support Intel
-+ * Precise Event Based Sampling (PEBS) feature of Intel Core
-+ * processors, such as Intel Core 2.
-+ *
-+ * What is PEBS?
-+ * ------------
-+ *  This is a hardware feature to enhance sampling by providing
-+ *  better precision as to where a sample is taken. This avoids the
-+ *  typical skew in the instruction one can observe with any
-+ *  interrupt-based sampling technique.
-+ *
-+ *  PEBS also lowers sampling overhead significantly by having the
-+ *  processor store samples instead of the OS. PMU interrupt are only
-+ *  generated after multiple samples are written.
-+ *
-+ *  Another benefit of PEBS is that samples can be captured inside
-+ *  critical sections where interrupts are masked.
-+ *
-+ * How does it work?
-+ *  PEBS effectively implements a Hw buffer. The Os must pass a region
-+ *  of memory where samples are to be stored. The region can have any
-+ *  size. The OS must also specify the sampling period to reload. The PMU
-+ *  will interrupt when it reaches the end of the buffer or a specified
-+ *  threshold location inside the memory region.
-+ *
-+ *  The description of the buffer is stored in the Data Save Area (DS).
-+ *  The samples are stored sequentially in the buffer. The format of the
-+ *  buffer is fixed and specified in the PEBS documentation.  The sample
-+ *  format does not change between 32-bit and 64-bit modes unlike on the
-+ *  Pentium 4 version of PEBS.
-+ *
-+ *  PEBS does not work when HyperThreading is enabled due to certain MSR
-+ *  being shared being to two threads.
-+ *
-+ *  What does the format do?
-+ *   It provides access to the PEBS feature for both 32-bit and 64-bit
-+ *   processors that support it.
-+ *
-+ *   The same code and data structures are used for both 32-bit and 64-bi
-+ *   modes. A single format name is used for both modes. In 32-bit mode,
-+ *   some of the extended registers are written to zero in each sample.
-+ *
-+ *   It is important to realize that the format provides a zero-copy
-+ *   environment for the samples, i.e,, the OS never touches the
-+ *   samples. Whatever the processor write is directly accessible to
-+ *   the user.
-+ *
-+ *   Parameters to the buffer can be passed via pfm_create_context() in
-+ *   the pfm_pebs_smpl_arg structure.
-+ */
-+#ifndef __PERFMON_PEBS_CORE_SMPL_H__
-+#define __PERFMON_PEBS_CORE_SMPL_H__ 1
-+
-+/*
-+ * The 32-bit and 64-bit formats are identical, thus we use only
-+ * one name for the format.
-+ */
-+#define PFM_PEBS_CORE_SMPL_NAME	"pebs_core"
-+
-+/*
-+ * format specific parameters (passed at context creation)
-+ *
-+ * intr_thres: index from start of buffer of entry where the
-+ * PMU interrupt must be triggered. It must be several samples
-+ * short of the end of the buffer.
-+ */
-+struct pfm_pebs_core_smpl_arg {
-+	u64 cnt_reset;	  /* counter reset value */
-+	size_t buf_size;  /* size of the PEBS buffer in bytes */
-+	size_t intr_thres;/* index of PEBS interrupt threshold entry */
-+	u64 reserved[6];  /* for future use */
-+};
-+
-+/*
-+ * Data Save Area (32 and 64-bit mode)
-+ *
-+ * The DS area is exposed to the user. To determine the number
-+ * of samples available in PEBS, it is necessary to substract
-+ * pebs_index from pebs_base.
-+ *
-+ * Layout of the structure is mandated by hardware and specified
-+ * in the Intel documentation.
-+ */
-+struct pfm_ds_area_core {
-+	u64 bts_buf_base;
-+	u64 bts_index;
-+	u64 bts_abs_max;
-+	u64 bts_intr_thres;
-+	u64 pebs_buf_base;
-+	u64 pebs_index;
-+	u64 pebs_abs_max;
-+	u64 pebs_intr_thres;
-+	u64 pebs_cnt_reset;
-+};
-+
-+/*
-+ * This header is at the beginning of the sampling buffer returned to the user.
-+ *
-+ * Because of PEBS alignement constraints, the actual PEBS buffer area does
-+ * not necessarily begin right after the header. The hdr_start_offs must be
-+ * used to compute the first byte of the buffer. The offset is defined as
-+ * the number of bytes between the end of the header and the beginning of
-+ * the buffer. As such the formula is:
-+ * 	actual_buffer = (unsigned long)(hdr+1)+hdr->hdr_start_offs
-+ */
-+struct pfm_pebs_core_smpl_hdr {
-+	u64 overflows;			/* #overflows for buffer */
-+	size_t buf_size;		/* bytes in the buffer */
-+	size_t start_offs; 		/* actual buffer start offset */
-+	u32 version;			/* smpl format version */
-+	u32 reserved1;			/* for future use */
-+	u64 reserved2[5];		/* for future use */
-+	struct pfm_ds_area_core ds;	/* data save area */
-+};
-+
-+/*
-+ * Sample format as mandated by Intel documentation.
-+ * The same format is used in both 32 and 64 bit modes.
-+ */
-+struct pfm_pebs_core_smpl_entry {
-+	u64	eflags;
-+	u64	ip;
-+	u64	eax;
-+	u64	ebx;
-+	u64	ecx;
-+	u64	edx;
-+	u64	esi;
-+	u64	edi;
-+	u64	ebp;
-+	u64	esp;
-+	u64	r8;	/* 0 in 32-bit mode */
-+	u64	r9;	/* 0 in 32-bit mode */
-+	u64	r10;	/* 0 in 32-bit mode */
-+	u64	r11;	/* 0 in 32-bit mode */
-+	u64	r12;	/* 0 in 32-bit mode */
-+	u64	r13;	/* 0 in 32-bit mode */
-+	u64	r14;	/* 0 in 32-bit mode */
-+	u64	r15;	/* 0 in 32-bit mode */
-+};
-+
-+#define PFM_PEBS_CORE_SMPL_VERSION_MAJ 1U
-+#define PFM_PEBS_CORE_SMPL_VERSION_MIN 0U
-+#define PFM_PEBS_CORE_SMPL_VERSION (((PFM_PEBS_CORE_SMPL_VERSION_MAJ&0xffff)<<16)|\
-+				   (PFM_PEBS_CORE_SMPL_VERSION_MIN & 0xffff))
-+
-+#endif /* __PERFMON_PEBS_CORE_SMPL_H__ */
-diff --git a/include/asm-x86/perfmon_pebs_p4_smpl.h b/include/asm-x86/perfmon_pebs_p4_smpl.h
-new file mode 100644
-index 0000000..26b51b4
---- /dev/null
-+++ b/include/asm-x86/perfmon_pebs_p4_smpl.h
-@@ -0,0 +1,193 @@
-+/*
-+ * Copyright (c) 2005-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ *
-+ * This file implements the sampling format to support Intel
-+ * Precise Event Based Sampling (PEBS) feature of Pentium 4
-+ * and other Netburst-based processors. Not to be used for
-+ * Intel Core-based processors.
-+ *
-+ * What is PEBS?
-+ * ------------
-+ *  This is a hardware feature to enhance sampling by providing
-+ *  better precision as to where a sample is taken. This avoids the
-+ *  typical skew in the instruction one can observe with any
-+ *  interrupt-based sampling technique.
-+ *
-+ *  PEBS also lowers sampling overhead significantly by having the
-+ *  processor store samples instead of the OS. PMU interrupt are only
-+ *  generated after multiple samples are written.
-+ *
-+ *  Another benefit of PEBS is that samples can be captured inside
-+ *  critical sections where interrupts are masked.
-+ *
-+ * How does it work?
-+ *  PEBS effectively implements a Hw buffer. The Os must pass a region
-+ *  of memory where samples are to be stored. The region can have any
-+ *  size. The OS must also specify the sampling period to reload. The PMU
-+ *  will interrupt when it reaches the end of the buffer or a specified
-+ *  threshold location inside the memory region.
-+ *
-+ *  The description of the buffer is stored in the Data Save Area (DS).
-+ *  The samples are stored sequentially in the buffer. The format of the
-+ *  buffer is fixed and specified in the PEBS documentation.  The sample
-+ *  format changes between 32-bit and 64-bit modes due to extended register
-+ *  file.
-+ *
-+ *  PEBS does not work when HyperThreading is enabled due to certain MSR
-+ *  being shared being to two threads.
-+ *
-+ *  What does the format do?
-+ *   It provides access to the PEBS feature for both 32-bit and 64-bit
-+ *   processors that support it.
-+ *
-+ *   The same code is used for both 32-bit and 64-bit modes, but different
-+ *   format names are used because the two modes are not compatible due to
-+ *   data model and register file differences. Similarly the public data
-+ *   structures describing the samples are different.
-+ *
-+ *   It is important to realize that the format provides a zero-copy environment
-+ *   for the samples, i.e,, the OS never touches the samples. Whatever the
-+ *   processor write is directly accessible to the user.
-+ *
-+ *   Parameters to the buffer can be passed via pfm_create_context() in
-+ *   the pfm_pebs_smpl_arg structure.
-+ *
-+ *   It is not possible to mix a 32-bit PEBS application on top of a 64-bit
-+ *   host kernel.
-+ */
-+#ifndef __PERFMON_PEBS_P4_SMPL_H__
-+#define __PERFMON_PEBS_P4_SMPL_H__ 1
-+
-+#ifdef __i386__
-+/*
-+ * The 32-bit and 64-bit formats are not compatible, thus we have
-+ * two different identifications so that 32-bit programs running on
-+ * 64-bit OS will fail to use the 64-bit PEBS support.
-+ */
-+#define PFM_PEBS_P4_SMPL_NAME	"pebs32_p4"
-+#else
-+#define PFM_PEBS_P4_SMPL_NAME	"pebs64_p4"
-+#endif
-+
-+/*
-+ * format specific parameters (passed at context creation)
-+ *
-+ * intr_thres: index from start of buffer of entry where the
-+ * PMU interrupt must be triggered. It must be several samples
-+ * short of the end of the buffer.
-+ */
-+struct pfm_pebs_p4_smpl_arg {
-+	u64 cnt_reset;	  /* counter reset value */
-+	size_t buf_size;  /* size of the PEBS buffer in bytes */
-+	size_t intr_thres;/* index of PEBS interrupt threshold entry */
-+	u64 reserved[6];  /* for future use */
-+};
-+
-+/*
-+ * Data Save Area (32 and 64-bit mode)
-+ *
-+ * The DS area must be exposed to the user because this is the only
-+ * way to report on the number of valid entries recorded by the CPU.
-+ * This is required when the buffer is not full, i..e, there was not
-+ * PMU interrupt.
-+ *
-+ * Layout of the structure is mandated by hardware and specified in
-+ * the Intel documentation.
-+ */
-+struct pfm_ds_area_p4 {
-+	unsigned long	bts_buf_base;
-+	unsigned long	bts_index;
-+	unsigned long	bts_abs_max;
-+	unsigned long	bts_intr_thres;
-+	unsigned long	pebs_buf_base;
-+	unsigned long	pebs_index;
-+	unsigned long	pebs_abs_max;
-+	unsigned long	pebs_intr_thres;
-+	u64     	pebs_cnt_reset;
-+};
-+
-+/*
-+ * This header is at the beginning of the sampling buffer returned to the user.
-+ *
-+ * Because of PEBS alignement constraints, the actual PEBS buffer area does
-+ * not necessarily begin right after the header. The hdr_start_offs must be
-+ * used to compute the first byte of the buffer. The offset is defined as
-+ * the number of bytes between the end of the header and the beginning of
-+ * the buffer. As such the formula is:
-+ * 	actual_buffer = (unsigned long)(hdr+1)+hdr->hdr_start_offs
-+ */
-+struct pfm_pebs_p4_smpl_hdr {
-+	u64 overflows;			/* #overflows for buffer */
-+	size_t buf_size;		/* bytes in the buffer */
-+	size_t start_offs; 		/* actual buffer start offset */
-+	u32 version;			/* smpl format version */
-+	u32 reserved1;			/* for future use */
-+	u64 reserved2[5];		/* for future use */
-+	struct pfm_ds_area_p4 ds;	/* data save area */
-+};
-+
-+/*
-+ * 64-bit PEBS record format is described in
-+ * http://www.intel.com/technology/64bitextensions/30083502.pdf
-+ *
-+ * The format does not peek at samples. The sample structure is only
-+ * used to ensure that the buffer is large enough to accomodate one
-+ * sample.
-+ */
-+#ifdef __i386__
-+struct pfm_pebs_p4_smpl_entry {
-+	u32	eflags;
-+	u32	ip;
-+	u32	eax;
-+	u32	ebx;
-+	u32	ecx;
-+	u32	edx;
-+	u32	esi;
-+	u32	edi;
-+	u32	ebp;
-+	u32	esp;
-+};
-+#else
-+struct pfm_pebs_p4_smpl_entry {
-+	u64	eflags;
-+	u64	ip;
-+	u64	eax;
-+	u64	ebx;
-+	u64	ecx;
-+	u64	edx;
-+	u64	esi;
-+	u64	edi;
-+	u64	ebp;
-+	u64	esp;
-+	u64	r8;
-+	u64	r9;
-+	u64	r10;
-+	u64	r11;
-+	u64	r12;
-+	u64	r13;
-+	u64	r14;
-+	u64	r15;
-+};
-+#endif
-+
-+#define PFM_PEBS_P4_SMPL_VERSION_MAJ 1U
-+#define PFM_PEBS_P4_SMPL_VERSION_MIN 0U
-+#define PFM_PEBS_P4_SMPL_VERSION (((PFM_PEBS_P4_SMPL_VERSION_MAJ&0xffff)<<16)|\
-+				   (PFM_PEBS_P4_SMPL_VERSION_MIN & 0xffff))
-+
-+#endif /* __PERFMON_PEBS_P4_SMPL_H__ */
-diff --git a/include/asm-x86/thread_info.h b/include/asm-x86/thread_info.h
-index da0a675..b3a6ae9 100644
---- a/include/asm-x86/thread_info.h
-+++ b/include/asm-x86/thread_info.h
-@@ -71,6 +71,7 @@ struct thread_info {
-  * Warning: layout of LSW is hardcoded in entry.S
-  */
- #define TIF_SYSCALL_TRACE	0	/* syscall trace active */
-+#define TIF_PERFMON_WORK	1	/* work for pfm_handle_work() */
- #define TIF_SIGPENDING		2	/* signal pending */
- #define TIF_NEED_RESCHED	3	/* rescheduling necessary */
- #define TIF_SINGLESTEP		4	/* reenable singlestep on user return*/
-@@ -91,6 +92,7 @@ struct thread_info {
- #define TIF_DEBUGCTLMSR		25	/* uses thread_struct.debugctlmsr */
- #define TIF_DS_AREA_MSR		26      /* uses thread_struct.ds_area_msr */
- #define TIF_BTS_TRACE_TS	27      /* record scheduling event timestamps */
-+#define TIF_PERFMON_CTXSW	28	/* perfmon needs ctxsw calls */
- 
- #define _TIF_SYSCALL_TRACE	(1 << TIF_SYSCALL_TRACE)
- #define _TIF_SIGPENDING		(1 << TIF_SIGPENDING)
-@@ -112,6 +114,8 @@ struct thread_info {
- #define _TIF_DEBUGCTLMSR	(1 << TIF_DEBUGCTLMSR)
- #define _TIF_DS_AREA_MSR	(1 << TIF_DS_AREA_MSR)
- #define _TIF_BTS_TRACE_TS	(1 << TIF_BTS_TRACE_TS)
-+#define _TIF_PERFMON_WORK	(1<<TIF_PERFMON_WORK)
-+#define _TIF_PERFMON_CTXSW	(1<<TIF_PERFMON_CTXSW)
- 
- /* work to do in syscall_trace_enter() */
- #define _TIF_WORK_SYSCALL_ENTRY	\
-@@ -133,12 +137,12 @@ struct thread_info {
- 
- /* Only used for 64 bit */
- #define _TIF_DO_NOTIFY_MASK						\
--	(_TIF_SIGPENDING|_TIF_MCE_NOTIFY)
-+	(_TIF_SIGPENDING|_TIF_MCE_NOTIFY|_TIF_PERFMON_WORK)
- 
- /* flags to check in __switch_to() */
- #define _TIF_WORK_CTXSW							\
- 	(_TIF_IO_BITMAP|_TIF_DEBUGCTLMSR|_TIF_DS_AREA_MSR|_TIF_BTS_TRACE_TS| \
--								_TIF_NOTSC)
-+	 _TIF_NOTSC|_TIF_PERFMON_CTXSW)
- 
- #define _TIF_WORK_CTXSW_PREV _TIF_WORK_CTXSW
- #define _TIF_WORK_CTXSW_NEXT (_TIF_WORK_CTXSW|_TIF_DEBUG)
-diff --git a/include/asm-x86/unistd_32.h b/include/asm-x86/unistd_32.h
-index d739467..5d8cca1 100644
---- a/include/asm-x86/unistd_32.h
-+++ b/include/asm-x86/unistd_32.h
-@@ -338,9 +338,23 @@
- #define __NR_dup3		330
- #define __NR_pipe2		331
- #define __NR_inotify_init1	332
-+#define __NR_pfm_create_context	333
-+#define __NR_pfm_write_pmcs	(__NR_pfm_create_context+1)
-+#define __NR_pfm_write_pmds	(__NR_pfm_create_context+2)
-+#define __NR_pfm_read_pmds	(__NR_pfm_create_context+3)
-+#define __NR_pfm_load_context	(__NR_pfm_create_context+4)
-+#define __NR_pfm_start		(__NR_pfm_create_context+5)
-+#define __NR_pfm_stop		(__NR_pfm_create_context+6)
-+#define __NR_pfm_restart	(__NR_pfm_create_context+7)
-+#define __NR_pfm_create_evtsets	(__NR_pfm_create_context+8)
-+#define __NR_pfm_getinfo_evtsets (__NR_pfm_create_context+9)
-+#define __NR_pfm_delete_evtsets (__NR_pfm_create_context+10)
-+#define __NR_pfm_unload_context	(__NR_pfm_create_context+11)
- 
- #ifdef __KERNEL__
- 
-+#define NR_syscalls 345
-+
- #define __ARCH_WANT_IPC_PARSE_VERSION
- #define __ARCH_WANT_OLD_READDIR
- #define __ARCH_WANT_OLD_STAT
-diff --git a/include/asm-x86/unistd_64.h b/include/asm-x86/unistd_64.h
-index 3a341d7..75dac98 100644
---- a/include/asm-x86/unistd_64.h
-+++ b/include/asm-x86/unistd_64.h
-@@ -653,7 +653,30 @@ __SYSCALL(__NR_dup3, sys_dup3)
- __SYSCALL(__NR_pipe2, sys_pipe2)
- #define __NR_inotify_init1			294
- __SYSCALL(__NR_inotify_init1, sys_inotify_init1)
--
-+#define __NR_pfm_create_context			295
-+__SYSCALL(__NR_pfm_create_context, sys_pfm_create_context)
-+#define __NR_pfm_write_pmcs			(__NR_pfm_create_context+1)
-+__SYSCALL(__NR_pfm_write_pmcs, sys_pfm_write_pmcs)
-+#define __NR_pfm_write_pmds			(__NR_pfm_create_context+2)
-+__SYSCALL(__NR_pfm_write_pmds, sys_pfm_write_pmds)
-+#define __NR_pfm_read_pmds			(__NR_pfm_create_context+3)
-+ __SYSCALL(__NR_pfm_read_pmds, sys_pfm_read_pmds)
-+#define __NR_pfm_load_context			(__NR_pfm_create_context+4)
-+__SYSCALL(__NR_pfm_load_context, sys_pfm_load_context)
-+#define __NR_pfm_start				(__NR_pfm_create_context+5)
-+__SYSCALL(__NR_pfm_start, sys_pfm_start)
-+#define __NR_pfm_stop				(__NR_pfm_create_context+6)
-+__SYSCALL(__NR_pfm_stop, sys_pfm_stop)
-+#define __NR_pfm_restart			(__NR_pfm_create_context+7)
-+__SYSCALL(__NR_pfm_restart, sys_pfm_restart)
-+#define __NR_pfm_create_evtsets			(__NR_pfm_create_context+8)
-+__SYSCALL(__NR_pfm_create_evtsets, sys_pfm_create_evtsets)
-+#define __NR_pfm_getinfo_evtsets 		(__NR_pfm_create_context+9)
-+__SYSCALL(__NR_pfm_getinfo_evtsets, sys_pfm_getinfo_evtsets)
-+#define __NR_pfm_delete_evtsets 		(__NR_pfm_create_context+10)
-+__SYSCALL(__NR_pfm_delete_evtsets, sys_pfm_delete_evtsets)
-+#define __NR_pfm_unload_context			(__NR_pfm_create_context+11)
-+__SYSCALL(__NR_pfm_unload_context, sys_pfm_unload_context)
- 
- #ifndef __NO_STUBS
- #define __ARCH_WANT_OLD_READDIR
-diff --git a/include/linux/Kbuild b/include/linux/Kbuild
-index b68ec09..d37036a 100644
---- a/include/linux/Kbuild
-+++ b/include/linux/Kbuild
-@@ -162,6 +162,8 @@ header-y += video_decoder.h
- header-y += video_encoder.h
- header-y += videotext.h
- header-y += x25.h
-+header-y += perfmon.h
-+header-y += perfmon_dfl_smpl.h
- 
- unifdef-y += acct.h
- unifdef-y += adb.h
-diff --git a/include/linux/perfmon.h b/include/linux/perfmon.h
-new file mode 100644
-index 0000000..5d9b977
---- /dev/null
-+++ b/include/linux/perfmon.h
-@@ -0,0 +1,213 @@
-+/*
-+ * Copyright (c) 2001-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+
-+#ifndef __LINUX_PERFMON_H__
-+#define __LINUX_PERFMON_H__
-+
-+/*
-+ * This file contains all the user visible generic definitions for the
-+ * interface. Model-specific user-visible definitions are located in
-+ * the asm/perfmon.h file.
-+ */
-+
-+/*
-+ * include arch-specific user interface definitions
-+ */
-+#include <asm/perfmon.h>
-+
-+/*
-+ * defined by each arch
-+ */
-+#define PFM_MAX_PMCS	PFM_ARCH_MAX_PMCS
-+#define PFM_MAX_PMDS	PFM_ARCH_MAX_PMDS
-+
-+/*
-+ * number of elements for each type of bitvector
-+ * all bitvectors use u64 fixed size type on all architectures.
-+ */
-+#define PFM_BVSIZE(x)	(((x)+(sizeof(__u64)<<3)-1) / (sizeof(__u64)<<3))
-+#define PFM_PMD_BV	PFM_BVSIZE(PFM_MAX_PMDS)
-+#define PFM_PMC_BV	PFM_BVSIZE(PFM_MAX_PMCS)
-+
-+/*
-+ * register flags layout:
-+ * bit[00-15] : generic flags
-+ * bit[16-31] : arch-specific flags
-+ *
-+ * PFM_REGFL_NO_EMUL64: must be set on the PMC controlling the PMD
-+ */
-+#define PFM_REGFL_OVFL_NOTIFY	0x1	/* PMD: send notification on event */
-+#define PFM_REGFL_RANDOM	0x2	/* PMD: randomize value after event */
-+#define PFM_REGFL_NO_EMUL64	0x4	/* PMC: no 64-bit emulation */
-+
-+/*
-+ * event set flags layout:
-+ * bits[00-15] : generic flags
-+ * bits[16-31] : arch-specific flags (see asm/perfmon.h)
-+ */
-+#define PFM_SETFL_OVFL_SWITCH	0x01 /* enable switch on overflow */
-+#define PFM_SETFL_TIME_SWITCH	0x02 /* enable switch on timeout */
-+
-+/*
-+ * argument to pfm_create_context() system call
-+ * structure shared with user level
-+ */
-+struct pfarg_ctx {
-+	__u32		ctx_flags;	  /* noblock/block/syswide */
-+	__u32		ctx_reserved1;	  /* for future use */
-+	__u64		ctx_reserved2[7]; /* for future use */
-+};
-+
-+/*
-+ * context flags layout:
-+ * bits[00-15]: generic flags
-+ * bits[16-31]: arch-specific flags (see perfmon_const.h)
-+ */
-+#define PFM_FL_NOTIFY_BLOCK    	 0x01	/* block task on user notifications */
-+#define PFM_FL_SYSTEM_WIDE	 0x02	/* create a system wide context */
-+#define PFM_FL_OVFL_NO_MSG	 0x80   /* no overflow msgs */
-+
-+/*
-+ * argument to pfm_write_pmcs() system call.
-+ * structure shared with user level
-+ */
-+struct pfarg_pmc {
-+	__u16 reg_num;		/* which register */
-+	__u16 reg_set;		/* event set for this register */
-+	__u32 reg_flags;	/* REGFL flags */
-+	__u64 reg_value;	/* pmc value */
-+	__u64 reg_reserved2[4];	/* for future use */
-+};
-+
-+/*
-+ * argument to pfm_write_pmds() and pfm_read_pmds() system calls.
-+ * structure shared with user level
-+ */
-+struct pfarg_pmd {
-+	__u16 reg_num;	   	/* which register */
-+	__u16 reg_set;	   	/* event set for this register */
-+	__u32 reg_flags; 	/* REGFL flags */
-+	__u64 reg_value;	/* initial pmc/pmd value */
-+	__u64 reg_long_reset;	/* value to reload after notification */
-+	__u64 reg_short_reset;  /* reset after counter overflow */
-+	__u64 reg_last_reset_val;	/* return: PMD last reset value */
-+	__u64 reg_ovfl_switch_cnt;	/* #overflows before switch */
-+	__u64 reg_reset_pmds[PFM_PMD_BV]; /* reset on overflow */
-+	__u64 reg_smpl_pmds[PFM_PMD_BV];  /* record in sample */
-+	__u64 reg_smpl_eventid; /* opaque event identifier */
-+	__u64 reg_random_mask; 	/* bitmask used to limit random value */
-+	__u32 reg_random_seed;  /* seed for randomization (OBSOLETE) */
-+	__u32 reg_reserved2[7];	/* for future use */
-+};
-+
-+/*
-+ * optional argument to pfm_start() system call. Pass NULL if not needed.
-+ * structure shared with user level
-+ */
-+struct pfarg_start {
-+	__u16 start_set;	/* event set to start with */
-+	__u16 start_reserved1;	/* for future use */
-+	__u32 start_reserved2;	/* for future use */
-+	__u64 reserved3[3];	/* for future use */
-+};
-+
-+/*
-+ * argument to pfm_load_context() system call.
-+ * structure shared with user level
-+ */
-+struct pfarg_load {
-+	__u32	load_pid;	   /* thread or CPU to attach to */
-+	__u16	load_set;	   /* set to load first */
-+	__u16	load_reserved1;	   /* for future use */
-+	__u64	load_reserved2[3]; /* for future use */
-+};
-+
-+/*
-+ * argument to pfm_create_evtsets() and pfm_delete_evtsets() system calls.
-+ * structure shared with user level.
-+ */
-+struct pfarg_setdesc {
-+	__u16	set_id;		  /* which set */
-+	__u16	set_reserved1;	  /* for future use */
-+	__u32	set_flags; 	  /* SETFL flags  */
-+	__u64	set_timeout;	  /* switch timeout in nsecs */
-+	__u64	reserved[6];	  /* for future use */
-+};
-+
-+/*
-+ * argument to pfm_getinfo_evtsets() system call.
-+ * structure shared with user level
-+ */
-+struct pfarg_setinfo {
-+	__u16	set_id;			/* which set */
-+	__u16	set_reserved1;		/* for future use */
-+	__u32	set_flags;		/* out: SETFL flags */
-+	__u64 	set_ovfl_pmds[PFM_PMD_BV]; /* out: last ovfl PMDs */
-+	__u64	set_runs;		/* out: #times the set was active */
-+	__u64	set_timeout;		/* out: eff/leftover timeout (nsecs) */
-+	__u64	set_act_duration;	/* out: time set was active in nsecs */
-+	__u64	set_avail_pmcs[PFM_PMC_BV];/* out: available PMCs */
-+	__u64	set_avail_pmds[PFM_PMD_BV];/* out: available PMDs */
-+	__u64	set_reserved3[6];	/* for future use */
-+};
-+
-+/*
-+ * default value for the user and group security parameters in
-+ * /proc/sys/kernel/perfmon/sys_group
-+ * /proc/sys/kernel/perfmon/task_group
-+ */
-+#define PFM_GROUP_PERM_ANY	-1	/* any user/group */
-+
-+/*
-+ * overflow notification message.
-+ * structure shared with user level
-+ */
-+struct pfarg_ovfl_msg {
-+	__u32 		msg_type;	/* message type: PFM_MSG_OVFL */
-+	__u32		msg_ovfl_pid;	/* process id */
-+	__u16 		msg_active_set;	/* active set at overflow */
-+	__u16 		msg_ovfl_cpu;	/* cpu of PMU interrupt */
-+	__u32		msg_ovfl_tid;	/* thread id */
-+	__u64		msg_ovfl_ip;    /* IP on PMU intr */
-+	__u64		msg_ovfl_pmds[PFM_PMD_BV];/* overflowed PMDs */
-+};
-+
-+#define PFM_MSG_OVFL	1	/* an overflow happened */
-+#define PFM_MSG_END	2	/* task to which context was attached ended */
-+
-+/*
-+ * generic notification message (union).
-+ * union shared with user level
-+ */
-+union pfarg_msg {
-+	__u32	type;
-+	struct pfarg_ovfl_msg pfm_ovfl_msg;
-+};
-+
-+/*
-+ * perfmon version number
-+ */
-+#define PFM_VERSION_MAJ		 2U
-+#define PFM_VERSION_MIN		 82U
-+#define PFM_VERSION		 (((PFM_VERSION_MAJ&0xffff)<<16)|\
-+				  (PFM_VERSION_MIN & 0xffff))
-+#define PFM_VERSION_MAJOR(x)	 (((x)>>16) & 0xffff)
-+#define PFM_VERSION_MINOR(x)	 ((x) & 0xffff)
-+
-+#endif /* __LINUX_PERFMON_H__ */
-diff --git a/include/linux/perfmon_dfl_smpl.h b/include/linux/perfmon_dfl_smpl.h
-new file mode 100644
-index 0000000..e0817a8
---- /dev/null
-+++ b/include/linux/perfmon_dfl_smpl.h
-@@ -0,0 +1,78 @@
-+/*
-+ * Copyright (c) 2005-2006 Hewlett-Packard Development Company, L.P.
-+ *               Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This file implements the new dfl sampling buffer format
-+ * for perfmon2 subsystem.
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#ifndef __PERFMON_DFL_SMPL_H__
-+#define __PERFMON_DFL_SMPL_H__ 1
-+
-+/*
-+ * format specific parameters (passed at context creation)
-+ */
-+struct pfm_dfl_smpl_arg {
-+	__u64 buf_size;		/* size of the buffer in bytes */
-+	__u32 buf_flags;	/* buffer specific flags */
-+	__u32 reserved1;	/* for future use */
-+	__u64 reserved[6];	/* for future use */
-+};
-+
-+/*
-+ * This header is at the beginning of the sampling buffer returned to the user.
-+ * It is directly followed by the first record.
-+ */
-+struct pfm_dfl_smpl_hdr {
-+	__u64 hdr_count;	/* how many valid entries */
-+	__u64 hdr_cur_offs;	/* current offset from top of buffer */
-+	__u64 hdr_overflows;	/* #overflows for buffer */
-+	__u64 hdr_buf_size;	/* bytes in the buffer */
-+	__u64 hdr_min_buf_space;/* minimal buffer size (internal use) */
-+	__u32 hdr_version;	/* smpl format version */
-+	__u32 hdr_buf_flags;	/* copy of buf_flags */
-+	__u64 hdr_reserved[10];	/* for future use */
-+};
-+
-+/*
-+ * Entry header in the sampling buffer.  The header is directly followed
-+ * with the values of the PMD registers of interest saved in increasing
-+ * index order: PMD4, PMD5, and so on. How many PMDs are present depends
-+ * on how the session was programmed.
-+ *
-+ * In the case where multiple counters overflow at the same time, multiple
-+ * entries are written consecutively.
-+ *
-+ * last_reset_value member indicates the initial value of the overflowed PMD.
-+ */
-+struct pfm_dfl_smpl_entry {
-+	__u32	pid;		/* thread id (for NPTL, this is gettid()) */
-+	__u16	ovfl_pmd;	/* index of overflowed PMD for this sample */
-+	__u16	reserved;	/* for future use */
-+	__u64	last_reset_val;	/* initial value of overflowed PMD */
-+	__u64	ip;		/* where did the overflow intr happened */
-+	__u64	tstamp;		/* overflow timetamp */
-+	__u16	cpu;		/* cpu on which the overfow occurred */
-+	__u16	set;		/* event set active when overflow ocurred */
-+	__u32	tgid;		/* thread group id (getpid() for NPTL) */
-+};
-+
-+#define PFM_DFL_SMPL_VERSION_MAJ 1U
-+#define PFM_DFL_SMPL_VERSION_MIN 0U
-+#define PFM_DFL_SMPL_VERSION (((PFM_DFL_SMPL_VERSION_MAJ&0xffff)<<16)|\
-+				(PFM_DFL_SMPL_VERSION_MIN & 0xffff))
-+
-+#endif /* __PERFMON_DFL_SMPL_H__ */
-diff --git a/include/linux/perfmon_fmt.h b/include/linux/perfmon_fmt.h
-new file mode 100644
-index 0000000..82a6a90
---- /dev/null
-+++ b/include/linux/perfmon_fmt.h
-@@ -0,0 +1,74 @@
-+/*
-+ * Copyright (c) 2001-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * Interface for custom sampling buffer format modules
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#ifndef __PERFMON_FMT_H__
-+#define __PERFMON_FMT_H__ 1
-+
-+#include <linux/kobject.h>
-+
-+typedef int (*fmt_validate_t)(u32 flags, u16 npmds, void *arg);
-+typedef	int (*fmt_getsize_t)(u32 flags, void *arg, size_t *size);
-+typedef int (*fmt_init_t)(struct pfm_context *ctx, void *buf, u32 flags,
-+			  u16 nmpds, void *arg);
-+typedef int (*fmt_restart_t)(int is_active, u32 *ovfl_ctrl, void *buf);
-+typedef int (*fmt_exit_t)(void *buf);
-+typedef int (*fmt_handler_t)(struct pfm_context *ctx,
-+			     unsigned long ip, u64 stamp, void *data);
-+
-+struct pfm_smpl_fmt {
-+	char		*fmt_name;	/* name of the format (required) */
-+	size_t		fmt_arg_size;	/* size of fmt args for ctx create */
-+	u32		fmt_flags;	/* format specific flags */
-+	u32		fmt_version;	/* format version number */
-+
-+	fmt_validate_t	fmt_validate;	/* validate context flags */
-+	fmt_getsize_t	fmt_getsize;	/* get size for sampling buffer */
-+	fmt_init_t	fmt_init;	/* initialize buffer area */
-+	fmt_handler_t	fmt_handler;	/* overflow handler (required) */
-+	fmt_restart_t	fmt_restart;	/* restart after notification  */
-+	fmt_exit_t	fmt_exit;	/* context termination */
-+
-+	struct list_head fmt_list;	/* internal use only */
-+
-+	struct kobject	kobj;		/* sysfs internal use only */
-+	struct module	*owner;		/* pointer to module owner */
-+	u32		fmt_qdepth;	/* Max notify queue depth (required) */
-+};
-+#define to_smpl_fmt(n) container_of(n, struct pfm_smpl_fmt, kobj)
-+
-+#define PFM_FMTFL_IS_BUILTIN	0x1	/* fmt is compiled in */
-+/*
-+ * we need to know whether the format is builtin or compiled
-+ * as a module
-+ */
-+#ifdef MODULE
-+#define PFM_FMT_BUILTIN_FLAG	0	/* not built as a module */
-+#else
-+#define PFM_FMT_BUILTIN_FLAG	PFM_PMUFL_IS_BUILTIN /* built as a module */
-+#endif
-+
-+int pfm_fmt_register(struct pfm_smpl_fmt *fmt);
-+int pfm_fmt_unregister(struct pfm_smpl_fmt *fmt);
-+void pfm_sysfs_builtin_fmt_add(void);
-+
-+int  pfm_sysfs_add_fmt(struct pfm_smpl_fmt *fmt);
-+void pfm_sysfs_remove_fmt(struct pfm_smpl_fmt *fmt);
-+
-+#endif /* __PERFMON_FMT_H__ */
-diff --git a/include/linux/perfmon_kern.h b/include/linux/perfmon_kern.h
-new file mode 100644
-index 0000000..6c3b527
---- /dev/null
-+++ b/include/linux/perfmon_kern.h
-@@ -0,0 +1,551 @@
-+/*
-+ * Copyright (c) 2001-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+
-+#ifndef __LINUX_PERFMON_KERN_H__
-+#define __LINUX_PERFMON_KERN_H__
-+/*
-+ * This file contains all the definitions of data structures, variables, macros
-+ * that are to be shared between generic code and arch-specific code
-+ *
-+ * For generic only definitions, use perfmon/perfmon_priv.h
-+ */
-+#ifdef CONFIG_PERFMON
-+
-+#include <linux/file.h>
-+#include <linux/sched.h>
-+#include <linux/perfmon.h>
-+
-+/*
-+ * system adminstrator configuration controls available via
-+ * the /sys/kerne/perfmon interface
-+ */
-+struct pfm_controls {
-+	u32	debug;		/* debugging control bitmask */
-+	gid_t	sys_group;	/* gid to create a syswide context */
-+	gid_t	task_group;	/* gid to create a per-task context */
-+	u32	flags;		/* control flags (see below) */
-+	size_t	arg_mem_max;	/* maximum vector argument size */
-+	size_t	smpl_buffer_mem_max; /* max buf mem, -1 for infinity */
-+};
-+extern struct pfm_controls pfm_controls;
-+
-+/*
-+ * control flags
-+ */
-+#define PFM_CTRL_FL_RW_EXPERT	0x1 /* bypass reserved fields on read/write */
-+
-+/*
-+ * software PMD
-+ */
-+struct pfm_pmd {
-+	u64 value;			/* 64-bit value */
-+	u64 lval;			/* last reset value */
-+	u64 ovflsw_thres;		/* #ovfls left before switch */
-+	u64 long_reset;			/* long reset value on overflow */
-+	u64 short_reset;		/* short reset value on overflow */
-+	u64 reset_pmds[PFM_PMD_BV];	/* pmds to reset on overflow */
-+	u64 smpl_pmds[PFM_PMD_BV];	/* pmds to record on overflow */
-+	u64 mask;			/* range mask for random value */
-+	u64 ovflsw_ref_thres;		/* #ovfls before next set */
-+	u64 eventid;			/* opaque event identifier */
-+	u32 flags;			/* notify/do not notify */
-+};
-+
-+/*
-+ * event_set: encapsulates the full PMU state
-+ */
-+struct pfm_event_set {
-+	struct list_head list;		/* ordered chain of sets */
-+	u16 id;				/* set identification */
-+	u16 nused_pmds;			/* max number of used PMDs */
-+	u16 nused_pmcs;			/* max number of used PMCs */
-+	u16 pad1;			/* paddding */
-+	u32 flags;			/* public flags */
-+	u32 priv_flags;			/* private flags (see below) */
-+	u64 runs;			/* # of activations */
-+	u32 npend_ovfls;		/* number of pending PMD overflow */
-+	u32 pad2;			/* padding */
-+	u64 used_pmds[PFM_PMD_BV];	/* used PMDs */
-+	u64 povfl_pmds[PFM_PMD_BV];	/* pending overflowed PMDs */
-+	u64 ovfl_pmds[PFM_PMD_BV];	/* last overflowed PMDs */
-+	u64 reset_pmds[PFM_PMD_BV];	/* PMDs to reset after overflow */
-+	u64 ovfl_notify[PFM_PMD_BV];	/* notify on overflow */
-+	u64 used_pmcs[PFM_PMC_BV];	/* used PMCs */
-+	u64 pmcs[PFM_MAX_PMCS];		/* PMC values */
-+
-+	struct pfm_pmd pmds[PFM_MAX_PMDS];
-+
-+	ktime_t hrtimer_exp;		/* switch timeout reference */
-+	ktime_t hrtimer_rem;		/* per-thread remainder timeout */
-+
-+	u64 duration_start;		/* start time in ns */
-+	u64 duration;			/* total active ns */
-+};
-+
-+/*
-+ * common private event set flags (priv_flags)
-+ *
-+ * upper 16 bits: for arch-specific use
-+ * lower 16 bits: for common use
-+ */
-+#define PFM_SETFL_PRIV_MOD_PMDS 0x1 /* PMD register(s) modified */
-+#define PFM_SETFL_PRIV_MOD_PMCS 0x2 /* PMC register(s) modified */
-+#define PFM_SETFL_PRIV_SWITCH	0x4 /* must switch set on restart */
-+#define PFM_SETFL_PRIV_MOD_BOTH	(PFM_SETFL_PRIV_MOD_PMDS \
-+				| PFM_SETFL_PRIV_MOD_PMCS)
-+
-+/*
-+ * context flags
-+ */
-+struct pfm_context_flags {
-+	unsigned int block:1;		/* task blocks on user notifications */
-+	unsigned int system:1;		/* do system wide monitoring */
-+	unsigned int no_msg:1;		/* no message sent on overflow */
-+	unsigned int switch_ovfl:1;	/* switch set on counter ovfl */
-+	unsigned int switch_time:1;	/* switch set on timeout */
-+	unsigned int started:1;		/* pfm_start() issued */
-+	unsigned int work_type:2;	/* type of work for pfm_handle_work */
-+	unsigned int mmap_nlock:1;	/* no lock in pfm_release_buf_space */
-+	unsigned int ia64_v20_compat:1;	/* context is IA-64 v2.0 mode */
-+	unsigned int can_restart:8;	/* allowed to issue a PFM_RESTART */
-+	unsigned int reset_count:8;	/* number of pending resets */
-+	unsigned int is_self:1;		/* per-thread and self-montoring */
-+	unsigned int reserved:5;	/* for future use */
-+};
-+
-+/*
-+ * values for work_type (TIF_PERFMON_WORK must be set)
-+ */
-+#define PFM_WORK_NONE	0	/* nothing to do */
-+#define PFM_WORK_RESET	1	/* reset overflowed counters */
-+#define PFM_WORK_BLOCK	2	/* block current thread */
-+#define PFM_WORK_ZOMBIE	3	/* cleanup zombie context */
-+
-+/*
-+ * overflow description argument passed to sampling format
-+ */
-+struct pfm_ovfl_arg {
-+	u16 ovfl_pmd;		/* index of overflowed PMD  */
-+	u16 active_set;		/* set active at the time of the overflow */
-+	u32 ovfl_ctrl;		/* control flags */
-+	u64 pmd_last_reset;	/* last reset value of overflowed PMD */
-+	u64 smpl_pmds_values[PFM_MAX_PMDS]; /* values of other PMDs */
-+	u64 pmd_eventid;	/* eventid associated with PMD */
-+	u16 num_smpl_pmds;	/* number of PMDS in smpl_pmd_values */
-+};
-+/*
-+ * depth of message queue
-+ *
-+ * Depth cannot be bigger than 255 (see reset_count)
-+ */
-+#define PFM_MSGS_ORDER		3 /* log2(number of messages) */
-+#define PFM_MSGS_COUNT		(1<<PFM_MSGS_ORDER) /* number of messages */
-+#define PFM_MSGQ_MASK		(PFM_MSGS_COUNT-1)
-+
-+/*
-+ * perfmon context state
-+ */
-+#define PFM_CTX_UNLOADED	1 /* context is not loaded onto any task */
-+#define PFM_CTX_LOADED		2 /* context is loaded onto a task */
-+#define PFM_CTX_MASKED		3 /* context is loaded, monitoring is masked */
-+#define PFM_CTX_ZOMBIE		4 /* context lost owner but still attached */
-+
-+/*
-+ * registers description
-+ */
-+struct pfm_regdesc {
-+	u64 pmcs[PFM_PMC_BV];		/* available PMC */
-+	u64 pmds[PFM_PMD_BV];		/* available PMD */
-+	u64 rw_pmds[PFM_PMD_BV];	/* available RW PMD */
-+	u64 intr_pmds[PFM_PMD_BV];	/* PMD generating intr */
-+	u64 cnt_pmds[PFM_PMD_BV];	/* PMD counters */
-+	u16 max_pmc;			/* highest+1 avail PMC */
-+	u16 max_pmd;			/* highest+1 avail PMD */
-+	u16 max_rw_pmd;			/* highest+1 avail RW PMD */
-+	u16 first_intr_pmd;		/* first intr PMD */
-+	u16 max_intr_pmd;		/* highest+1 intr PMD */
-+	u16 num_rw_pmd;			/* number of avail RW PMD */
-+	u16 num_pmcs;			/* number of logical PMCS */
-+	u16 num_pmds;			/* number of logical PMDS */
-+	u16 num_counters;		/* number of counting PMD */
-+};
-+
-+/*
-+ * context: contains all the state of a session
-+ */
-+struct pfm_context {
-+	spinlock_t		lock;		/* context protection */
-+
-+	struct pfm_context_flags flags;
-+	u32			state;		/* current state */
-+	struct task_struct 	*task;		/* attached task */
-+
-+	struct completion       restart_complete;/* block on notification */
-+	u64 			last_act;	/* last activation */
-+	u32			last_cpu;   	/* last CPU used (SMP only) */
-+	u32			cpu;		/* cpu bound to context */
-+
-+	struct pfm_smpl_fmt	*smpl_fmt;	/* sampling format callbacks */
-+	void			*smpl_addr;	/* user smpl buffer base */
-+	size_t			smpl_size;	/* user smpl buffer size */
-+	void			*smpl_real_addr;/* actual smpl buffer base */
-+	size_t			smpl_real_size; /* actual smpl buffer size */
-+
-+	wait_queue_head_t 	msgq_wait;	/* pfm_read() wait queue */
-+
-+	union pfarg_msg		msgq[PFM_MSGS_COUNT];
-+	int			msgq_head;
-+	int			msgq_tail;
-+
-+	struct fasync_struct	*async_queue;	/* async notification */
-+
-+	struct pfm_event_set	*active_set;	/* active set */
-+	struct list_head	set_list;	/* ordered list of sets */
-+
-+	struct pfm_regdesc	regs;		/* registers available to context */
-+
-+	/*
-+	 * save stack space by allocating temporary variables for
-+	 * pfm_overflow_handler() in pfm_context
-+	 */
-+	struct pfm_ovfl_arg 	ovfl_arg;
-+	u64			tmp_ovfl_notify[PFM_PMD_BV];
-+};
-+
-+/*
-+ * ovfl_ctrl bitmask (used by interrupt handler)
-+ */
-+#define PFM_OVFL_CTRL_NOTIFY	0x1	/* notify user */
-+#define PFM_OVFL_CTRL_RESET	0x2	/* reset overflowed pmds */
-+#define PFM_OVFL_CTRL_MASK	0x4	/* mask monitoring */
-+#define PFM_OVFL_CTRL_SWITCH	0x8	/* switch sets */
-+
-+/*
-+ * logging
-+ */
-+#define PFM_ERR(f, x...)  printk(KERN_ERR     "perfmon: " f "\n", ## x)
-+#define PFM_WARN(f, x...) printk(KERN_WARNING "perfmon: " f "\n", ## x)
-+#define PFM_LOG(f, x...)  printk(KERN_NOTICE  "perfmon: " f "\n", ## x)
-+#define PFM_INFO(f, x...) printk(KERN_INFO    "perfmon: " f "\n", ## x)
-+
-+/*
-+ * debugging
-+ *
-+ * Printk rate limiting is enforced to avoid getting flooded with too many
-+ * error messages on the console (which could render the machine unresponsive).
-+ * To get full debug output (turn off ratelimit):
-+ * 	$ echo 0 >/proc/sys/kernel/printk_ratelimit
-+ *
-+ * debug is a bitmask where bits are defined as follows:
-+ * bit  0: enable non-interrupt code degbug messages
-+ * bit  1: enable interrupt code debug messages
-+ */
-+#ifdef CONFIG_PERFMON_DEBUG
-+#define _PFM_DBG(lm, f, x...) \
-+	do { \
-+		if (unlikely((pfm_controls.debug & lm) && printk_ratelimit())) { \
-+			preempt_disable(); \
-+			printk("perfmon: %s.%d: CPU%d [%d]: " f "\n", \
-+			       __func__, __LINE__, \
-+			       smp_processor_id(), current->pid , ## x); \
-+			preempt_enable(); \
-+		} \
-+	} while (0)
-+
-+#define PFM_DBG(f, x...) _PFM_DBG(0x1, f, ##x)
-+#define PFM_DBG_ovfl(f, x...) _PFM_DBG(0x2, f, ## x)
-+#else
-+#define PFM_DBG(f, x...)	do {} while (0)
-+#define PFM_DBG_ovfl(f, x...)	do {} while (0)
-+#endif
-+
-+extern struct pfm_pmu_config  *pfm_pmu_conf;
-+extern int perfmon_disabled;
-+
-+static inline struct pfm_arch_context *pfm_ctx_arch(struct pfm_context *c)
-+{
-+	return (struct pfm_arch_context *)(c+1);
-+}
-+
-+int  pfm_get_args(void __user *ureq, size_t sz, size_t lsz, void *laddr,
-+		  void **req, void **to_free);
-+
-+int pfm_get_smpl_arg(char __user *fmt_uname, void __user *uaddr, size_t usize,
-+		     void **arg, struct pfm_smpl_fmt **fmt);
-+
-+int __pfm_write_pmcs(struct pfm_context *ctx, struct pfarg_pmc *req,
-+		     int count);
-+int __pfm_write_pmds(struct pfm_context *ctx, struct pfarg_pmd *req, int count,
-+		     int compat);
-+int __pfm_read_pmds(struct pfm_context *ctx, struct pfarg_pmd *req, int count);
-+
-+int __pfm_load_context(struct pfm_context *ctx, struct pfarg_load *req,
-+		       struct task_struct *task);
-+int __pfm_unload_context(struct pfm_context *ctx, int *can_release);
-+
-+int __pfm_stop(struct pfm_context *ctx, int *release_info);
-+int  __pfm_restart(struct pfm_context *ctx, int *unblock);
-+int __pfm_start(struct pfm_context *ctx, struct pfarg_start *start);
-+
-+void pfm_free_context(struct pfm_context *ctx);
-+
-+void pfm_smpl_buf_space_release(struct pfm_context *ctx, size_t size);
-+
-+int pfm_check_task_state(struct pfm_context *ctx, int check_mask,
-+			 unsigned long *flags, void **resume);
-+/*
-+ * check_mask bitmask values for pfm_check_task_state()
-+ */
-+#define PFM_CMD_STOPPED		0x01	/* command needs thread stopped */
-+#define PFM_CMD_UNLOADED	0x02	/* command needs ctx unloaded */
-+#define PFM_CMD_UNLOAD		0x04	/* command is unload */
-+
-+int __pfm_create_context(struct pfarg_ctx *req,
-+			 struct pfm_smpl_fmt *fmt,
-+			 void *fmt_arg,
-+			 int mode,
-+			 struct pfm_context **new_ctx);
-+
-+struct pfm_event_set *pfm_find_set(struct pfm_context *ctx, u16 set_id,
-+				   int alloc);
-+
-+int pfm_pmu_conf_get(int autoload);
-+void pfm_pmu_conf_put(void);
-+
-+int pfm_session_allcpus_acquire(void);
-+void pfm_session_allcpus_release(void);
-+
-+int pfm_smpl_buf_alloc(struct pfm_context *ctx, size_t rsize);
-+void pfm_smpl_buf_free(struct pfm_context *ctx);
-+
-+struct pfm_smpl_fmt *pfm_smpl_fmt_get(char *name);
-+void pfm_smpl_fmt_put(struct pfm_smpl_fmt *fmt);
-+
-+void pfm_interrupt_handler(unsigned long iip, struct pt_regs *regs);
-+
-+void pfm_resume_task(struct task_struct *t, void *data);
-+
-+#include <linux/perfmon_pmu.h>
-+#include <linux/perfmon_fmt.h>
-+
-+extern const struct file_operations pfm_file_ops;
-+/*
-+ * upper limit for count in calls that take vector arguments. This is used
-+ * to prevent for multiplication overflow when we compute actual storage size
-+ */
-+#define PFM_MAX_ARG_COUNT(m) (INT_MAX/sizeof(*(m)))
-+
-+#define cast_ulp(_x) ((unsigned long *)_x)
-+
-+#define PFM_NORMAL      0
-+#define PFM_COMPAT      1
-+
-+void __pfm_exit_thread(void);
-+void pfm_ctxsw_in(struct task_struct *prev, struct task_struct *next);
-+void pfm_ctxsw_out(struct task_struct *prev, struct task_struct *next);
-+void pfm_handle_work(struct pt_regs *regs);
-+void __pfm_init_percpu(void *dummy);
-+void pfm_save_pmds(struct pfm_context *ctx, struct pfm_event_set *set);
-+
-+static inline void pfm_exit_thread(void)
-+{
-+	if (current->pfm_context)
-+		__pfm_exit_thread();
-+}
-+
-+/*
-+ * include arch-specific kernel level definitions
-+ */
-+#include <asm/perfmon_kern.h>
-+
-+static inline void pfm_copy_thread(struct task_struct *task)
-+{
-+	/*
-+	 * context or perfmon TIF state  is NEVER inherited
-+	 * in child task. Holds for per-thread and system-wide
-+	 */
-+	task->pfm_context = NULL;
-+	clear_tsk_thread_flag(task, TIF_PERFMON_CTXSW);
-+	clear_tsk_thread_flag(task, TIF_PERFMON_WORK);
-+	pfm_arch_disarm_handle_work(task);
-+}
-+
-+
-+/*
-+ * read a single PMD register.
-+ *
-+ * virtual PMD registers have special handler.
-+ * Depends on definitions in asm/perfmon_kern.h
-+ */
-+static inline u64 pfm_read_pmd(struct pfm_context *ctx, unsigned int cnum)
-+{
-+	if (unlikely(pfm_pmu_conf->pmd_desc[cnum].type & PFM_REG_V))
-+		return pfm_pmu_conf->pmd_sread(ctx, cnum);
-+
-+	return pfm_arch_read_pmd(ctx, cnum);
-+}
-+/*
-+ * write a single PMD register.
-+ *
-+ * virtual PMD registers have special handler.
-+ * Depends on definitions in asm/perfmon_kern.h
-+ */
-+static inline void pfm_write_pmd(struct pfm_context *ctx, unsigned int cnum,
-+				 u64 value)
-+{
-+	/*
-+	 * PMD writes are ignored for read-only registers
-+	 */
-+	if (pfm_pmu_conf->pmd_desc[cnum].type & PFM_REG_RO)
-+		return;
-+
-+	if (pfm_pmu_conf->pmd_desc[cnum].type & PFM_REG_V) {
-+		pfm_pmu_conf->pmd_swrite(ctx, cnum, value);
-+		return;
-+	}
-+	/*
-+	 * clear unimplemented bits
-+	 */
-+	value &= ~pfm_pmu_conf->pmd_desc[cnum].rsvd_msk;
-+
-+	pfm_arch_write_pmd(ctx, cnum, value);
-+}
-+
-+void __pfm_init_percpu(void *dummy);
-+
-+static inline void pfm_init_percpu(void)
-+{
-+	__pfm_init_percpu(NULL);
-+}
-+
-+/*
-+ * pfm statistics are available via debugfs
-+ * and perfmon subdir.
-+ *
-+ * When adding/removing new stats, make sure you also
-+ * update the name table in perfmon_debugfs.c
-+ */
-+enum pfm_stats_names {
-+	PFM_ST_ovfl_intr_all_count = 0,
-+	PFM_ST_ovfl_intr_ns,
-+	PFM_ST_ovfl_intr_spurious_count,
-+	PFM_ST_ovfl_intr_replay_count,
-+	PFM_ST_ovfl_intr_regular_count,
-+	PFM_ST_handle_work_count,
-+	PFM_ST_ovfl_notify_count,
-+	PFM_ST_reset_pmds_count,
-+	PFM_ST_pfm_restart_count,
-+	PFM_ST_fmt_handler_calls,
-+	PFM_ST_fmt_handler_ns,
-+	PFM_ST_set_switch_count,
-+	PFM_ST_set_switch_ns,
-+	PFM_ST_set_switch_exp,
-+	PFM_ST_ctxswin_count,
-+	PFM_ST_ctxswin_ns,
-+	PFM_ST_handle_timeout_count,
-+	PFM_ST_ovfl_intr_nmi_count,
-+	PFM_ST_ctxswout_count,
-+	PFM_ST_ctxswout_ns,
-+	PFM_ST_LAST	/* last entry marked */
-+};
-+#define PFM_NUM_STATS PFM_ST_LAST
-+
-+struct pfm_stats {
-+	u64 v[PFM_NUM_STATS];
-+	struct dentry *dirs[PFM_NUM_STATS];
-+	struct dentry *cpu_dir;
-+	char cpu_name[8];
-+};
-+
-+#ifdef CONFIG_PERFMON_DEBUG_FS
-+#define pfm_stats_get(x)  __get_cpu_var(pfm_stats).v[PFM_ST_##x]
-+#define pfm_stats_inc(x)  __get_cpu_var(pfm_stats).v[PFM_ST_##x]++
-+#define pfm_stats_add(x, y)  __get_cpu_var(pfm_stats).v[PFM_ST_##x] += (y)
-+void pfm_reset_stats(int cpu);
-+#else
-+#define pfm_stats_get(x)
-+#define pfm_stats_inc(x)
-+#define pfm_stats_add(x, y)
-+static inline void pfm_reset_stats(int cpu)
-+{}
-+#endif
-+
-+
-+
-+DECLARE_PER_CPU(struct pfm_context *, pmu_ctx);
-+DECLARE_PER_CPU(struct pfm_stats, pfm_stats);
-+DECLARE_PER_CPU(struct task_struct *, pmu_owner);
-+
-+void pfm_cpu_disable(void);
-+
-+
-+/*
-+ * max vector argument elements for local storage (no kmalloc/kfree)
-+ * The PFM_ARCH_PM*_ARG should be defined in perfmon_kern.h.
-+ * If not, default (conservative) values are used
-+ */
-+#ifndef PFM_ARCH_PMC_STK_ARG
-+#define PFM_ARCH_PMC_STK_ARG	1
-+#endif
-+
-+#ifndef PFM_ARCH_PMD_STK_ARG
-+#define PFM_ARCH_PMD_STK_ARG	1
-+#endif
-+
-+#define PFM_PMC_STK_ARG	PFM_ARCH_PMC_STK_ARG
-+#define PFM_PMD_STK_ARG	PFM_ARCH_PMD_STK_ARG
-+
-+#else /* !CONFIG_PERFMON */
-+
-+
-+/*
-+ * perfmon hooks are nops when CONFIG_PERFMON is undefined
-+ */
-+static inline void pfm_cpu_disable(void)
-+{}
-+
-+static inline void pfm_exit_thread(void)
-+{}
-+
-+static inline void pfm_handle_work(struct pt_regs *regs)
-+{}
-+
-+static inline void pfm_copy_thread(struct task_struct *t)
-+{}
-+
-+static inline void pfm_ctxsw_in(struct task_struct *p, struct task_struct *n)
-+{}
-+
-+static inline void pfm_ctxsw_out(struct task_struct *p, struct task_struct *n)
-+{}
-+
-+static inline void pfm_session_allcpus_release(void)
-+{}
-+
-+static inline int pfm_session_allcpus_acquire(void)
-+{
-+	return 0;
-+}
-+
-+static inline void pfm_init_percpu(void)
-+{}
-+
-+#endif /* CONFIG_PERFMON */
-+
-+#endif /* __LINUX_PERFMON_KERN_H__ */
-diff --git a/include/linux/perfmon_pmu.h b/include/linux/perfmon_pmu.h
-new file mode 100644
-index 0000000..3f5f9e8
---- /dev/null
-+++ b/include/linux/perfmon_pmu.h
-@@ -0,0 +1,192 @@
-+/*
-+ * Copyright (c) 2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * Interface for PMU description modules
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#ifndef __PERFMON_PMU_H__
-+#define __PERFMON_PMU_H__ 1
-+
-+/*
-+ * generic information about a PMC or PMD register
-+ *
-+ * Dependency bitmasks:
-+ *  They are used to allow lazy save/restore in the context switch
-+ *  code. To avoid picking up stale configuration from a previous
-+ *  thread. Usng the bitmask, the generic read/write routines can
-+ *  ensure that all registers needed to support the measurement are
-+ *  restored properly on context switch in.
-+ */
-+struct pfm_regmap_desc {
-+	u16  type;		/* role of the register */
-+	u16  reserved1;		/* for future use */
-+	u32  reserved2;		/* for future use */
-+	u64  dfl_val;		/* power-on default value (quiescent) */
-+	u64  rsvd_msk;		/* reserved bits: 1 means reserved */
-+	u64  no_emul64_msk;	/* bits to clear for PFM_REGFL_NO_EMUL64 */
-+	unsigned long hw_addr;	/* HW register address or index */
-+	struct kobject	kobj;	/* for internal use only */
-+	char *desc;		/* HW register description string */
-+	u64 dep_pmcs[PFM_PMC_BV];/* depending PMC registers */
-+};
-+#define to_reg(n) container_of(n, struct pfm_regmap_desc, kobj)
-+
-+/*
-+ * pfm_reg_desc helper macros
-+ */
-+#define PMC_D(t, d, v, r, n, h) \
-+	{ .type = t,          \
-+	  .desc = d,          \
-+	  .dfl_val = v,       \
-+	  .rsvd_msk = r,      \
-+	  .no_emul64_msk = n, \
-+	  .hw_addr = h	      \
-+	}
-+
-+#define PMD_D(t, d, h)        \
-+	{ .type = t,          \
-+	  .desc = d,          \
-+	  .rsvd_msk = 0,      \
-+	  .no_emul64_msk = 0, \
-+	  .hw_addr = h	      \
-+	}
-+
-+#define PMD_DR(t, d, h, r)    \
-+	{ .type = t,          \
-+	  .desc = d,          \
-+	  .rsvd_msk = r,      \
-+	  .no_emul64_msk = 0, \
-+	  .hw_addr = h	      \
-+	}
-+
-+#define PMX_NA \
-+	{ .type = PFM_REG_NA }
-+
-+#define PMD_DP(t, d, h, p)    \
-+	{ .type = t,          \
-+	  .desc = d,          \
-+	  .rsvd_msk = 0,      \
-+	  .no_emul64_msk = 0, \
-+	  .dep_pmcs[0] = p,   \
-+	  .hw_addr = h	      \
-+	}
-+
-+/*
-+ * type of a PMU register (16-bit bitmask) for use with pfm_reg_desc.type
-+ */
-+#define PFM_REG_NA	0x00  /* not avail. (not impl.,no access) must be 0 */
-+#define PFM_REG_I	0x01  /* PMC/PMD: implemented */
-+#define PFM_REG_WC	0x02  /* PMC: has write_checker */
-+#define PFM_REG_C64	0x04  /* PMD: 64-bit virtualization */
-+#define PFM_REG_RO	0x08  /* PMD: read-only (writes ignored) */
-+#define PFM_REG_V	0x10  /* PMD: virtual reg */
-+#define PFM_REG_INTR	0x20  /* PMD: register can generate interrupt */
-+#define PFM_REG_SYS	0x40  /* PMC/PMD: register is for system-wide only */
-+#define PFM_REG_THR	0x80  /* PMC/PMD: register is for per-thread only */
-+#define PFM_REG_NO64	0x100 /* PMC: supports PFM_REGFL_NO_EMUL64 */
-+
-+/*
-+ * define some shortcuts for common types
-+ */
-+#define PFM_REG_W	(PFM_REG_WC|PFM_REG_I)
-+#define PFM_REG_W64	(PFM_REG_WC|PFM_REG_NO64|PFM_REG_I)
-+#define PFM_REG_C	(PFM_REG_C64|PFM_REG_INTR|PFM_REG_I)
-+#define PFM_REG_I64	(PFM_REG_NO64|PFM_REG_I)
-+#define PFM_REG_IRO	(PFM_REG_I|PFM_REG_RO)
-+
-+typedef int (*pfm_pmc_check_t)(struct pfm_context *ctx,
-+			       struct pfm_event_set *set,
-+			       struct pfarg_pmc *req);
-+
-+typedef int (*pfm_pmd_check_t)(struct pfm_context *ctx,
-+			       struct pfm_event_set *set,
-+			       struct pfarg_pmd *req);
-+
-+
-+typedef u64 (*pfm_sread_t)(struct pfm_context *ctx, unsigned int cnum);
-+typedef void (*pfm_swrite_t)(struct pfm_context *ctx, unsigned int cnum, u64 val);
-+
-+/*
-+ * structure used by pmu description modules
-+ *
-+ * probe_pmu() routine return value:
-+ * 	- 1 means recognized PMU
-+ * 	- 0 means not recognized PMU
-+ */
-+struct pfm_pmu_config {
-+	char *pmu_name;				/* PMU family name */
-+	char *version;				/* config module version */
-+
-+	int counter_width;			/* width of hardware counter */
-+
-+	struct pfm_regmap_desc	*pmc_desc;	/* PMC register descriptions */
-+	struct pfm_regmap_desc	*pmd_desc;	/* PMD register descriptions */
-+
-+	pfm_pmc_check_t		pmc_write_check;/* write checker (optional) */
-+	pfm_pmd_check_t		pmd_write_check;/* write checker (optional) */
-+	pfm_pmd_check_t		pmd_read_check;	/* read checker (optional) */
-+
-+	pfm_sread_t		pmd_sread;	/* virtual pmd read */
-+	pfm_swrite_t		pmd_swrite;	/* virtual pmd write */
-+
-+	int             	(*probe_pmu)(void);/* probe PMU routine */
-+
-+	u16			num_pmc_entries;/* #entries in pmc_desc */
-+	u16			num_pmd_entries;/* #entries in pmd_desc */
-+
-+	void			*pmu_info;	/* model-specific infos */
-+	u32			flags;		/* set of flags */
-+
-+	struct module		*owner;		/* pointer to module struct */
-+
-+	/*
-+	 * fields computed internally, do not set in module
-+	 */
-+	struct pfm_regdesc	regs_all;	/* regs available to all */
-+	struct pfm_regdesc	regs_thr;	/* regs avail per-thread */
-+	struct pfm_regdesc	regs_sys;	/* regs avail system-wide */
-+
-+	u64			ovfl_mask;	/* overflow mask */
-+};
-+
-+static inline void *pfm_pmu_info(void)
-+{
-+	return pfm_pmu_conf->pmu_info;
-+}
-+
-+/*
-+ * pfm_pmu_config flags
-+ */
-+#define PFM_PMUFL_IS_BUILTIN	0x1	/* pmu config is compiled in */
-+
-+/*
-+ * we need to know whether the PMU description is builtin or compiled
-+ * as a module
-+ */
-+#ifdef MODULE
-+#define PFM_PMU_BUILTIN_FLAG	0	/* not built as a module */
-+#else
-+#define PFM_PMU_BUILTIN_FLAG	PFM_PMUFL_IS_BUILTIN /* built as a module */
-+#endif
-+
-+int pfm_pmu_register(struct pfm_pmu_config *cfg);
-+void pfm_pmu_unregister(struct pfm_pmu_config *cfg);
-+
-+int pfm_sysfs_remove_pmu(struct pfm_pmu_config *pmu);
-+int pfm_sysfs_add_pmu(struct pfm_pmu_config *pmu);
-+
-+#endif /* __PERFMON_PMU_H__ */
-diff --git a/include/linux/sched.h b/include/linux/sched.h
-index 3d9120c..8fb3b55 100644
---- a/include/linux/sched.h
-+++ b/include/linux/sched.h
-@@ -96,6 +96,7 @@ struct exec_domain;
- struct futex_pi_state;
- struct robust_list_head;
- struct bio;
-+struct pfm_context;
- 
- /*
-  * List of flags we want to share for kernel threads,
-@@ -1301,6 +1302,9 @@ struct task_struct {
- 	int latency_record_count;
- 	struct latency_record latency_record[LT_SAVECOUNT];
- #endif
-+#ifdef CONFIG_PERFMON
-+	struct pfm_context *pfm_context;
-+#endif
- };
- 
- /*
-diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
-index d6ff145..e308523 100644
---- a/include/linux/syscalls.h
-+++ b/include/linux/syscalls.h
-@@ -29,6 +29,13 @@ struct msqid_ds;
- struct new_utsname;
- struct nfsctl_arg;
- struct __old_kernel_stat;
-+struct pfarg_ctx;
-+struct pfarg_pmc;
-+struct pfarg_pmd;
-+struct pfarg_start;
-+struct pfarg_load;
-+struct pfarg_setinfo;
-+struct pfarg_setdesc;
- struct pollfd;
- struct rlimit;
- struct rusage;
-@@ -625,4 +632,27 @@ asmlinkage long sys_fallocate(int fd, int mode, loff_t offset, loff_t len);
- 
- int kernel_execve(const char *filename, char *const argv[], char *const envp[]);
- 
-+asmlinkage long sys_pfm_create_context(struct pfarg_ctx __user *ureq,
-+				       void __user *uarg, size_t smpl_size);
-+asmlinkage long sys_pfm_write_pmcs(int fd, struct pfarg_pmc __user *ureq,
-+				   int count);
-+asmlinkage long sys_pfm_write_pmds(int fd, struct pfarg_pmd __user *ureq,
-+				   int count);
-+asmlinkage long sys_pfm_read_pmds(int fd, struct pfarg_pmd __user *ureq,
-+				  int count);
-+asmlinkage long sys_pfm_restart(int fd);
-+asmlinkage long sys_pfm_stop(int fd);
-+asmlinkage long sys_pfm_start(int fd, struct pfarg_start __user *ureq);
-+asmlinkage long sys_pfm_load_context(int fd, struct pfarg_load __user *ureq);
-+asmlinkage long sys_pfm_unload_context(int fd);
-+asmlinkage long sys_pfm_delete_evtsets(int fd,
-+				       struct pfarg_setinfo __user *ureq,
-+				       int count);
-+asmlinkage long sys_pfm_create_evtsets(int fd,
-+				       struct pfarg_setdesc __user *ureq,
-+				       int count);
-+asmlinkage long sys_pfm_getinfo_evtsets(int fd,
-+					struct pfarg_setinfo __user *ureq,
-+					int count);
-+
- #endif
-diff --git a/kernel/sched.c b/kernel/sched.c
-index ad1962d..1bc8fcf 100644
---- a/kernel/sched.c
-+++ b/kernel/sched.c
-@@ -71,6 +71,7 @@
- #include <linux/debugfs.h>
- #include <linux/ctype.h>
- #include <linux/ftrace.h>
-+#include <linux/perfmon_kern.h>
- 
- #include <asm/tlb.h>
- #include <asm/irq_regs.h>
-diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c
-index 08d6e1b..61f4155 100644
---- a/kernel/sys_ni.c
-+++ b/kernel/sys_ni.c
-@@ -126,6 +126,19 @@ cond_syscall(sys_vm86);
- cond_syscall(compat_sys_ipc);
- cond_syscall(compat_sys_sysctl);
- 
-+cond_syscall(sys_pfm_create_context);
-+cond_syscall(sys_pfm_write_pmcs);
-+cond_syscall(sys_pfm_write_pmds);
-+cond_syscall(sys_pfm_read_pmds);
-+cond_syscall(sys_pfm_restart);
-+cond_syscall(sys_pfm_start);
-+cond_syscall(sys_pfm_stop);
-+cond_syscall(sys_pfm_load_context);
-+cond_syscall(sys_pfm_unload_context);
-+cond_syscall(sys_pfm_create_evtsets);
-+cond_syscall(sys_pfm_delete_evtsets);
-+cond_syscall(sys_pfm_getinfo_evtsets);
-+
- /* arch-specific weak syscall entries */
- cond_syscall(sys_pciconfig_read);
- cond_syscall(sys_pciconfig_write);
-diff --git a/perfmon/Makefile b/perfmon/Makefile
-new file mode 100644
-index 0000000..32ff037
---- /dev/null
-+++ b/perfmon/Makefile
-@@ -0,0 +1,12 @@
-+#
-+# Copyright (c) 2005-2006 Hewlett-Packard Development Company, L.P.
-+# Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+#
-+obj-y = perfmon_init.o perfmon_rw.o perfmon_res.o           \
-+	perfmon_pmu.o perfmon_sysfs.o perfmon_syscalls.o    \
-+	perfmon_file.o perfmon_ctxsw.o perfmon_intr.o	    \
-+	perfmon_dfl_smpl.o perfmon_sets.o perfmon_hotplug.o \
-+	perfmon_msg.o perfmon_smpl.o perfmon_attach.o       \
-+	perfmon_activate.o perfmon_ctx.o perfmon_fmt.o
-+
-+obj-$(CONFIG_PERFMON_DEBUG_FS) +=  perfmon_debugfs.o
-diff --git a/perfmon/perfmon_activate.c b/perfmon/perfmon_activate.c
-new file mode 100644
-index 0000000..d9f501d
---- /dev/null
-+++ b/perfmon/perfmon_activate.c
-@@ -0,0 +1,265 @@
-+/*
-+ * perfmon_activate.c: perfmon2 start/stop functions
-+ *
-+ * This file implements the perfmon2 interface which
-+ * provides access to the hardware performance counters
-+ * of the host processor.
-+ *
-+ *
-+ * The initial version of perfmon.c was written by
-+ * Ganesh Venkitachalam, IBM Corp.
-+ *
-+ * Then it was modified for perfmon-1.x by Stephane Eranian and
-+ * David Mosberger, Hewlett Packard Co.
-+ *
-+ * Version Perfmon-2.x is a complete rewrite of perfmon-1.x
-+ * by Stephane Eranian, Hewlett Packard Co.
-+ *
-+ * Copyright (c) 1999-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *                David Mosberger-Tang <davidm@hpl.hp.com>
-+ *
-+ * More information about perfmon available at:
-+ * 	http://perfmon2.sf.net
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/kernel.h>
-+#include <linux/perfmon_kern.h>
-+#include "perfmon_priv.h"
-+
-+/**
-+ * __pfm_start - activate monitoring
-+ * @ctx: context to operate on
-+ * @start: pfarg_start as passed by user
-+ *
-+ * When operating in per-thread mode and not self-monitoring, the monitored
-+ * thread must be stopped. Activation will be effective next time the thread
-+ * is context switched in.
-+ *
-+ * The pfarg_start argument is optional and may be used to designate
-+ * the initial event set to activate. When not provided, the last active
-+ * set is used. For the first activation, set0 is used when start is NULL.
-+ *
-+ * On some architectures, e.g., IA-64, it may be possible to start monitoring
-+ * without calling this function under certain conditions (per-thread and self
-+ * monitoring). In this case, either set0 or the last active set is used.
-+ *
-+ * the context is locked and interrupts are disabled.
-+ */
-+int __pfm_start(struct pfm_context *ctx, struct pfarg_start *start)
-+{
-+	struct task_struct *task, *owner_task;
-+	struct pfm_event_set *new_set, *old_set;
-+	int is_self;
-+
-+	task = ctx->task;
-+
-+	/*
-+	 * UNLOADED: error
-+	 * LOADED  : normal start, nop if started unless set is different
-+	 * MASKED  : nop or change set when unmasking
-+	 * ZOMBIE  : cannot happen
-+	 */
-+	if (ctx->state == PFM_CTX_UNLOADED)
-+		return -EINVAL;
-+
-+	old_set = new_set = ctx->active_set;
-+
-+	/*
-+	 * always the case for system-wide
-+	 */
-+	if (task == NULL)
-+		task = current;
-+
-+	is_self = task == current;
-+
-+	/*
-+	 * argument is provided?
-+	 */
-+	if (start) {
-+		/*
-+		 * find the set to load first
-+		 */
-+		new_set = pfm_find_set(ctx, start->start_set, 0);
-+		if (new_set == NULL) {
-+			PFM_DBG("event set%u does not exist",
-+				start->start_set);
-+			return -EINVAL;
-+		}
-+	}
-+
-+	PFM_DBG("cur_set=%u req_set=%u", old_set->id, new_set->id);
-+
-+	/*
-+	 * if we need to change the active set we need
-+	 * to check if we can access the PMU
-+	 */
-+	if (new_set != old_set) {
-+
-+		owner_task = __get_cpu_var(pmu_owner);
-+		/*
-+		 * system-wide: must run on the right CPU
-+		 * per-thread : must be the owner of the PMU context
-+		 *
-+		 * pfm_switch_sets() returns with monitoring stopped
-+		 */
-+		if (is_self) {
-+			pfm_switch_sets(ctx, new_set, PFM_PMD_RESET_LONG, 1);
-+		} else {
-+			/*
-+			 * In a UP kernel, the PMU may contain the state
-+			 * of the task we want to operate on, yet the task
-+			 * may be switched out (lazy save). We need to save
-+			 * current state (old_set), switch active_set and
-+			 * mark it for reload.
-+			 */
-+			if (owner_task == task)
-+				pfm_save_pmds(ctx, old_set);
-+			ctx->active_set = new_set;
-+			new_set->priv_flags |= PFM_SETFL_PRIV_MOD_BOTH;
-+		}
-+	}
-+
-+	/*
-+	 * mark as started
-+	 * must be done before calling pfm_arch_start()
-+	 */
-+	ctx->flags.started = 1;
-+
-+	pfm_arch_start(task, ctx);
-+
-+	/*
-+	 * we check whether we had a pending ovfl before restarting.
-+	 * If so we need to regenerate the interrupt to make sure we
-+	 * keep recorded samples. For non-self monitoring this check
-+	 * is done in the pfm_ctxswin_thread() routine.
-+	 *
-+	 * we check new_set/old_set because pfm_switch_sets() already
-+	 * takes care of replaying the pending interrupts
-+	 */
-+	if (is_self && new_set != old_set && new_set->npend_ovfls) {
-+		pfm_arch_resend_irq(ctx);
-+		pfm_stats_inc(ovfl_intr_replay_count);
-+	}
-+
-+	/*
-+	 * always start with full timeout
-+	 */
-+	new_set->hrtimer_rem = new_set->hrtimer_exp;
-+
-+	/*
-+	 * activate timeout for system-wide, self-montoring
-+	 * Always start with full timeout
-+	 * Timeout is at least one tick away, so no risk of
-+	 * having hrtimer_start() trying to wakeup softirqd
-+	 * and thus causing troubles. This cannot happen anmyway
-+	 * because cb_mode = HRTIMER_CB_IRQSAFE_NO_SOFTIRQ
-+	 */
-+	if (is_self && new_set->flags & PFM_SETFL_TIME_SWITCH) {
-+		hrtimer_start(&__get_cpu_var(pfm_hrtimer),
-+			      new_set->hrtimer_rem,
-+			      HRTIMER_MODE_REL);
-+
-+		PFM_DBG("set%u started timeout=%lld",
-+			new_set->id,
-+			(unsigned long long)new_set->hrtimer_rem.tv64);
-+	}
-+
-+	/*
-+	 * we restart total duration even if context was
-+	 * already started. In that case, counts are simply
-+	 * reset.
-+	 *
-+	 * For per-thread, if not self-monitoring, the statement
-+	 * below will have no effect because thread is stopped.
-+	 * The field is reset of ctxsw in.
-+	 */
-+	new_set->duration_start = sched_clock();
-+
-+	return 0;
-+}
-+
-+/**
-+ * __pfm_stop - stop monitoring
-+ * @ctx: context to operate on
-+ * @release_info: infos for caller (see below)
-+ *
-+ * When operating in per-thread* mode and when not self-monitoring,
-+ * the monitored thread must be stopped.
-+ *
-+ * the context is locked and interrupts are disabled.
-+ *
-+ * release_info value upon return:
-+ * 	- bit 0 : unused
-+ * 	- bit 1 : when set, must cancel hrtimer
-+ */
-+int __pfm_stop(struct pfm_context *ctx, int *release_info)
-+{
-+	struct pfm_event_set *set;
-+	struct task_struct *task;
-+	u64 now;
-+	int state;
-+
-+	*release_info = 0;
-+
-+	now = sched_clock();
-+	state = ctx->state;
-+	set = ctx->active_set;
-+
-+	/*
-+	 * context must be attached (zombie cannot happen)
-+	 */
-+	if (state == PFM_CTX_UNLOADED)
-+		return -EINVAL;
-+
-+	task = ctx->task;
-+
-+	PFM_DBG("ctx_task=[%d] ctx_state=%d is_system=%d",
-+		task ? task->pid : -1,
-+		state,
-+		!task);
-+
-+	/*
-+	 * this happens for system-wide context
-+	 */
-+	if (task == NULL)
-+		task = current;
-+
-+	/*
-+	 * compute elapsed time
-+	 *
-+	 * unless masked, compute elapsed duration, stop timeout
-+	 */
-+	if (task == current && state == PFM_CTX_LOADED) {
-+		/*
-+		 * timeout cancel must be deferred until context is
-+		 * unlocked to avoid race with pfm_handle_switch_timeout()
-+		 */
-+		if (set->flags & PFM_SETFL_TIME_SWITCH)
-+			*release_info |= 0x2;
-+
-+		set->duration += now - set->duration_start;
-+	}
-+
-+	pfm_arch_stop(task, ctx);
-+
-+	ctx->flags.started = 0;
-+	/*
-+	 * starting now, in-flight PMU interrupt for this context
-+	 * are treated as spurious
-+	 */
-+	return 0;
-+}
-diff --git a/perfmon/perfmon_attach.c b/perfmon/perfmon_attach.c
-new file mode 100644
-index 0000000..bbd1d1e
---- /dev/null
-+++ b/perfmon/perfmon_attach.c
-@@ -0,0 +1,474 @@
-+/*
-+ * perfmon_attach.c: perfmon2 load/unload functions
-+ *
-+ * This file implements the perfmon2 interface which
-+ * provides access to the hardware performance counters
-+ * of the host processor.
-+ *
-+ *
-+ * The initial version of perfmon.c was written by
-+ * Ganesh Venkitachalam, IBM Corp.
-+ *
-+ * Then it was modified for perfmon-1.x by Stephane Eranian and
-+ * David Mosberger, Hewlett Packard Co.
-+ *
-+ * Version Perfmon-2.x is a complete rewrite of perfmon-1.x
-+ * by Stephane Eranian, Hewlett Packard Co.
-+ *
-+ * Copyright (c) 1999-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *                David Mosberger-Tang <davidm@hpl.hp.com>
-+ *
-+ * More information about perfmon available at:
-+ * 	http://perfmon2.sf.net
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/kernel.h>
-+#include <linux/fs.h>
-+#include <linux/perfmon_kern.h>
-+#include "perfmon_priv.h"
-+
-+/**
-+ * __pfm_load_context_sys - attach context to a CPU in system-wide mode
-+ * @ctx: context to operate on
-+ * @set_id: set to activate first
-+ * @cpu: CPU to monitor
-+ *
-+ * The cpu specified in the pfarg_load.load_pid  argument must be the current
-+ * CPU.
-+ *
-+ * The function must be called with the context locked and interrupts disabled.
-+ */
-+static int pfm_load_ctx_sys(struct pfm_context *ctx, u16 set_id, u32 cpu)
-+{
-+	struct pfm_event_set *set;
-+	int mycpu;
-+	int ret;
-+
-+	mycpu = smp_processor_id();
-+
-+	/*
-+	 * system-wide: check we are running on the desired CPU
-+	 */
-+	if (cpu != mycpu) {
-+		PFM_DBG("wrong CPU: asking %u but on %u", cpu, mycpu);
-+		return -EINVAL;
-+	}
-+
-+	/*
-+	 * initialize sets
-+	 */
-+	set = pfm_prepare_sets(ctx, set_id);
-+	if (!set) {
-+		PFM_DBG("event set%u does not exist", set_id);
-+		return -EINVAL;
-+	}
-+
-+	PFM_DBG("set=%u set_flags=0x%x", set->id, set->flags);
-+
-+	ctx->cpu = mycpu;
-+	ctx->task = NULL;
-+	ctx->active_set = set;
-+
-+	/*
-+	 * perform any architecture specific actions
-+	 */
-+	ret = pfm_arch_load_context(ctx);
-+	if (ret)
-+		goto error_noload;
-+
-+	/*
-+	 * now reserve the session, before we can proceed with
-+	 * actually accessing the PMU hardware
-+	 */
-+	ret = pfm_session_acquire(1, mycpu);
-+	if (ret)
-+		goto error;
-+
-+
-+	/*
-+	 * caller must be on monitored CPU to access PMU, thus this is
-+	 * a form of self-monitoring
-+	 */
-+	ctx->flags.is_self = 1;
-+
-+	set->runs++;
-+
-+	/*
-+	 * load PMD from set
-+	 * load PMC from set
-+	 */
-+	pfm_arch_restore_pmds(ctx, set);
-+	pfm_arch_restore_pmcs(ctx, set);
-+
-+	/*
-+	 * set new ownership
-+	 */
-+	pfm_set_pmu_owner(NULL, ctx);
-+
-+	/*
-+	 * reset pending work
-+	 */
-+	ctx->flags.work_type = PFM_WORK_NONE;
-+	ctx->flags.reset_count = 0;
-+
-+	/*
-+	 * reset message queue
-+	 */
-+	ctx->msgq_head = ctx->msgq_tail = 0;
-+
-+	ctx->state = PFM_CTX_LOADED;
-+
-+	return 0;
-+error:
-+	pfm_arch_unload_context(ctx);
-+error_noload:
-+	return ret;
-+}
-+
-+/**
-+ * __pfm_load_context_thread - attach context to a thread
-+ * @ctx: context to operate on
-+ * @set_id: first set
-+ * @task: threadf to attach to
-+ *
-+ * The function must be called with the context locked and interrupts disabled.
-+ */
-+static int pfm_load_ctx_thread(struct pfm_context *ctx, u16 set_id,
-+			       struct task_struct *task)
-+{
-+	struct pfm_event_set *set;
-+	struct pfm_context *old;
-+	int ret;
-+
-+	PFM_DBG("load_pid=%d set=%u", task->pid, set_id);
-+	/*
-+	 * per-thread:
-+	 *   - task to attach to is checked in sys_pfm_load_context() to avoid
-+	 *     locking issues. if found, and not self,  task refcount was
-+	 *     incremented.
-+	 */
-+	old = cmpxchg(&task->pfm_context, NULL, ctx);
-+	if (old) {
-+		PFM_DBG("load_pid=%d has a context "
-+			"old=%p new=%p cur=%p",
-+			task->pid,
-+			old,
-+			ctx,
-+			task->pfm_context);
-+		return -EEXIST;
-+	}
-+
-+	/*
-+	 * initialize sets
-+	 */
-+	set = pfm_prepare_sets(ctx, set_id);
-+	if (!set) {
-+		PFM_DBG("event set%u does not exist", set_id);
-+		return -EINVAL;
-+	}
-+
-+
-+	ctx->task = task;
-+	ctx->cpu = -1;
-+	ctx->active_set = set;
-+
-+	/*
-+	 * perform any architecture specific actions
-+	 */
-+	ret = pfm_arch_load_context(ctx);
-+	if (ret)
-+		goto error_noload;
-+
-+	/*
-+	 * now reserve the session, before we can proceed with
-+	 * actually accessing the PMU hardware
-+	 */
-+	ret = pfm_session_acquire(0, -1);
-+	if (ret)
-+		goto error;
-+
-+
-+	set->runs++;
-+	if (ctx->task != current) {
-+
-+		ctx->flags.is_self = 0;
-+
-+		/* force a full reload */
-+		ctx->last_act = PFM_INVALID_ACTIVATION;
-+		ctx->last_cpu = -1;
-+		set->priv_flags |= PFM_SETFL_PRIV_MOD_BOTH;
-+
-+	} else {
-+		pfm_check_save_prev_ctx();
-+
-+		ctx->last_cpu = smp_processor_id();
-+		__get_cpu_var(pmu_activation_number)++;
-+		ctx->last_act = __get_cpu_var(pmu_activation_number);
-+
-+		ctx->flags.is_self = 1;
-+
-+		/*
-+		 * load PMD from set
-+		 * load PMC from set
-+		 */
-+		pfm_arch_restore_pmds(ctx, set);
-+		pfm_arch_restore_pmcs(ctx, set);
-+
-+		/*
-+		 * set new ownership
-+		 */
-+		pfm_set_pmu_owner(ctx->task, ctx);
-+	}
-+	set_tsk_thread_flag(task, TIF_PERFMON_CTXSW);
-+
-+	/*
-+	 * reset pending work
-+	 */
-+	ctx->flags.work_type = PFM_WORK_NONE;
-+	ctx->flags.reset_count = 0;
-+
-+	/*
-+	 * reset message queue
-+	 */
-+	ctx->msgq_head = ctx->msgq_tail = 0;
-+
-+	ctx->state = PFM_CTX_LOADED;
-+
-+	return 0;
-+
-+error:
-+	pfm_arch_unload_context(ctx);
-+	ctx->task = NULL;
-+error_noload:
-+	/*
-+	 * detach context
-+	 */
-+	task->pfm_context = NULL;
-+	return ret;
-+}
-+
-+/**
-+ * __pfm_load_context - attach context to a CPU or thread
-+ * @ctx: context to operate on
-+ * @load: pfarg_load as passed by user
-+ * @task: thread to attach to, NULL for system-wide
-+ */
-+int __pfm_load_context(struct pfm_context *ctx, struct pfarg_load *load,
-+		       struct task_struct *task)
-+{
-+	if (ctx->flags.system)
-+		return pfm_load_ctx_sys(ctx, load->load_set, load->load_pid);
-+	return pfm_load_ctx_thread(ctx, load->load_set, task);
-+}
-+
-+/**
-+ * pfm_update_ovfl_pmds - account for pending ovfls on PMDs
-+ * @ctx: context to operate on
-+ *
-+ * This function is always called after pfm_stop has been issued
-+ */
-+static void pfm_update_ovfl_pmds(struct pfm_context *ctx)
-+{
-+	struct pfm_event_set *set;
-+	u64 *cnt_pmds;
-+	u64 ovfl_mask;
-+	u16 num_ovfls, i, first;
-+
-+	ovfl_mask = pfm_pmu_conf->ovfl_mask;
-+	first = ctx->regs.first_intr_pmd;
-+	cnt_pmds = ctx->regs.cnt_pmds;
-+
-+	/*
-+	 * look for pending interrupts and adjust PMD values accordingly
-+	 */
-+	list_for_each_entry(set, &ctx->set_list, list) {
-+
-+		if (!set->npend_ovfls)
-+			continue;
-+
-+		num_ovfls = set->npend_ovfls;
-+		PFM_DBG("set%u nintrs=%u", set->id, num_ovfls);
-+
-+		for (i = first; num_ovfls; i++) {
-+			if (test_bit(i, cast_ulp(set->povfl_pmds))) {
-+				/* only correct value for counters */
-+				if (test_bit(i, cast_ulp(cnt_pmds)))
-+					set->pmds[i].value += 1 + ovfl_mask;
-+				num_ovfls--;
-+			}
-+			PFM_DBG("pmd%u set=%u val=0x%llx",
-+				i,
-+				set->id,
-+				(unsigned long long)set->pmds[i].value);
-+		}
-+		/*
-+		 * we need to clear to prevent a pfm_getinfo_evtsets() from
-+		 * returning stale data even after the context is unloaded
-+		 */
-+		set->npend_ovfls = 0;
-+		bitmap_zero(cast_ulp(set->povfl_pmds), ctx->regs.max_intr_pmd);
-+	}
-+}
-+
-+
-+/**
-+ * __pfm_unload_context - detach context from CPU or thread
-+ * @ctx: context to operate on
-+ * @release_info: pointer to return info (see below)
-+ *
-+ * The function must be called with the context locked and interrupts disabled.
-+ *
-+ * release_info value upon return:
-+ * 	- bit 0: when set, must free context
-+ * 	- bit 1: when set, must cancel hrtimer
-+ */
-+int __pfm_unload_context(struct pfm_context *ctx, int *release_info)
-+{
-+	struct task_struct *task;
-+	int ret;
-+
-+	PFM_DBG("ctx_state=%d task [%d]",
-+		ctx->state,
-+		ctx->task ? ctx->task->pid : -1);
-+
-+	*release_info = 0;
-+
-+	/*
-+	 * unload only when necessary
-+	 */
-+	if (ctx->state == PFM_CTX_UNLOADED)
-+		return 0;
-+
-+	task = ctx->task;
-+
-+	/*
-+	 * stop monitoring
-+	 */
-+	ret = __pfm_stop(ctx, release_info);
-+	if (ret)
-+		return ret;
-+
-+	ctx->state = PFM_CTX_UNLOADED;
-+	ctx->flags.can_restart = 0;
-+
-+	/*
-+	 * save active set
-+	 * UP:
-+	 * 	if not current task and due to lazy, state may
-+	 * 	still be live
-+	 * for system-wide, guaranteed to run on correct CPU
-+	 */
-+	if (__get_cpu_var(pmu_ctx) == ctx) {
-+		/*
-+		 * pending overflows have been saved by pfm_stop()
-+		 */
-+		pfm_save_pmds(ctx, ctx->active_set);
-+		pfm_set_pmu_owner(NULL, NULL);
-+		PFM_DBG("released ownership");
-+	}
-+
-+	/*
-+	 * account for pending overflows
-+	 */
-+	pfm_update_ovfl_pmds(ctx);
-+
-+	/*
-+	 * arch-specific unload operations
-+	 */
-+	pfm_arch_unload_context(ctx);
-+
-+	/*
-+	 * per-thread: disconnect from monitored task
-+	 */
-+	if (task) {
-+		task->pfm_context = NULL;
-+		ctx->task = NULL;
-+		clear_tsk_thread_flag(task, TIF_PERFMON_CTXSW);
-+		clear_tsk_thread_flag(task, TIF_PERFMON_WORK);
-+		pfm_arch_disarm_handle_work(task);
-+	}
-+	/*
-+	 * session can be freed, must have interrupts enabled
-+	 * thus we release in the caller. Bit 0 signals to the
-+	 * caller that the session can be released.
-+	 */
-+	*release_info |= 0x1;
-+
-+	return 0;
-+}
-+
-+/**
-+ * __pfm_exit_thread - detach and free context on thread exit
-+ */
-+void __pfm_exit_thread(void)
-+{
-+	struct pfm_context *ctx;
-+	unsigned long flags;
-+	int free_ok = 0, release_info = 0;
-+	int ret;
-+
-+	ctx  = current->pfm_context;
-+
-+	BUG_ON(ctx->flags.system);
-+
-+	spin_lock_irqsave(&ctx->lock, flags);
-+
-+	PFM_DBG("state=%d is_self=%d", ctx->state, ctx->flags.is_self);
-+
-+	/*
-+	 * __pfm_unload_context() cannot fail
-+	 * in the context states we are interested in
-+	 */
-+	switch (ctx->state) {
-+	case PFM_CTX_LOADED:
-+	case PFM_CTX_MASKED:
-+		__pfm_unload_context(ctx, &release_info);
-+		/*
-+		 * end notification only sent for non
-+		 * self-monitoring context
-+		 */
-+		if (!ctx->flags.is_self)
-+			pfm_end_notify(ctx);
-+		break;
-+	case PFM_CTX_ZOMBIE:
-+		__pfm_unload_context(ctx, &release_info);
-+		free_ok = 1;
-+		break;
-+	default:
-+		BUG_ON(ctx->state != PFM_CTX_LOADED);
-+		break;
-+	}
-+	spin_unlock_irqrestore(&ctx->lock, flags);
-+
-+	/*
-+	 * cancel timer now that context is unlocked
-+	 */
-+	if (release_info & 0x2) {
-+		ret = hrtimer_cancel(&__get_cpu_var(pfm_hrtimer));
-+		PFM_DBG("timeout cancel=%d", ret);
-+	}
-+
-+	if (release_info & 0x1)
-+		pfm_session_release(0, 0);
-+
-+	/*
-+	 * All memory free operations (especially for vmalloc'ed memory)
-+	 * MUST be done with interrupts ENABLED.
-+	 */
-+	if (free_ok)
-+		pfm_free_context(ctx);
-+}
-diff --git a/perfmon/perfmon_ctx.c b/perfmon/perfmon_ctx.c
-new file mode 100644
-index 0000000..afe6078
---- /dev/null
-+++ b/perfmon/perfmon_ctx.c
-@@ -0,0 +1,314 @@
-+/*
-+ * perfmon_ctx.c: perfmon2 context functions
-+ *
-+ * This file implements the perfmon2 interface which
-+ * provides access to the hardware performance counters
-+ * of the host processor.
-+ *
-+ *
-+ * The initial version of perfmon.c was written by
-+ * Ganesh Venkitachalam, IBM Corp.
-+ *
-+ * Then it was modified for perfmon-1.x by Stephane Eranian and
-+ * David Mosberger, Hewlett Packard Co.
-+ *
-+ * Version Perfmon-2.x is a complete rewrite of perfmon-1.x
-+ * by Stephane Eranian, Hewlett Packard Co.
-+ *
-+ * Copyright (c) 1999-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *                David Mosberger-Tang <davidm@hpl.hp.com>
-+ *
-+ * More information about perfmon available at:
-+ * 	http://perfmon2.sf.net
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/kernel.h>
-+#include <linux/fs.h>
-+#include <linux/perfmon_kern.h>
-+#include "perfmon_priv.h"
-+
-+/*
-+ * context memory pool pointer
-+ */
-+static struct kmem_cache *pfm_ctx_cachep;
-+
-+/**
-+ * pfm_free_context - de-allocate context and associated resources
-+ * @ctx: context to free
-+ */
-+void pfm_free_context(struct pfm_context *ctx)
-+{
-+	pfm_arch_context_free(ctx);
-+
-+	pfm_free_sets(ctx);
-+
-+	pfm_smpl_buf_free(ctx);
-+
-+	PFM_DBG("free ctx @0x%p", ctx);
-+	kmem_cache_free(pfm_ctx_cachep, ctx);
-+	/*
-+	 * decrease refcount on:
-+	 * 	- PMU description table
-+	 * 	- sampling format
-+	 */
-+	pfm_pmu_conf_put();
-+	pfm_pmu_release();
-+}
-+
-+/**
-+ * pfm_ctx_flags_sane - check if context flags passed by user are okay
-+ * @ctx_flags: flags passed user on pfm_create_context
-+ *
-+ * return:
-+ * 	 0 if successful
-+ * 	<0 and error code otherwise
-+ */
-+static inline int pfm_ctx_flags_sane(u32 ctx_flags)
-+{
-+	if (ctx_flags & PFM_FL_SYSTEM_WIDE) {
-+		if (ctx_flags & PFM_FL_NOTIFY_BLOCK) {
-+			PFM_DBG("cannot use blocking mode in syswide mode");
-+			return -EINVAL;
-+		}
-+	}
-+	return 0;
-+}
-+
-+/**
-+ * pfm_ctx_permissions - check authorization to create new context
-+ * @ctx_flags: context flags passed by user
-+ *
-+ * check for permissions to create a context.
-+ *
-+ * A sysadmin may decide to restrict creation of per-thread
-+ * and/or system-wide context to a group of users using the
-+ * group id via /sys/kernel/perfmon/task_group  and
-+ * /sys/kernel/perfmon/sys_group.
-+ *
-+ * Once we identify a user level package which can be used
-+ * to grant/revoke Linux capabilites at login via PAM, we will
-+ * be able to use capabilities. We would also need to increase
-+ * the size of cap_t to support more than 32 capabilities (it
-+ * is currently defined as u32 and 32 capabilities are alrady
-+ * defined).
-+ */
-+static inline int pfm_ctx_permissions(u32 ctx_flags)
-+{
-+	if ((ctx_flags & PFM_FL_SYSTEM_WIDE)
-+	    && pfm_controls.sys_group != PFM_GROUP_PERM_ANY
-+	    && !in_group_p(pfm_controls.sys_group)) {
-+		PFM_DBG("user group not allowed to create a syswide ctx");
-+		return -EPERM;
-+	} else if (pfm_controls.task_group != PFM_GROUP_PERM_ANY
-+		   && !in_group_p(pfm_controls.task_group)) {
-+		PFM_DBG("user group not allowed to create a task context");
-+		return -EPERM;
-+	}
-+	return 0;
-+}
-+
-+/**
-+ * __pfm_create_context - allocate and initialize a perfmon context
-+ * @req : pfarg_ctx from user
-+ * @fmt : pointer sampling format, NULL if not used
-+ * @fmt_arg: pointer to argument to sampling format, NULL if not used
-+ * @mode: PFM_NORMAL or PFM_COMPAT(IA-64 v2.0 compatibility)
-+ * @ctx : address of new context upon succesful return, undefined otherwise
-+ *
-+ * function used to allocate a new context. A context is allocated along
-+ * with the default event set. If a sampling format is used, the buffer
-+ * may be allocated and initialized.
-+ *
-+ * The file descriptor identifying the context is allocated and returned
-+ * to caller.
-+ *
-+ * This function operates with no locks and interrupts are enabled.
-+ * return:
-+ * 	>=0: the file descriptor to identify the context
-+ * 	<0 : the error code
-+ */
-+int __pfm_create_context(struct pfarg_ctx *req,
-+			 struct pfm_smpl_fmt *fmt,
-+			 void *fmt_arg,
-+			 int mode,
-+			 struct pfm_context **new_ctx)
-+{
-+	struct pfm_context *ctx;
-+	struct file *filp = NULL;
-+	u32 ctx_flags;
-+	int fd = 0, ret;
-+
-+	ctx_flags = req->ctx_flags;
-+
-+	/* Increase refcount on PMU description */
-+	ret = pfm_pmu_conf_get(1);
-+	if (ret < 0)
-+		goto error_conf;
-+
-+	ret = pfm_ctx_flags_sane(ctx_flags);
-+	if (ret < 0)
-+		goto error_alloc;
-+
-+	ret = pfm_ctx_permissions(ctx_flags);
-+	if (ret < 0)
-+		goto error_alloc;
-+
-+	/*
-+	 * we can use GFP_KERNEL and potentially sleep because we do
-+	 * not hold any lock at this point.
-+	 */
-+	might_sleep();
-+	ret = -ENOMEM;
-+	ctx = kmem_cache_zalloc(pfm_ctx_cachep, GFP_KERNEL);
-+	if (!ctx)
-+		goto error_alloc;
-+
-+	PFM_DBG("alloc ctx @0x%p", ctx);
-+
-+	INIT_LIST_HEAD(&ctx->set_list);
-+	spin_lock_init(&ctx->lock);
-+	init_completion(&ctx->restart_complete);
-+	init_waitqueue_head(&ctx->msgq_wait);
-+
-+	/*
-+	 * context is unloaded
-+	 */
-+	ctx->state = PFM_CTX_UNLOADED;
-+
-+	/*
-+	 * initialization of context's flags
-+	 * must be done before pfm_find_set()
-+	 */
-+	ctx->flags.block = (ctx_flags & PFM_FL_NOTIFY_BLOCK) ? 1 : 0;
-+	ctx->flags.system = (ctx_flags & PFM_FL_SYSTEM_WIDE) ? 1: 0;
-+	ctx->flags.no_msg = (ctx_flags & PFM_FL_OVFL_NO_MSG) ? 1: 0;
-+	ctx->flags.ia64_v20_compat = mode == PFM_COMPAT ? 1 : 0;
-+
-+	ret = pfm_pmu_acquire(ctx);
-+	if (ret)
-+		goto error_file;
-+	/*
-+	 * check if PMU is usable
-+	 */
-+	if (!(ctx->regs.num_pmcs && ctx->regs.num_pmcs)) {
-+		PFM_DBG("no usable PMU registers");
-+		ret = -EBUSY;
-+		goto error_file;
-+	}
-+
-+	/*
-+	 * link to format, must be done first for correct
-+	 * error handling in pfm_context_free()
-+	 */
-+	ctx->smpl_fmt = fmt;
-+
-+	ret = -ENFILE;
-+	fd = pfm_alloc_fd(&filp);
-+	if (fd < 0)
-+		goto error_file;
-+
-+	/*
-+	 * initialize arch-specific section
-+	 * must be done before fmt_init()
-+	 */
-+	ret = pfm_arch_context_create(ctx, ctx_flags);
-+	if (ret)
-+		goto error_set;
-+
-+	ret = -ENOMEM;
-+
-+	/*
-+	 * add initial set
-+	 */
-+	if (pfm_create_initial_set(ctx))
-+		goto error_set;
-+
-+	/*
-+	 * does the user want to sample?
-+	 * must be done after pfm_pmu_acquire() because
-+	 * needs ctx->regs
-+	 */
-+	if (fmt) {
-+		ret = pfm_setup_smpl_fmt(ctx, ctx_flags, fmt_arg, filp);
-+		if (ret)
-+			goto error_set;
-+	}
-+
-+	filp->private_data = ctx;
-+
-+	ctx->last_act = PFM_INVALID_ACTIVATION;
-+	ctx->last_cpu = -1;
-+
-+	/*
-+	 * initialize notification message queue
-+	 */
-+	ctx->msgq_head = ctx->msgq_tail = 0;
-+
-+	PFM_DBG("flags=0x%x system=%d notify_block=%d no_msg=%d"
-+		" use_fmt=%d ctx_fd=%d mode=%d",
-+		ctx_flags,
-+		ctx->flags.system,
-+		ctx->flags.block,
-+		ctx->flags.no_msg,
-+		!!fmt,
-+		fd, mode);
-+
-+	if (new_ctx)
-+		*new_ctx = ctx;
-+
-+	/*
-+	 * we defer the fd_install until we are certain the call succeeded
-+	 * to ensure we do not have to undo its effect. Neither put_filp()
-+	 * nor put_unused_fd() undoes the effect of fd_install().
-+	 */
-+	fd_install(fd, filp);
-+
-+	return fd;
-+
-+error_set:
-+	put_filp(filp);
-+	put_unused_fd(fd);
-+error_file:
-+	/*
-+	 * calls the right *_put() functions
-+	 * calls pfm_release_pmu()
-+	 */
-+	pfm_free_context(ctx);
-+	return ret;
-+error_alloc:
-+	pfm_pmu_conf_put();
-+error_conf:
-+	pfm_smpl_fmt_put(fmt);
-+	return ret;
-+}
-+
-+/**
-+ * pfm_init_ctx -- initialize context SLAB
-+ *
-+ * called from pfm_init
-+ */
-+int __init pfm_init_ctx(void)
-+{
-+	pfm_ctx_cachep = kmem_cache_create("pfm_context",
-+				   sizeof(struct pfm_context)+PFM_ARCH_CTX_SIZE,
-+				   SLAB_HWCACHE_ALIGN, 0, NULL);
-+	if (!pfm_ctx_cachep) {
-+		PFM_ERR("cannot initialize context slab");
-+		return -ENOMEM;
-+	}
-+	return 0;
-+}
-diff --git a/perfmon/perfmon_ctxsw.c b/perfmon/perfmon_ctxsw.c
-new file mode 100644
-index 0000000..9a28d13
---- /dev/null
-+++ b/perfmon/perfmon_ctxsw.c
-@@ -0,0 +1,342 @@
-+/*
-+ * perfmon_cxtsw.c: perfmon2 context switch code
-+ *
-+ * This file implements the perfmon2 interface which
-+ * provides access to the hardware performance counters
-+ * of the host processor.
-+ *
-+ * The initial version of perfmon.c was written by
-+ * Ganesh Venkitachalam, IBM Corp.
-+ *
-+ * Then it was modified for perfmon-1.x by Stephane Eranian and
-+ * David Mosberger, Hewlett Packard Co.
-+ *
-+ * Version Perfmon-2.x is a complete rewrite of perfmon-1.x
-+ * by Stephane Eranian, Hewlett Packard Co.
-+ *
-+ * Copyright (c) 1999-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *                David Mosberger-Tang <davidm@hpl.hp.com>
-+ *
-+ * More information about perfmon available at:
-+ * 	http://perfmon2.sf.net
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/kernel.h>
-+#include <linux/perfmon_kern.h>
-+#include "perfmon_priv.h"
-+
-+void pfm_save_pmds(struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	u64 val, ovfl_mask;
-+	u64 *used_pmds, *cnt_pmds;
-+	u16 i, num;
-+
-+	ovfl_mask = pfm_pmu_conf->ovfl_mask;
-+	num = set->nused_pmds;
-+	cnt_pmds = ctx->regs.cnt_pmds;
-+	used_pmds = set->used_pmds;
-+
-+	/*
-+	 * save HW PMD, for counters, reconstruct 64-bit value
-+	 */
-+	for (i = 0; num; i++) {
-+		if (test_bit(i, cast_ulp(used_pmds))) {
-+			val = pfm_read_pmd(ctx, i);
-+			if (likely(test_bit(i, cast_ulp(cnt_pmds))))
-+				val = (set->pmds[i].value & ~ovfl_mask) |
-+					(val & ovfl_mask);
-+			set->pmds[i].value = val;
-+			num--;
-+		}
-+	}
-+	pfm_arch_clear_pmd_ovfl_cond(ctx, set);
-+}
-+
-+/*
-+ * interrupts are  disabled (no preemption)
-+ */
-+void __pfm_ctxswin_thread(struct task_struct *task,
-+				 struct pfm_context *ctx, u64 now)
-+{
-+	u64 cur_act;
-+	struct pfm_event_set *set;
-+	int reload_pmcs, reload_pmds;
-+	int mycpu, is_active;
-+
-+	mycpu = smp_processor_id();
-+
-+	cur_act = __get_cpu_var(pmu_activation_number);
-+	/*
-+	 * we need to lock context because it could be accessed
-+	 * from another CPU. Normally the schedule() functions
-+	 * has masked interrupts which should be enough to
-+	 * protect against PMU interrupts.
-+	 */
-+	spin_lock(&ctx->lock);
-+
-+	is_active = pfm_arch_is_active(ctx);
-+
-+	set = ctx->active_set;
-+
-+	/*
-+	 * in case fo zombie, we do not complete ctswin of the
-+	 * PMU, and we force a call to pfm_handle_work() to finish
-+	 * cleanup, i.e., free context + smpl_buff. The reason for
-+	 * deferring to pfm_handle_work() is that it is not possible
-+	 * to vfree() with interrupts disabled.
-+	 */
-+	if (unlikely(ctx->state == PFM_CTX_ZOMBIE)) {
-+		pfm_post_work(task, ctx, PFM_WORK_ZOMBIE);
-+		goto done;
-+	}
-+
-+	/*
-+	 * if we were the last user of the PMU on that CPU,
-+	 * then nothing to do except restore psr
-+	 */
-+	if (ctx->last_cpu == mycpu && ctx->last_act == cur_act) {
-+		/*
-+		 * check for forced reload conditions
-+		 */
-+		reload_pmcs = set->priv_flags & PFM_SETFL_PRIV_MOD_PMCS;
-+		reload_pmds = set->priv_flags & PFM_SETFL_PRIV_MOD_PMDS;
-+	} else {
-+#ifndef CONFIG_SMP
-+		pfm_check_save_prev_ctx();
-+#endif
-+		reload_pmcs = 1;
-+		reload_pmds = 1;
-+	}
-+	/* consumed */
-+	set->priv_flags &= ~PFM_SETFL_PRIV_MOD_BOTH;
-+
-+	if (reload_pmds)
-+		pfm_arch_restore_pmds(ctx, set);
-+
-+	/*
-+	 * need to check if had in-flight interrupt in
-+	 * pfm_ctxswout_thread(). If at least one bit set, then we must replay
-+	 * the interrupt to avoid losing some important performance data.
-+	 *
-+	 * npend_ovfls is cleared in interrupt handler
-+	 */
-+	if (set->npend_ovfls) {
-+		pfm_arch_resend_irq(ctx);
-+		pfm_stats_inc(ovfl_intr_replay_count);
-+	}
-+
-+	if (reload_pmcs)
-+		pfm_arch_restore_pmcs(ctx, set);
-+
-+	/*
-+	 * record current activation for this context
-+	 */
-+	__get_cpu_var(pmu_activation_number)++;
-+	ctx->last_cpu = mycpu;
-+	ctx->last_act = __get_cpu_var(pmu_activation_number);
-+
-+	/*
-+	 * establish new ownership.
-+	 */
-+	pfm_set_pmu_owner(task, ctx);
-+
-+	pfm_arch_ctxswin_thread(task, ctx);
-+	/*
-+	 * set->duration does not count when context in MASKED state.
-+	 * set->duration_start is reset in unmask_monitoring()
-+	 */
-+	set->duration_start = now;
-+
-+	/*
-+	 * re-arm switch timeout, if necessary
-+	 * Timeout is active only if monitoring is active,
-+	 * i.e., LOADED + started
-+	 *
-+	 * We reload the remainder timeout or the full timeout.
-+	 * Remainder is recorded on context switch out or in
-+	 * pfm_load_context()
-+	 */
-+	if (ctx->state == PFM_CTX_LOADED
-+	    && (set->flags & PFM_SETFL_TIME_SWITCH) && is_active) {
-+		pfm_restart_timer(ctx, set);
-+		/* careful here as pfm_restart_timer may switch sets */
-+	}
-+done:
-+	spin_unlock(&ctx->lock);
-+}
-+
-+/*
-+ * interrupts are masked, runqueue lock is held.
-+ *
-+ * In UP. we simply stop monitoring and leave the state
-+ * in place, i.e., lazy save
-+ */
-+void __pfm_ctxswout_thread(struct task_struct *task,
-+				  struct pfm_context *ctx, u64 now)
-+{
-+	struct pfm_event_set *set;
-+	int need_save_pmds, is_active;
-+
-+	/*
-+	 * we need to lock context because it could be accessed
-+	 * from another CPU. Normally the schedule() functions
-+	 * has masked interrupts which should be enough to
-+	 * protect against PMU interrupts.
-+	 */
-+
-+	spin_lock(&ctx->lock);
-+
-+	is_active = pfm_arch_is_active(ctx);
-+	set = ctx->active_set;
-+
-+	/*
-+	 * stop monitoring and
-+	 * collect pending overflow information
-+	 * needed on ctxswin. We cannot afford to lose
-+	 * a PMU interrupt.
-+	 */
-+	need_save_pmds = pfm_arch_ctxswout_thread(task, ctx);
-+
-+	if (ctx->state == PFM_CTX_LOADED) {
-+		/*
-+		 * accumulate only when set is actively monitoring,
-+		 */
-+		set->duration += now - set->duration_start;
-+
-+		/*
-+		 * record remaining timeout
-+		 * reload in pfm_ctxsw_in()
-+		 */
-+		if (is_active && (set->flags & PFM_SETFL_TIME_SWITCH)) {
-+			struct hrtimer *h = NULL;
-+			h = &__get_cpu_var(pfm_hrtimer);
-+			hrtimer_cancel(h);
-+			set->hrtimer_rem = hrtimer_get_remaining(h);
-+			PFM_DBG_ovfl("hrtimer=%lld",
-+				     (long long)set->hrtimer_rem.tv64);
-+		}
-+	}
-+
-+#ifdef CONFIG_SMP
-+	/*
-+	 * in SMP, release ownership of this PMU.
-+	 * PMU interrupts are masked, so nothing
-+	 * can happen.
-+	 */
-+	pfm_set_pmu_owner(NULL, NULL);
-+
-+	/*
-+	 * On some architectures, it is necessary to read the
-+	 * PMD registers to check for pending overflow in
-+	 * pfm_arch_ctxswout_thread(). In that case, saving of
-+	 * the PMDs  may be  done there and not here.
-+	 */
-+	if (need_save_pmds)
-+		pfm_save_pmds(ctx, set);
-+#endif
-+	spin_unlock(&ctx->lock);
-+}
-+
-+/*
-+ *
-+ */
-+static void __pfm_ctxswout_sys(struct task_struct *prev,
-+			       struct task_struct *next)
-+{
-+	struct pfm_context *ctx;
-+
-+	ctx = __get_cpu_var(pmu_ctx);
-+	BUG_ON(!ctx);
-+
-+	/*
-+	 * propagate TIF_PERFMON_CTXSW to ensure that:
-+	 * - previous task has TIF_PERFMON_CTXSW cleared, in case it is
-+	 *   scheduled onto another CPU where there is syswide monitoring
-+	 * - next task has TIF_PERFMON_CTXSW set to ensure it will come back
-+	 *   here when context switched out
-+	 */
-+	clear_tsk_thread_flag(prev, TIF_PERFMON_CTXSW);
-+	set_tsk_thread_flag(next, TIF_PERFMON_CTXSW);
-+
-+	/*
-+	 * nothing to do until actually started
-+	 * XXX: assumes no mean to start from user level
-+	 */
-+	if (!ctx->flags.started)
-+		return;
-+
-+	pfm_arch_ctxswout_sys(prev, ctx);
-+}
-+
-+/*
-+ *
-+ */
-+static void __pfm_ctxswin_sys(struct task_struct *prev,
-+			      struct task_struct *next)
-+{
-+	struct pfm_context *ctx;
-+
-+	ctx = __get_cpu_var(pmu_ctx);
-+	BUG_ON(!ctx);
-+
-+	/*
-+	 * nothing to do until actually started
-+	 * XXX: assumes no mean to start from user level
-+	 */
-+	if (!ctx->flags.started)
-+		return;
-+
-+	pfm_arch_ctxswin_sys(next, ctx);
-+}
-+
-+void pfm_ctxsw_out(struct task_struct *prev,
-+		   struct task_struct *next)
-+{
-+	struct pfm_context *ctxp;
-+	u64 now;
-+
-+	now = sched_clock();
-+
-+	ctxp = prev->pfm_context;
-+
-+	if (ctxp)
-+		__pfm_ctxswout_thread(prev, ctxp, now);
-+	else
-+		__pfm_ctxswout_sys(prev, next);
-+
-+	pfm_stats_inc(ctxswout_count);
-+	pfm_stats_add(ctxswout_ns, sched_clock() - now);
-+}
-+
-+void pfm_ctxsw_in(struct task_struct *prev,
-+		  struct task_struct *next)
-+{
-+	struct pfm_context *ctxn;
-+	u64 now;
-+
-+	now = sched_clock();
-+
-+	ctxn = next->pfm_context;
-+
-+	if (ctxn)
-+		__pfm_ctxswin_thread(next, ctxn, now);
-+	else
-+		__pfm_ctxswin_sys(prev, next);
-+
-+	pfm_stats_inc(ctxswin_count);
-+	pfm_stats_add(ctxswin_ns, sched_clock() - now);
-+}
-diff --git a/perfmon/perfmon_debugfs.c b/perfmon/perfmon_debugfs.c
-new file mode 100644
-index 0000000..e4d2fad
---- /dev/null
-+++ b/perfmon/perfmon_debugfs.c
-@@ -0,0 +1,168 @@
-+/*
-+ * perfmon_debugfs.c: perfmon2 statistics interface to debugfs
-+ *
-+ * This file implements the perfmon2 interface which
-+ * provides access to the hardware performance counters
-+ * of the host processor.
-+ *
-+ * The initial version of perfmon.c was written by
-+ * Ganesh Venkitachalam, IBM Corp.
-+ *
-+ * Then it was modified for perfmon-1.x by Stephane Eranian and
-+ * David Mosberger, Hewlett Packard Co.
-+ *
-+ * Version Perfmon-2.x is a complete rewrite of perfmon-1.x
-+ * by Stephane Eranian, Hewlett Packard Co.
-+ *
-+ * Copyright (c) 2007 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * More information about perfmon available at:
-+ * 	http://perfmon2.sf.net
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/kernel.h>
-+#include <linux/debugfs.h>
-+#include <linux/perfmon_kern.h>
-+
-+/*
-+ * to make the statistics visible to user space:
-+ * $ mount -t debugfs none /mnt
-+ * $ cd /mnt/perfmon
-+ * then choose a CPU subdir
-+ */
-+DECLARE_PER_CPU(struct pfm_stats, pfm_stats);
-+
-+static struct dentry *pfm_debugfs_dir;
-+
-+void pfm_reset_stats(int cpu)
-+{
-+	struct pfm_stats *st;
-+	unsigned long flags;
-+
-+	st = &per_cpu(pfm_stats, cpu);
-+
-+	local_irq_save(flags);
-+	memset(st->v, 0, sizeof(st->v));
-+	local_irq_restore(flags);
-+}
-+
-+static const char *pfm_stats_strs[] = {
-+	"ovfl_intr_all_count",
-+	"ovfl_intr_ns",
-+	"ovfl_intr_spurious_count",
-+	"ovfl_intr_replay_count",
-+	"ovfl_intr_regular_count",
-+	"handle_work_count",
-+	"ovfl_notify_count",
-+	"reset_pmds_count",
-+	"pfm_restart_count",
-+	"fmt_handler_calls",
-+	"fmt_handler_ns",
-+	"set_switch_count",
-+	"set_switch_ns",
-+	"set_switch_exp",
-+	"ctxswin_count",
-+	"ctxswin_ns",
-+	"handle_timeout_count",
-+	"ovfl_intr_nmi_count",
-+	"ctxswout_count",
-+	"ctxswout_ns",
-+};
-+#define PFM_NUM_STRS ARRAY_SIZE(pfm_stats_strs)
-+
-+void pfm_debugfs_del_cpu(int cpu)
-+{
-+	struct pfm_stats *st;
-+	int i;
-+
-+	st = &per_cpu(pfm_stats, cpu);
-+
-+	for (i = 0; i < PFM_NUM_STATS; i++) {
-+		if (st->dirs[i])
-+			debugfs_remove(st->dirs[i]);
-+		st->dirs[i] = NULL;
-+	}
-+	if (st->cpu_dir)
-+		debugfs_remove(st->cpu_dir);
-+	st->cpu_dir = NULL;
-+}
-+
-+int pfm_debugfs_add_cpu(int cpu)
-+{
-+	struct pfm_stats *st;
-+	int i;
-+
-+	/*
-+	 * sanity check between stats names and the number
-+	 * of entries in the pfm_stats value array.
-+	 */
-+	if (PFM_NUM_STRS != PFM_NUM_STATS) {
-+		PFM_ERR("PFM_NUM_STRS != PFM_NUM_STATS error");
-+		return -1;
-+	}
-+
-+	st = &per_cpu(pfm_stats, cpu);
-+	sprintf(st->cpu_name, "cpu%d", cpu);
-+
-+	st->cpu_dir = debugfs_create_dir(st->cpu_name, pfm_debugfs_dir);
-+	if (!st->cpu_dir)
-+		return -1;
-+
-+	for (i = 0; i < PFM_NUM_STATS; i++) {
-+		st->dirs[i] = debugfs_create_u64(pfm_stats_strs[i],
-+						 S_IRUGO,
-+						 st->cpu_dir,
-+						 &st->v[i]);
-+		if (!st->dirs[i])
-+			goto error;
-+	}
-+	pfm_reset_stats(cpu);
-+	return 0;
-+error:
-+	while (i >= 0) {
-+		debugfs_remove(st->dirs[i]);
-+		i--;
-+	}
-+	debugfs_remove(st->cpu_dir);
-+	return -1;
-+}
-+
-+/*
-+ * called once from pfm_init()
-+ */
-+int __init pfm_init_debugfs(void)
-+{
-+	int cpu1, cpu2, ret;
-+
-+	pfm_debugfs_dir = debugfs_create_dir("perfmon", NULL);
-+	if (!pfm_debugfs_dir)
-+		return -1;
-+
-+	for_each_online_cpu(cpu1) {
-+		ret = pfm_debugfs_add_cpu(cpu1);
-+		if (ret)
-+			goto error;
-+	}
-+	return 0;
-+error:
-+	for_each_online_cpu(cpu2) {
-+		if (cpu2 == cpu1)
-+			break;
-+		pfm_debugfs_del_cpu(cpu2);
-+	}
-+	return -1;
-+}
-diff --git a/perfmon/perfmon_dfl_smpl.c b/perfmon/perfmon_dfl_smpl.c
-new file mode 100644
-index 0000000..8c83489
---- /dev/null
-+++ b/perfmon/perfmon_dfl_smpl.c
-@@ -0,0 +1,298 @@
-+/*
-+ * Copyright (c) 1999-2006 Hewlett-Packard Development Company, L.P.
-+ *               Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This file implements the new default sampling buffer format
-+ * for the perfmon2 subsystem.
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/kernel.h>
-+#include <linux/types.h>
-+#include <linux/module.h>
-+#include <linux/init.h>
-+#include <linux/smp.h>
-+
-+#include <linux/perfmon_kern.h>
-+#include <linux/perfmon_dfl_smpl.h>
-+
-+MODULE_AUTHOR("Stephane Eranian <eranian@hpl.hp.com>");
-+MODULE_DESCRIPTION("new perfmon default sampling format");
-+MODULE_LICENSE("GPL");
-+
-+static int pfm_dfl_fmt_validate(u32 ctx_flags, u16 npmds, void *data)
-+{
-+	struct pfm_dfl_smpl_arg *arg = data;
-+	u64 min_buf_size;
-+
-+	if (data == NULL) {
-+		PFM_DBG("no argument passed");
-+		return -EINVAL;
-+	}
-+
-+	/*
-+	 * sanity check in case size_t is smaller then u64
-+	 */
-+#if BITS_PER_LONG == 4
-+#define MAX_SIZE_T	(1ULL<<(sizeof(size_t)<<3))
-+	if (sizeof(size_t) < sizeof(arg->buf_size)) {
-+		if (arg->buf_size >= MAX_SIZE_T)
-+			return -ETOOBIG;
-+	}
-+#endif
-+
-+	/*
-+	 * compute min buf size. npmds is the maximum number
-+	 * of implemented PMD registers.
-+	 */
-+	min_buf_size = sizeof(struct pfm_dfl_smpl_hdr)
-+		+ (sizeof(struct pfm_dfl_smpl_entry) + (npmds*sizeof(u64)));
-+
-+	PFM_DBG("validate ctx_flags=0x%x flags=0x%x npmds=%u "
-+		"min_buf_size=%llu buf_size=%llu\n",
-+		ctx_flags,
-+		arg->buf_flags,
-+		npmds,
-+		(unsigned long long)min_buf_size,
-+		(unsigned long long)arg->buf_size);
-+
-+	/*
-+	 * must hold at least the buffer header + one minimally sized entry
-+	 */
-+	if (arg->buf_size < min_buf_size)
-+		return -EINVAL;
-+
-+	return 0;
-+}
-+
-+static int pfm_dfl_fmt_get_size(u32 flags, void *data, size_t *size)
-+{
-+	struct pfm_dfl_smpl_arg *arg = data;
-+
-+	/*
-+	 * size has been validated in default_validate
-+	 * we can never loose bits from buf_size.
-+	 */
-+	*size = (size_t)arg->buf_size;
-+
-+	return 0;
-+}
-+
-+static int pfm_dfl_fmt_init(struct pfm_context *ctx, void *buf, u32 ctx_flags,
-+			    u16 npmds, void *data)
-+{
-+	struct pfm_dfl_smpl_hdr *hdr;
-+	struct pfm_dfl_smpl_arg *arg = data;
-+
-+	hdr = buf;
-+
-+	hdr->hdr_version = PFM_DFL_SMPL_VERSION;
-+	hdr->hdr_buf_size = arg->buf_size;
-+	hdr->hdr_buf_flags = arg->buf_flags;
-+	hdr->hdr_cur_offs = sizeof(*hdr);
-+	hdr->hdr_overflows = 0;
-+	hdr->hdr_count = 0;
-+	hdr->hdr_min_buf_space = sizeof(struct pfm_dfl_smpl_entry) + (npmds*sizeof(u64));
-+	/*
-+	 * due to cache aliasing, it may be necessary to flush the cache
-+	 * on certain architectures (e.g., MIPS)
-+	 */
-+	pfm_cacheflush(hdr, sizeof(*hdr));
-+
-+	PFM_DBG("buffer=%p buf_size=%llu hdr_size=%zu hdr_version=%u.%u "
-+		  "min_space=%llu npmds=%u",
-+		  buf,
-+		  (unsigned long long)hdr->hdr_buf_size,
-+		  sizeof(*hdr),
-+		  PFM_VERSION_MAJOR(hdr->hdr_version),
-+		  PFM_VERSION_MINOR(hdr->hdr_version),
-+		  (unsigned long long)hdr->hdr_min_buf_space,
-+		  npmds);
-+
-+	return 0;
-+}
-+
-+/*
-+ * called from pfm_overflow_handler() to record a new sample
-+ *
-+ * context is locked, interrupts are disabled (no preemption)
-+ */
-+static int pfm_dfl_fmt_handler(struct pfm_context *ctx,
-+			       unsigned long ip, u64 tstamp, void *data)
-+{
-+	struct pfm_dfl_smpl_hdr *hdr;
-+	struct pfm_dfl_smpl_entry *ent;
-+	struct pfm_ovfl_arg *arg;
-+	void *cur, *last;
-+	u64 *e;
-+	size_t entry_size, min_size;
-+	u16 npmds, i;
-+	u16 ovfl_pmd;
-+	void *buf;
-+
-+	hdr = ctx->smpl_addr;
-+	arg = &ctx->ovfl_arg;
-+
-+        buf = hdr;
-+	cur = buf+hdr->hdr_cur_offs;
-+	last = buf+hdr->hdr_buf_size;
-+	ovfl_pmd = arg->ovfl_pmd;
-+	min_size = hdr->hdr_min_buf_space;
-+
-+	/*
-+	 * precheck for sanity
-+	 */
-+	if ((last - cur) < min_size)
-+		goto full;
-+
-+	npmds = arg->num_smpl_pmds;
-+
-+	ent = (struct pfm_dfl_smpl_entry *)cur;
-+
-+	entry_size = sizeof(*ent) + (npmds << 3);
-+
-+	/* position for first pmd */
-+	e = (u64 *)(ent+1);
-+
-+	hdr->hdr_count++;
-+
-+	PFM_DBG_ovfl("count=%llu cur=%p last=%p free_bytes=%zu ovfl_pmd=%d "
-+		     "npmds=%u",
-+		     (unsigned long long)hdr->hdr_count,
-+		     cur, last,
-+		     (last-cur),
-+		     ovfl_pmd,
-+		     npmds);
-+
-+	/*
-+	 * current = task running at the time of the overflow.
-+	 *
-+	 * per-task mode:
-+	 * 	- this is usually the task being monitored.
-+	 * 	  Under certain conditions, it might be a different task
-+	 *
-+	 * system-wide:
-+	 * 	- this is not necessarily the task controlling the session
-+	 */
-+	ent->pid = current->pid;
-+	ent->ovfl_pmd = ovfl_pmd;
-+	ent->last_reset_val = arg->pmd_last_reset;
-+
-+	/*
-+	 * where did the fault happen (includes slot number)
-+	 */
-+	ent->ip = ip;
-+
-+	ent->tstamp = tstamp;
-+	ent->cpu = smp_processor_id();
-+	ent->set = arg->active_set;
-+	ent->tgid = current->tgid;
-+
-+	/*
-+	 * selectively store PMDs in increasing index number
-+	 */
-+	if (npmds) {
-+		u64 *val = arg->smpl_pmds_values;
-+		for (i = 0; i < npmds; i++)
-+			*e++ = *val++;
-+	}
-+
-+	/*
-+	 * update position for next entry
-+	 */
-+	hdr->hdr_cur_offs += entry_size;
-+	cur += entry_size;
-+
-+	pfm_cacheflush(hdr, sizeof(*hdr));
-+	pfm_cacheflush(ent, entry_size);
-+
-+	/*
-+	 * post check to avoid losing the last sample
-+	 */
-+	if ((last - cur) < min_size)
-+		goto full;
-+
-+	/* reset before returning from interrupt handler */
-+	arg->ovfl_ctrl = PFM_OVFL_CTRL_RESET;
-+
-+	return 0;
-+full:
-+	PFM_DBG_ovfl("sampling buffer full free=%zu, count=%llu",
-+		     last-cur,
-+		     (unsigned long long)hdr->hdr_count);
-+
-+	/*
-+	 * increment number of buffer overflows.
-+	 * important to detect duplicate set of samples.
-+	 */
-+	hdr->hdr_overflows++;
-+
-+	/*
-+	 * request notification and masking of monitoring.
-+	 * Notification is still subject to the overflowed
-+	 * register having the FL_NOTIFY flag set.
-+	 */
-+	arg->ovfl_ctrl = PFM_OVFL_CTRL_NOTIFY | PFM_OVFL_CTRL_MASK;
-+
-+	return -ENOBUFS; /* we are full, sorry */
-+}
-+
-+static int pfm_dfl_fmt_restart(int is_active, u32 *ovfl_ctrl, void *buf)
-+{
-+	struct pfm_dfl_smpl_hdr *hdr;
-+
-+	hdr = buf;
-+
-+	hdr->hdr_count = 0;
-+	hdr->hdr_cur_offs = sizeof(*hdr);
-+
-+	pfm_cacheflush(hdr, sizeof(*hdr));
-+
-+	*ovfl_ctrl = PFM_OVFL_CTRL_RESET;
-+
-+	return 0;
-+}
-+
-+static int pfm_dfl_fmt_exit(void *buf)
-+{
-+	return 0;
-+}
-+
-+static struct pfm_smpl_fmt dfl_fmt = {
-+	.fmt_name = "default",
-+	.fmt_version = 0x10000,
-+	.fmt_arg_size = sizeof(struct pfm_dfl_smpl_arg),
-+	.fmt_validate = pfm_dfl_fmt_validate,
-+	.fmt_getsize = pfm_dfl_fmt_get_size,
-+	.fmt_init = pfm_dfl_fmt_init,
-+	.fmt_handler = pfm_dfl_fmt_handler,
-+	.fmt_restart = pfm_dfl_fmt_restart,
-+	.fmt_exit = pfm_dfl_fmt_exit,
-+	.fmt_flags = PFM_FMT_BUILTIN_FLAG,
-+	.owner = THIS_MODULE
-+};
-+
-+static int pfm_dfl_fmt_init_module(void)
-+{
-+	return pfm_fmt_register(&dfl_fmt);
-+}
-+
-+static void pfm_dfl_fmt_cleanup_module(void)
-+{
-+	pfm_fmt_unregister(&dfl_fmt);
-+}
-+
-+module_init(pfm_dfl_fmt_init_module);
-+module_exit(pfm_dfl_fmt_cleanup_module);
-diff --git a/perfmon/perfmon_file.c b/perfmon/perfmon_file.c
-new file mode 100644
-index 0000000..1cde81b
---- /dev/null
-+++ b/perfmon/perfmon_file.c
-@@ -0,0 +1,751 @@
-+/*
-+ * perfmon_file.c: perfmon2 file input/output functions
-+ *
-+ * This file implements the perfmon2 interface which
-+ * provides access to the hardware performance counters
-+ * of the host processor.
-+ *
-+ * The initial version of perfmon.c was written by
-+ * Ganesh Venkitachalam, IBM Corp.
-+ *
-+ * Then it was modified for perfmon-1.x by Stephane Eranian and
-+ * David Mosberger, Hewlett Packard Co.
-+ *
-+ * Version Perfmon-2.x is a complete rewrite of perfmon-1.x
-+ * by Stephane Eranian, Hewlett Packard Co.
-+ *
-+ * Copyright (c) 1999-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *                David Mosberger-Tang <davidm@hpl.hp.com>
-+ *
-+ * More information about perfmon available at:
-+ * 	http://perfmon2.sf.net
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/kernel.h>
-+#include <linux/module.h>
-+#include <linux/file.h>
-+#include <linux/poll.h>
-+#include <linux/vfs.h>
-+#include <linux/pagemap.h>
-+#include <linux/mount.h>
-+#include <linux/perfmon_kern.h>
-+#include "perfmon_priv.h"
-+
-+#define PFMFS_MAGIC 0xa0b4d889	/* perfmon filesystem magic number */
-+
-+struct pfm_controls pfm_controls = {
-+	.sys_group = PFM_GROUP_PERM_ANY,
-+	.task_group = PFM_GROUP_PERM_ANY,
-+	.arg_mem_max = PAGE_SIZE,
-+	.smpl_buffer_mem_max = ~0,
-+};
-+EXPORT_SYMBOL(pfm_controls);
-+
-+static int __init enable_debug(char *str)
-+{
-+	pfm_controls.debug = 1;
-+	PFM_INFO("debug output enabled\n");
-+	return 1;
-+}
-+__setup("perfmon_debug", enable_debug);
-+
-+static int pfmfs_delete_dentry(struct dentry *dentry)
-+{
-+	return 1;
-+}
-+
-+static struct dentry_operations pfmfs_dentry_operations = {
-+	.d_delete = pfmfs_delete_dentry,
-+};
-+
-+int pfm_buf_map_pagefault(struct vm_area_struct *vma, struct vm_fault *vmf)
-+{
-+	void *kaddr;
-+	unsigned long address;
-+	struct pfm_context *ctx;
-+	size_t size;
-+
-+	address = (unsigned long)vmf->virtual_address;
-+
-+	ctx = vma->vm_private_data;
-+	if (ctx == NULL) {
-+		PFM_DBG("no ctx");
-+		return VM_FAULT_SIGBUS;
-+	}
-+	/*
-+	 * size available to user (maybe different from real_smpl_size
-+	 */
-+	size = ctx->smpl_size;
-+
-+	if ((address < vma->vm_start) ||
-+	    (address >= (vma->vm_start + size)))
-+		return VM_FAULT_SIGBUS;
-+
-+	kaddr = ctx->smpl_addr + (address - vma->vm_start);
-+
-+	vmf->page = vmalloc_to_page(kaddr);
-+	get_page(vmf->page);
-+
-+	PFM_DBG("[%d] start=%p ref_count=%d",
-+		current->pid,
-+		kaddr, page_count(vmf->page));
-+
-+	return 0;
-+}
-+
-+/*
-+ * we need to determine whther or not we are closing the last reference
-+ * to the file and thus are going to end up in pfm_close() which eventually
-+ * calls pfm_release_buf_space(). In that function, we update the accouting
-+ * for locked_vm given that we are actually freeing the sampling buffer. The
-+ * issue is that there are multiple paths leading to pfm_release_buf_space(),
-+ * from exit(), munmap(), close(). The path coming from munmap() is problematic
-+ * becuse do_munmap() grabs mmap_sem in write-mode which is also what
-+ * pfm_release_buf_space does. To avoid deadlock, we need to determine where
-+ * we are calling from and skip the locking. The vm_ops->close() callback
-+ * is invoked for each remove_vma() independently of the number of references
-+ * left on the file descriptor, therefore simple reference counter does not
-+ * work. We need to determine if this is the last call, and then set a flag
-+ * to skip the locking.
-+ */
-+static void pfm_buf_map_close(struct vm_area_struct *vma)
-+{
-+	struct file *file;
-+	struct pfm_context *ctx;
-+
-+	file = vma->vm_file;
-+	ctx = vma->vm_private_data;
-+
-+	/*
-+	 * if file is going to close, then pfm_close() will
-+	 * be called, do not lock in pfm_release_buf
-+	 */
-+	if (atomic_read(&file->f_count) == 1)
-+		ctx->flags.mmap_nlock = 1;
-+}
-+
-+/*
-+ * we do not have a close callback because, the locked
-+ * memory accounting must be done when the actual buffer
-+ * is freed. Munmap does not free the page backing the vma
-+ * because they may still be in use by the PMU interrupt handler.
-+ */
-+struct vm_operations_struct pfm_buf_map_vm_ops = {
-+	.fault = pfm_buf_map_pagefault,
-+	.close = pfm_buf_map_close
-+};
-+
-+static int pfm_mmap_buffer(struct pfm_context *ctx, struct vm_area_struct *vma,
-+			   size_t size)
-+{
-+	if (ctx->smpl_addr == NULL) {
-+		PFM_DBG("no sampling buffer to map");
-+		return -EINVAL;
-+	}
-+
-+	if (size > ctx->smpl_size) {
-+		PFM_DBG("mmap size=%zu >= actual buf size=%zu",
-+			size,
-+			ctx->smpl_size);
-+		return -EINVAL;
-+	}
-+
-+	vma->vm_ops = &pfm_buf_map_vm_ops;
-+	vma->vm_private_data = ctx;
-+
-+	return 0;
-+}
-+
-+static int pfm_mmap(struct file *file, struct vm_area_struct *vma)
-+{
-+	size_t size;
-+	struct pfm_context *ctx;
-+	unsigned long flags;
-+	int ret;
-+
-+	PFM_DBG("pfm_file_ops");
-+
-+	ctx  = file->private_data;
-+	size = (vma->vm_end - vma->vm_start);
-+
-+	if (ctx == NULL)
-+		return -EINVAL;
-+
-+	ret = -EINVAL;
-+
-+	spin_lock_irqsave(&ctx->lock, flags);
-+
-+	if (vma->vm_flags & VM_WRITE) {
-+		PFM_DBG("cannot map buffer for writing");
-+		goto done;
-+	}
-+
-+	PFM_DBG("vm_pgoff=%lu size=%zu vm_start=0x%lx",
-+		vma->vm_pgoff,
-+		size,
-+		vma->vm_start);
-+
-+	ret = pfm_mmap_buffer(ctx, vma, size);
-+	if (ret == 0)
-+		vma->vm_flags |= VM_RESERVED;
-+
-+	PFM_DBG("ret=%d vma_flags=0x%lx vma_start=0x%lx vma_size=%lu",
-+		ret,
-+		vma->vm_flags,
-+		vma->vm_start,
-+		vma->vm_end-vma->vm_start);
-+done:
-+	spin_unlock_irqrestore(&ctx->lock, flags);
-+
-+	return ret;
-+}
-+
-+/*
-+ * Extract one message from queue.
-+ *
-+ * return:
-+ * 	-EAGAIN:  when non-blocking and nothing is* in the queue.
-+ * 	-ERESTARTSYS: when blocking and signal is pending
-+ * 	Otherwise returns size of message (sizeof(pfarg_msg))
-+ */
-+ssize_t __pfm_read(struct pfm_context *ctx, union pfarg_msg *msg_buf, int non_block)
-+{
-+	ssize_t ret = 0;
-+	unsigned long flags;
-+	DECLARE_WAITQUEUE(wait, current);
-+
-+	/*
-+	 * we must masks interrupts to avoid a race condition
-+	 * with the PMU interrupt handler.
-+	 */
-+	spin_lock_irqsave(&ctx->lock, flags);
-+
-+	while (pfm_msgq_is_empty(ctx)) {
-+
-+		/*
-+		 * handle non-blocking reads
-+		 * return -EAGAIN
-+		 */
-+		ret = -EAGAIN;
-+		if (non_block)
-+			break;
-+
-+		add_wait_queue(&ctx->msgq_wait, &wait);
-+		set_current_state(TASK_INTERRUPTIBLE);
-+
-+		spin_unlock_irqrestore(&ctx->lock, flags);
-+
-+		schedule();
-+
-+		/*
-+		 * during this window, another thread may call
-+		 * pfm_read() and steal our message
-+		 */
-+
-+		spin_lock_irqsave(&ctx->lock, flags);
-+
-+		remove_wait_queue(&ctx->msgq_wait, &wait);
-+		set_current_state(TASK_RUNNING);
-+
-+		/*
-+		 * check for pending signals
-+		 * return -ERESTARTSYS
-+		 */
-+		ret = -ERESTARTSYS;
-+		if (signal_pending(current))
-+			break;
-+
-+		/*
-+		 * we may have a message
-+		 */
-+		ret = 0;
-+	}
-+
-+	/*
-+	 * extract message
-+	 */
-+	if (ret == 0) {
-+		/*
-+		 * copy the oldest message into msg_buf.
-+		 * We cannot directly call copy_to_user()
-+		 * because interrupts masked. This is done
-+		 * in the caller
-+		 */
-+		pfm_get_next_msg(ctx, msg_buf);
-+
-+		ret = sizeof(*msg_buf);
-+
-+		PFM_DBG("extracted type=%d", msg_buf->type);
-+	}
-+
-+	spin_unlock_irqrestore(&ctx->lock, flags);
-+
-+	PFM_DBG("blocking=%d ret=%zd", non_block, ret);
-+
-+	return ret;
-+}
-+
-+static ssize_t pfm_read(struct file *filp, char __user *buf, size_t size,
-+			loff_t *ppos)
-+{
-+	struct pfm_context *ctx;
-+	union pfarg_msg msg_buf;
-+	int non_block, ret;
-+
-+	PFM_DBG_ovfl("buf=%p size=%zu", buf, size);
-+
-+	ctx = filp->private_data;
-+	if (ctx == NULL) {
-+		PFM_ERR("no ctx for pfm_read");
-+		return -EINVAL;
-+	}
-+
-+	non_block = filp->f_flags & O_NONBLOCK;
-+
-+#ifdef CONFIG_IA64_PERFMON_COMPAT
-+	/*
-+	 * detect IA-64 v2.0 context read (message size is different)
-+	 * nops on all other architectures
-+	 */
-+	if (unlikely(ctx->flags.ia64_v20_compat))
-+		return pfm_arch_compat_read(ctx,  buf, non_block, size);
-+#endif
-+	/*
-+	 * cannot extract partial messages.
-+	 * check even when there is no message
-+	 *
-+	 * cannot extract more than one message per call. Bytes
-+	 * above sizeof(msg) are ignored.
-+	 */
-+	if (size < sizeof(msg_buf)) {
-+		PFM_DBG("message is too small size=%zu must be >=%zu)",
-+			size,
-+			sizeof(msg_buf));
-+		return -EINVAL;
-+	}
-+
-+	ret =  __pfm_read(ctx, &msg_buf, non_block);
-+	if (ret > 0) {
-+		if (copy_to_user(buf, &msg_buf, sizeof(msg_buf)))
-+			ret = -EFAULT;
-+	}
-+	PFM_DBG_ovfl("ret=%d", ret);
-+	return ret;
-+}
-+
-+static ssize_t pfm_write(struct file *file, const char __user *ubuf,
-+			  size_t size, loff_t *ppos)
-+{
-+	PFM_DBG("pfm_write called");
-+	return -EINVAL;
-+}
-+
-+static unsigned int pfm_poll(struct file *filp, poll_table *wait)
-+{
-+	struct pfm_context *ctx;
-+	unsigned long flags;
-+	unsigned int mask = 0;
-+
-+	PFM_DBG("pfm_file_ops");
-+
-+	if (filp->f_op != &pfm_file_ops) {
-+		PFM_ERR("pfm_poll bad magic");
-+		return 0;
-+	}
-+
-+	ctx = filp->private_data;
-+	if (ctx == NULL) {
-+		PFM_ERR("pfm_poll no ctx");
-+		return 0;
-+	}
-+
-+	PFM_DBG("before poll_wait");
-+
-+	poll_wait(filp, &ctx->msgq_wait, wait);
-+
-+	/*
-+	 * pfm_msgq_is_empty() is non-atomic
-+	 *
-+	 * filp is protected by fget() at upper level
-+	 * context cannot be closed by another thread.
-+	 *
-+	 * There may be a race with a PMU interrupt adding
-+	 * messages to the queue. But we are interested in
-+	 * queue not empty, so adding more messages should
-+	 * not really be a problem.
-+	 *
-+	 * There may be a race with another thread issuing
-+	 * a read() and stealing messages from the queue thus
-+	 * may return the wrong answer. This could potentially
-+	 * lead to a blocking read, because nothing is
-+	 * available in the queue
-+	 */
-+	spin_lock_irqsave(&ctx->lock, flags);
-+
-+	if (!pfm_msgq_is_empty(ctx))
-+		mask =  POLLIN | POLLRDNORM;
-+
-+	spin_unlock_irqrestore(&ctx->lock, flags);
-+
-+	PFM_DBG("after poll_wait mask=0x%x", mask);
-+
-+	return mask;
-+}
-+
-+static int pfm_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-+		     unsigned long arg)
-+{
-+	PFM_DBG("pfm_ioctl called");
-+	return -EINVAL;
-+}
-+
-+/*
-+ * interrupt cannot be masked when entering this function
-+ */
-+static inline int __pfm_fasync(int fd, struct file *filp,
-+			       struct pfm_context *ctx, int on)
-+{
-+	int ret;
-+
-+	PFM_DBG("in  fd=%d on=%d async_q=%p",
-+		fd,
-+		on,
-+		ctx->async_queue);
-+
-+	ret = fasync_helper(fd, filp, on, &ctx->async_queue);
-+
-+	PFM_DBG("out fd=%d on=%d async_q=%p ret=%d",
-+		fd,
-+		on,
-+		ctx->async_queue, ret);
-+
-+	return ret;
-+}
-+
-+static int pfm_fasync(int fd, struct file *filp, int on)
-+{
-+	struct pfm_context *ctx;
-+	int ret;
-+
-+	PFM_DBG("pfm_file_ops");
-+
-+	ctx = filp->private_data;
-+	if (ctx == NULL) {
-+		PFM_ERR("pfm_fasync no ctx");
-+		return -EBADF;
-+	}
-+
-+	/*
-+	 * we cannot mask interrupts during this call because this may
-+	 * may go to sleep if memory is not readily avalaible.
-+	 *
-+	 * We are protected from the context disappearing by the
-+	 * get_fd()/put_fd() done in caller. Serialization of this function
-+	 * is ensured by caller.
-+	 */
-+	ret = __pfm_fasync(fd, filp, ctx, on);
-+
-+	PFM_DBG("pfm_fasync called on fd=%d on=%d async_queue=%p ret=%d",
-+		fd,
-+		on,
-+		ctx->async_queue, ret);
-+
-+	return ret;
-+}
-+
-+#ifdef CONFIG_SMP
-+static void __pfm_close_remote_cpu(void *info)
-+{
-+	struct pfm_context *ctx = info;
-+	int can_release;
-+
-+	BUG_ON(ctx != __get_cpu_var(pmu_ctx));
-+
-+	/*
-+	 * we are in IPI interrupt handler which has always higher
-+	 * priority than PMU interrupt, therefore we do not need to
-+	 * mask interrupts. context locking is not needed because we
-+	 * are in close(), no more user references.
-+	 *
-+	 * can_release is ignored, release done on calling CPU
-+	 */
-+	__pfm_unload_context(ctx, &can_release);
-+
-+	/*
-+	 * we cannot free context here because we are in_interrupt().
-+	 * we free on the calling CPU
-+	 */
-+}
-+
-+static int pfm_close_remote_cpu(u32 cpu, struct pfm_context *ctx)
-+{
-+	BUG_ON(irqs_disabled());
-+	return smp_call_function_single(cpu, __pfm_close_remote_cpu, ctx, 1);
-+}
-+#endif /* CONFIG_SMP */
-+
-+/*
-+ * called either on explicit close() or from exit_files().
-+ * Only the LAST user of the file gets to this point, i.e., it is
-+ * called only ONCE.
-+ *
-+ * IMPORTANT: we get called ONLY when the refcnt on the file gets to zero
-+ * (fput()),i.e, last task to access the file. Nobody else can access the
-+ * file at this point.
-+ *
-+ * When called from exit_files(), the VMA has been freed because exit_mm()
-+ * is executed before exit_files().
-+ *
-+ * When called from exit_files(), the current task is not yet ZOMBIE but we
-+ * flush the PMU state to the context.
-+ */
-+int __pfm_close(struct pfm_context *ctx, struct file *filp)
-+{
-+	unsigned long flags;
-+	int state;
-+	int can_free = 1, can_unload = 1;
-+	int is_system, can_release = 0;
-+	u32 cpu;
-+
-+	/*
-+	 * no risk of ctx of filp disappearing so we can operate outside
-+	 * of spin_lock(). fasync_helper() runs with interrupts masked,
-+	 * thus there is no risk with the PMU interrupt handler
-+	 *
-+	 * In case of zombie, we will not have the async struct anymore
-+	 * thus kill_fasync() will not do anything
-+	 *
-+	 * fd is not used when removing the entry so we pass -1
-+	 */
-+	if (filp->f_flags & FASYNC)
-+		__pfm_fasync (-1, filp, ctx, 0);
-+
-+	spin_lock_irqsave(&ctx->lock, flags);
-+
-+	state = ctx->state;
-+	is_system = ctx->flags.system;
-+	cpu = ctx->cpu;
-+
-+	PFM_DBG("state=%d", state);
-+
-+	/*
-+	 * check if unload is needed
-+	 */
-+	if (state == PFM_CTX_UNLOADED)
-+		goto doit;
-+
-+#ifdef CONFIG_SMP
-+	/*
-+	 * we need to release the resource on the ORIGINAL cpu.
-+	 * we need to release the context lock to avoid deadlocks
-+	 * on the original CPU, especially in the context switch
-+	 * routines. It is safe to unlock because we are in close(),
-+	 * in other words, there is no more access from user level.
-+	 * we can also unmask interrupts on this CPU because the
-+	 * context is running on the original CPU. Context will be
-+	 * unloaded and the session will be released on the original
-+	 * CPU. Upon return, the caller is guaranteed that the context
-+	 * is gone from original CPU.
-+	 */
-+	if (is_system && cpu != smp_processor_id()) {
-+		spin_unlock_irqrestore(&ctx->lock, flags);
-+		pfm_close_remote_cpu(cpu, ctx);
-+		can_release = 1;
-+		goto free_it;
-+	}
-+
-+	if (!is_system && ctx->task != current) {
-+		/*
-+		 * switch context to zombie state
-+		 */
-+		ctx->state = PFM_CTX_ZOMBIE;
-+
-+		PFM_DBG("zombie ctx for [%d]", ctx->task->pid);
-+		/*
-+		 * must check if other thread is using block overflow
-+		 * notification mode. If so make sure it will not block
-+		 * because there will not be any pfm_restart() issued.
-+		 * When the thread notices the ZOMBIE state, it will clean
-+		 * up what is left of the context
-+		 */
-+		if (state == PFM_CTX_MASKED && ctx->flags.block) {
-+			/*
-+			 * force task to wake up from MASKED state
-+			 */
-+			PFM_DBG("waking up [%d]", ctx->task->pid);
-+
-+			complete(&ctx->restart_complete);
-+		}
-+		/*
-+		 * PMU session will be release by monitored task when it notices
-+		 * ZOMBIE state as part of pfm_unload_context()
-+		 */
-+		can_unload = can_free = 0;
-+	}
-+#endif
-+	if (can_unload)
-+		__pfm_unload_context(ctx, &can_release);
-+doit:
-+	spin_unlock_irqrestore(&ctx->lock, flags);
-+
-+#ifdef CONFIG_SMP
-+free_it:
-+#endif
-+	if (can_release)
-+		pfm_session_release(is_system, cpu);
-+
-+	if (can_free)
-+		pfm_free_context(ctx);
-+
-+	return 0;
-+}
-+
-+static int pfm_close(struct inode *inode, struct file *filp)
-+{
-+	struct pfm_context *ctx;
-+
-+	PFM_DBG("called filp=%p", filp);
-+
-+	ctx = filp->private_data;
-+	if (ctx == NULL) {
-+		PFM_ERR("no ctx");
-+		return -EBADF;
-+	}
-+	return __pfm_close(ctx, filp);
-+}
-+
-+static int pfm_no_open(struct inode *irrelevant, struct file *dontcare)
-+{
-+	PFM_DBG("pfm_file_ops");
-+
-+	return -ENXIO;
-+}
-+
-+
-+const struct file_operations pfm_file_ops = {
-+	.llseek = no_llseek,
-+	.read = pfm_read,
-+	.write = pfm_write,
-+	.poll = pfm_poll,
-+	.ioctl = pfm_ioctl,
-+	.open = pfm_no_open, /* special open to disallow open via /proc */
-+	.fasync = pfm_fasync,
-+	.release = pfm_close,
-+	.mmap = pfm_mmap
-+};
-+
-+static int pfmfs_get_sb(struct file_system_type *fs_type,
-+			int flags, const char *dev_name,
-+			void *data, struct vfsmount *mnt)
-+{
-+	return get_sb_pseudo(fs_type, "pfm:", NULL, PFMFS_MAGIC, mnt);
-+}
-+
-+static struct file_system_type pfm_fs_type = {
-+	.name     = "pfmfs",
-+	.get_sb   = pfmfs_get_sb,
-+	.kill_sb  = kill_anon_super,
-+};
-+
-+/*
-+ * pfmfs should _never_ be mounted by userland - too much of security hassle,
-+ * no real gain from having the whole whorehouse mounted. So we don't need
-+ * any operations on the root directory. However, we need a non-trivial
-+ * d_name - pfm: will go nicely and kill the special-casing in procfs.
-+ */
-+static struct vfsmount *pfmfs_mnt;
-+
-+int __init pfm_init_fs(void)
-+{
-+	int err = register_filesystem(&pfm_fs_type);
-+	if (!err) {
-+		pfmfs_mnt = kern_mount(&pfm_fs_type);
-+		err = PTR_ERR(pfmfs_mnt);
-+		if (IS_ERR(pfmfs_mnt))
-+			unregister_filesystem(&pfm_fs_type);
-+		else
-+			err = 0;
-+	}
-+	return err;
-+}
-+
-+int pfm_alloc_fd(struct file **cfile)
-+{
-+	int fd, ret = 0;
-+	struct file *file = NULL;
-+	struct inode * inode;
-+	char name[32];
-+	struct qstr this;
-+
-+	fd = get_unused_fd();
-+	if (fd < 0)
-+		return -ENFILE;
-+
-+	ret = -ENFILE;
-+
-+	file = get_empty_filp();
-+	if (!file)
-+		goto out;
-+
-+	/*
-+	 * allocate a new inode
-+	 */
-+	inode = new_inode(pfmfs_mnt->mnt_sb);
-+	if (!inode)
-+		goto out;
-+
-+	PFM_DBG("new inode ino=%ld @%p", inode->i_ino, inode);
-+
-+	inode->i_sb = pfmfs_mnt->mnt_sb;
-+	inode->i_mode = S_IFCHR|S_IRUGO;
-+	inode->i_uid = current->fsuid;
-+	inode->i_gid = current->fsgid;
-+
-+	sprintf(name, "[%lu]", inode->i_ino);
-+	this.name = name;
-+	this.hash = inode->i_ino;
-+	this.len = strlen(name);
-+
-+	ret = -ENOMEM;
-+
-+	/*
-+	 * allocate a new dcache entry
-+	 */
-+	file->f_dentry = d_alloc(pfmfs_mnt->mnt_sb->s_root, &this);
-+	if (!file->f_dentry)
-+		goto out;
-+
-+	file->f_dentry->d_op = &pfmfs_dentry_operations;
-+
-+	d_add(file->f_dentry, inode);
-+	file->f_vfsmnt = mntget(pfmfs_mnt);
-+	file->f_mapping = inode->i_mapping;
-+
-+	file->f_op = &pfm_file_ops;
-+	file->f_mode = FMODE_READ;
-+	file->f_flags = O_RDONLY;
-+	file->f_pos  = 0;
-+
-+	*cfile = file;
-+
-+	return fd;
-+out:
-+	if (file)
-+		put_filp(file);
-+	put_unused_fd(fd);
-+	return ret;
-+}
-diff --git a/perfmon/perfmon_fmt.c b/perfmon/perfmon_fmt.c
-new file mode 100644
-index 0000000..27c4340
---- /dev/null
-+++ b/perfmon/perfmon_fmt.c
-@@ -0,0 +1,219 @@
-+/*
-+ * perfmon_fmt.c: perfmon2 sampling buffer format management
-+ *
-+ * This file implements the perfmon2 interface which
-+ * provides access to the hardware performance counters
-+ * of the host processor.
-+ *
-+ * The initial version of perfmon.c was written by
-+ * Ganesh Venkitachalam, IBM Corp.
-+ *
-+ * Then it was modified for perfmon-1.x by Stephane Eranian and
-+ * David Mosberger, Hewlett Packard Co.
-+ *
-+ * Version Perfmon-2.x is a complete rewrite of perfmon-1.x
-+ * by Stephane Eranian, Hewlett Packard Co.
-+ *
-+ * Copyright (c) 1999-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *                David Mosberger-Tang <davidm@hpl.hp.com>
-+ *
-+ * More information about perfmon available at:
-+ * 	http://perfmon2.sf.net
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/module.h>
-+#include <linux/perfmon_kern.h>
-+#include "perfmon_priv.h"
-+
-+static __cacheline_aligned_in_smp DEFINE_SPINLOCK(pfm_smpl_fmt_lock);
-+static LIST_HEAD(pfm_smpl_fmt_list);
-+
-+static inline int fmt_is_mod(struct pfm_smpl_fmt *f)
-+{
-+	return !(f->fmt_flags & PFM_FMTFL_IS_BUILTIN);
-+}
-+
-+static struct pfm_smpl_fmt *pfm_find_fmt(char *name)
-+{
-+	struct pfm_smpl_fmt *entry;
-+
-+	list_for_each_entry(entry, &pfm_smpl_fmt_list, fmt_list) {
-+		if (!strcmp(entry->fmt_name, name))
-+			return entry;
-+	}
-+	return NULL;
-+}
-+/*
-+ * find a buffer format based on its name
-+ */
-+struct pfm_smpl_fmt *pfm_smpl_fmt_get(char *name)
-+{
-+	struct pfm_smpl_fmt *fmt;
-+
-+	spin_lock(&pfm_smpl_fmt_lock);
-+
-+	fmt = pfm_find_fmt(name);
-+
-+	/*
-+	 * increase module refcount
-+	 */
-+	if (fmt && fmt_is_mod(fmt) && !try_module_get(fmt->owner))
-+		fmt = NULL;
-+
-+	spin_unlock(&pfm_smpl_fmt_lock);
-+
-+	return fmt;
-+}
-+
-+void pfm_smpl_fmt_put(struct pfm_smpl_fmt *fmt)
-+{
-+	if (fmt == NULL || !fmt_is_mod(fmt))
-+		return;
-+	BUG_ON(fmt->owner == NULL);
-+
-+	spin_lock(&pfm_smpl_fmt_lock);
-+	module_put(fmt->owner);
-+	spin_unlock(&pfm_smpl_fmt_lock);
-+}
-+
-+int pfm_fmt_register(struct pfm_smpl_fmt *fmt)
-+{
-+	int ret = 0;
-+
-+	if (perfmon_disabled) {
-+		PFM_INFO("perfmon disabled, cannot add sampling format");
-+		return -ENOSYS;
-+	}
-+
-+	/* some sanity checks */
-+	if (fmt == NULL) {
-+		PFM_INFO("perfmon: NULL format for register");
-+		return -EINVAL;
-+	}
-+
-+	if (fmt->fmt_name == NULL) {
-+		PFM_INFO("perfmon: format has no name");
-+		return -EINVAL;
-+	}
-+
-+	if (fmt->fmt_qdepth > PFM_MSGS_COUNT) {
-+		PFM_INFO("perfmon: format %s requires %u msg queue depth (max %d)",
-+		       fmt->fmt_name,
-+		       fmt->fmt_qdepth,
-+		       PFM_MSGS_COUNT);
-+		return -EINVAL;
-+	}
-+
-+	/*
-+	 * fmt is missing the initialization of .owner = THIS_MODULE
-+	 * this is only valid when format is compiled as a module
-+	 */
-+	if (fmt->owner == NULL && fmt_is_mod(fmt)) {
-+		PFM_INFO("format %s has no module owner", fmt->fmt_name);
-+		return -EINVAL;
-+	}
-+	/*
-+	 * we need at least a handler
-+	 */
-+	if (fmt->fmt_handler == NULL) {
-+		PFM_INFO("format %s has no handler", fmt->fmt_name);
-+		return -EINVAL;
-+	}
-+
-+	/*
-+	 * format argument size cannot be bigger than PAGE_SIZE
-+	 */
-+	if (fmt->fmt_arg_size > PAGE_SIZE) {
-+		PFM_INFO("format %s arguments too big", fmt->fmt_name);
-+		return -EINVAL;
-+	}
-+
-+	spin_lock(&pfm_smpl_fmt_lock);
-+
-+	/*
-+	 * because of sysfs, we cannot have two formats with the same name
-+	 */
-+	if (pfm_find_fmt(fmt->fmt_name)) {
-+		PFM_INFO("format %s already registered", fmt->fmt_name);
-+		ret = -EBUSY;
-+		goto out;
-+	}
-+
-+	ret = pfm_sysfs_add_fmt(fmt);
-+	if (ret) {
-+		PFM_INFO("sysfs cannot add format entry for %s", fmt->fmt_name);
-+		goto out;
-+	}
-+
-+	list_add(&fmt->fmt_list, &pfm_smpl_fmt_list);
-+
-+	PFM_INFO("added sampling format %s", fmt->fmt_name);
-+out:
-+	spin_unlock(&pfm_smpl_fmt_lock);
-+
-+	return ret;
-+}
-+EXPORT_SYMBOL(pfm_fmt_register);
-+
-+int pfm_fmt_unregister(struct pfm_smpl_fmt *fmt)
-+{
-+	struct pfm_smpl_fmt *fmt2;
-+	int ret = 0;
-+
-+	if (!fmt || !fmt->fmt_name) {
-+		PFM_DBG("invalid fmt");
-+		return -EINVAL;
-+	}
-+
-+	spin_lock(&pfm_smpl_fmt_lock);
-+
-+	fmt2 = pfm_find_fmt(fmt->fmt_name);
-+	if (!fmt) {
-+		PFM_INFO("unregister failed, format not registered");
-+		ret = -EINVAL;
-+		goto out;
-+	}
-+	list_del_init(&fmt->fmt_list);
-+
-+	pfm_sysfs_remove_fmt(fmt);
-+
-+	PFM_INFO("removed sampling format: %s", fmt->fmt_name);
-+
-+out:
-+	spin_unlock(&pfm_smpl_fmt_lock);
-+	return ret;
-+
-+}
-+EXPORT_SYMBOL(pfm_fmt_unregister);
-+
-+/*
-+ * we defer adding the builtin formats to /sys/kernel/perfmon/formats
-+ * until after the pfm sysfs subsystem is initialized. This function
-+ * is called from pfm_init_sysfs()
-+ */
-+void __init pfm_sysfs_builtin_fmt_add(void)
-+{
-+	struct pfm_smpl_fmt *entry;
-+
-+	/*
-+	 * locking not needed, kernel not fully booted
-+	 * when called
-+	 */
-+	list_for_each_entry(entry, &pfm_smpl_fmt_list, fmt_list) {
-+		pfm_sysfs_add_fmt(entry);
-+	}
-+}
-diff --git a/perfmon/perfmon_hotplug.c b/perfmon/perfmon_hotplug.c
-new file mode 100644
-index 0000000..eaaba81
---- /dev/null
-+++ b/perfmon/perfmon_hotplug.c
-@@ -0,0 +1,151 @@
-+/*
-+ * perfmon_hotplug.c: handling of CPU hotplug
-+ *
-+ * The initial version of perfmon.c was written by
-+ * Ganesh Venkitachalam, IBM Corp.
-+ *
-+ * Then it was modified for perfmon-1.x by Stephane Eranian and
-+ * David Mosberger, Hewlett Packard Co.
-+ *
-+ * Version Perfmon-2.x is a complete rewrite of perfmon-1.x
-+ * by Stephane Eranian, Hewlett Packard Co.
-+ *
-+ * Copyright (c) 1999-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *                David Mosberger-Tang <davidm@hpl.hp.com>
-+ *
-+ * More information about perfmon available at:
-+ * 	http://perfmon2.sf.net
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/kernel.h>
-+#include <linux/perfmon_kern.h>
-+#include <linux/cpu.h>
-+#include "perfmon_priv.h"
-+
-+#ifndef CONFIG_HOTPLUG_CPU
-+void pfm_cpu_disable(void)
-+{}
-+
-+int __init pfm_init_hotplug(void)
-+{
-+	return 0;
-+}
-+#else /* CONFIG_HOTPLUG_CPU */
-+/*
-+ * CPU hotplug event nofication callback
-+ *
-+ * We use the callback to do manage the sysfs interface.
-+ * Note that the actual shutdown of monitoring on the CPU
-+ * is done in pfm_cpu_disable(), see comments there for more
-+ * information.
-+ */
-+static int pfm_cpu_notify(struct notifier_block *nfb,
-+			  unsigned long action, void *hcpu)
-+{
-+	unsigned int cpu = (unsigned long)hcpu;
-+	int ret = NOTIFY_OK;
-+
-+	pfm_pmu_conf_get(0);
-+
-+	switch (action) {
-+	case CPU_ONLINE:
-+		pfm_debugfs_add_cpu(cpu);
-+		PFM_INFO("CPU%d is online", cpu);
-+		break;
-+	case CPU_UP_PREPARE:
-+		PFM_INFO("CPU%d prepare online", cpu);
-+		break;
-+	case CPU_UP_CANCELED:
-+		pfm_debugfs_del_cpu(cpu);
-+		PFM_INFO("CPU%d is up canceled", cpu);
-+		break;
-+	case CPU_DOWN_PREPARE:
-+		PFM_INFO("CPU%d prepare offline", cpu);
-+		break;
-+	case CPU_DOWN_FAILED:
-+		PFM_INFO("CPU%d is down failed", cpu);
-+		break;
-+	case CPU_DEAD:
-+		pfm_debugfs_del_cpu(cpu);
-+		PFM_INFO("CPU%d is offline", cpu);
-+		break;
-+	}
-+	pfm_pmu_conf_put();
-+	return ret;
-+}
-+
-+/*
-+ * called from cpu_disable() to detach the perfmon context
-+ * from the CPU going down.
-+ *
-+ * We cannot use the cpu hotplug notifier because we MUST run
-+ * on the CPU that is going down to save the PMU state
-+ */
-+void pfm_cpu_disable(void)
-+{
-+	struct pfm_context *ctx;
-+	unsigned long flags;
-+	int is_system, release_info = 0;
-+	u32 cpu;
-+	int r;
-+
-+	ctx = __get_cpu_var(pmu_ctx);
-+	if (ctx == NULL)
-+		return;
-+
-+	is_system = ctx->flags.system;
-+	cpu = ctx->cpu;
-+
-+	/*
-+	 * context is LOADED or MASKED
-+	 *
-+	 * we unload from CPU. That stops monitoring and does
-+	 * all the bookeeping of saving values and updating duration
-+	 */
-+	spin_lock_irqsave(&ctx->lock, flags);
-+	if (is_system)
-+		__pfm_unload_context(ctx, &release_info);
-+	spin_unlock_irqrestore(&ctx->lock, flags);
-+
-+	/*
-+	 * cancel timer
-+	 */
-+	if (release_info & 0x2) {
-+		r = hrtimer_cancel(&__get_cpu_var(pfm_hrtimer));
-+		PFM_DBG("timeout cancel=%d", r);
-+	}
-+
-+	if (release_info & 0x1)
-+		pfm_session_release(is_system, cpu);
-+}
-+
-+static struct notifier_block pfm_cpu_notifier = {
-+	.notifier_call = pfm_cpu_notify
-+};
-+
-+int __init pfm_init_hotplug(void)
-+{
-+	int ret = 0;
-+	/*
-+	 * register CPU hotplug event notifier
-+	 */
-+	ret = register_cpu_notifier(&pfm_cpu_notifier);
-+	if (!ret)
-+		PFM_LOG("CPU hotplug support enabled");
-+	return ret;
-+}
-+#endif /* CONFIG_HOTPLUG_CPU */
-diff --git a/perfmon/perfmon_init.c b/perfmon/perfmon_init.c
-new file mode 100644
-index 0000000..bbb6e4d
---- /dev/null
-+++ b/perfmon/perfmon_init.c
-@@ -0,0 +1,131 @@
-+/*
-+ * perfmon.c: perfmon2 global initialization functions
-+ *
-+ * This file implements the perfmon2 interface which
-+ * provides access to the hardware performance counters
-+ * of the host processor.
-+ *
-+ *
-+ * The initial version of perfmon.c was written by
-+ * Ganesh Venkitachalam, IBM Corp.
-+ *
-+ * Then it was modified for perfmon-1.x by Stephane Eranian and
-+ * David Mosberger, Hewlett Packard Co.
-+ *
-+ * Version Perfmon-2.x is a complete rewrite of perfmon-1.x
-+ * by Stephane Eranian, Hewlett Packard Co.
-+ *
-+ * Copyright (c) 1999-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *                David Mosberger-Tang <davidm@hpl.hp.com>
-+ *
-+ * More information about perfmon available at:
-+ * 	http://perfmon2.sf.net
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/kernel.h>
-+#include <linux/perfmon_kern.h>
-+#include "perfmon_priv.h"
-+
-+/*
-+ * external variables
-+ */
-+DEFINE_PER_CPU(struct task_struct *, pmu_owner);
-+DEFINE_PER_CPU(struct pfm_context  *, pmu_ctx);
-+DEFINE_PER_CPU(u64, pmu_activation_number);
-+DEFINE_PER_CPU(struct pfm_stats, pfm_stats);
-+DEFINE_PER_CPU(struct hrtimer, pfm_hrtimer);
-+
-+
-+int perfmon_disabled;	/* >0 if perfmon is disabled */
-+
-+/*
-+ * called from cpu_init() and pfm_pmu_register()
-+ */
-+void __pfm_init_percpu(void *dummy)
-+{
-+	struct hrtimer *h;
-+
-+	h = &__get_cpu_var(pfm_hrtimer);
-+
-+	pfm_arch_init_percpu();
-+
-+	/*
-+	 * initialize per-cpu high res timer
-+	 */
-+	hrtimer_init(h, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
-+#ifdef CONFIG_HIGH_RES_TIMERS
-+	/*
-+	 * avoid potential deadlock on the runqueue lock
-+	 * during context switch when multiplexing. Situation
-+	 * arises on architectures which run switch_to() with
-+	 * the runqueue lock held, e.g., x86. On others, e.g.,
-+	 * IA-64, the problem does not exist.
-+	 * Setting the callback mode to HRTIMER_CB_IRQSAFE_UNOCKED
-+	 * such that the callback routine is only called on hardirq
-+	 * context not on softirq, thus the context switch will not
-+	 * end up trying to wakeup the softirqd
-+	 */
-+	h->cb_mode = HRTIMER_CB_IRQSAFE_UNLOCKED;
-+#endif
-+	h->function = pfm_handle_switch_timeout;
-+}
-+
-+/*
-+ * global initialization routine, executed only once
-+ */
-+int __init pfm_init(void)
-+{
-+	PFM_LOG("version %u.%u", PFM_VERSION_MAJ, PFM_VERSION_MIN);
-+
-+	if (pfm_init_ctx())
-+		goto error_disable;
-+
-+
-+	if (pfm_init_sets())
-+		goto error_disable;
-+
-+	if (pfm_init_fs())
-+		goto error_disable;
-+
-+	if (pfm_init_sysfs())
-+		goto error_disable;
-+
-+	/* not critical, so no error checking */
-+	pfm_init_debugfs();
-+
-+	/*
-+	 * one time, arch-specific global initialization
-+	 */
-+	if (pfm_arch_init())
-+		goto error_disable;
-+
-+	if (pfm_init_hotplug())
-+		goto error_disable;
-+	return 0;
-+
-+error_disable:
-+	PFM_ERR("perfmon is disabled due to initialization error");
-+	perfmon_disabled = 1;
-+	return -1;
-+}
-+
-+/*
-+ * must use subsys_initcall() to ensure that the perfmon2 core
-+ * is initialized before any PMU description module when they are
-+ * compiled in.
-+ */
-+subsys_initcall(pfm_init);
-diff --git a/perfmon/perfmon_intr.c b/perfmon/perfmon_intr.c
-new file mode 100644
-index 0000000..c5e3cda
---- /dev/null
-+++ b/perfmon/perfmon_intr.c
-@@ -0,0 +1,648 @@
-+/*
-+ * perfmon_intr.c: perfmon2 interrupt handling
-+ *
-+ * This file implements the perfmon2 interface which
-+ * provides access to the hardware performance counters
-+ * of the host processor.
-+ *
-+ * The initial version of perfmon.c was written by
-+ * Ganesh Venkitachalam, IBM Corp.
-+ *
-+ * Then it was modified for perfmon-1.x by Stephane Eranian and
-+ * David Mosberger, Hewlett Packard Co.
-+ *
-+ * Version Perfmon-2.x is a complete rewrite of perfmon-1.x
-+ * by Stephane Eranian, Hewlett Packard Co.
-+ *
-+ * Copyright (c) 1999-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *                David Mosberger-Tang <davidm@hpl.hp.com>
-+ *
-+ * More information about perfmon available at:
-+ * 	http://perfmon2.sf.net
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/kernel.h>
-+#include <linux/module.h>
-+#include <linux/perfmon_kern.h>
-+#include "perfmon_priv.h"
-+
-+/**
-+ * pfm_intr_process_64bit_ovfls - handle 64-bit counter emulation
-+ * @ctx: context to operate on
-+ * @set: set to operate on
-+ *
-+ * The function returns the number of 64-bit overflows detected.
-+ *
-+ * 64-bit software pmds are updated for overflowed pmd registers
-+ * the set->reset_pmds is updated to the list of pmds to reset
-+ *
-+ * In any case, set->npend_ovfls is cleared
-+ */
-+static u16 pfm_intr_process_64bit_ovfls(struct pfm_context *ctx,
-+					struct pfm_event_set *set,
-+					u32 *ovfl_ctrl)
-+{
-+	u16 i, num_ovfls, max_pmd, max_intr;
-+	u16 num_64b_ovfls, has_ovfl_sw, must_switch;
-+	u64 ovfl_thres, old_val, new_val, ovfl_mask;
-+
-+	num_64b_ovfls = must_switch = 0;
-+
-+	ovfl_mask = pfm_pmu_conf->ovfl_mask;
-+	max_pmd = ctx->regs.max_pmd;
-+	max_intr = ctx->regs.max_intr_pmd;
-+
-+	num_ovfls = set->npend_ovfls;
-+	has_ovfl_sw = set->flags & PFM_SETFL_OVFL_SWITCH;
-+
-+	bitmap_zero(cast_ulp(set->reset_pmds), max_pmd);
-+
-+	for (i = ctx->regs.first_intr_pmd; num_ovfls; i++) {
-+		/*
-+		 * skip pmd which did not overflow
-+		 */
-+		if (!test_bit(i, cast_ulp(set->povfl_pmds)))
-+			continue;
-+
-+		num_ovfls--;
-+
-+		/*
-+		 * Update software value for counters ONLY
-+		 *
-+		 * Note that the pmd is not necessarily 0 at this point as
-+		 * qualified events may have happened before the PMU was
-+		 * frozen. The residual count is not taken into consideration
-+		 * here but will be with any read of the pmd
-+		 */
-+		ovfl_thres = set->pmds[i].ovflsw_thres;
-+
-+		if (likely(test_bit(i, cast_ulp(ctx->regs.cnt_pmds)))) {
-+			old_val = new_val = set->pmds[i].value;
-+			new_val += 1 + ovfl_mask;
-+			set->pmds[i].value = new_val;
-+		}  else {
-+			/*
-+			 * for non counters which interrupt, e.g., AMD IBS,
-+			 * we consider this equivalent to a 64-bit counter
-+			 * overflow.
-+			 */
-+			old_val = 1; new_val = 0;
-+		}
-+
-+		/*
-+		 * check for 64-bit overflow condition
-+		 */
-+		if (likely(old_val > new_val)) {
-+			num_64b_ovfls++;
-+			if (has_ovfl_sw && ovfl_thres > 0) {
-+				if (ovfl_thres == 1)
-+					must_switch = 1;
-+				set->pmds[i].ovflsw_thres = ovfl_thres - 1;
-+			}
-+
-+			/*
-+			 * what to reset because of this overflow
-+			 * - the overflowed register
-+			 * - its reset_smpls
-+			 */
-+			__set_bit(i, cast_ulp(set->reset_pmds));
-+
-+			bitmap_or(cast_ulp(set->reset_pmds),
-+				  cast_ulp(set->reset_pmds),
-+				  cast_ulp(set->pmds[i].reset_pmds),
-+				  max_pmd);
-+		} else {
-+			/*
-+			 * only keep track of 64-bit overflows or
-+			 * assimilated
-+			 */
-+			__clear_bit(i, cast_ulp(set->povfl_pmds));
-+
-+			/*
-+			 * on some PMU, it may be necessary to re-arm the PMD
-+			 */
-+			pfm_arch_ovfl_reset_pmd(ctx, i);
-+		}
-+
-+		PFM_DBG_ovfl("ovfl=%s pmd%u new=0x%llx old=0x%llx "
-+			     "hw_pmd=0x%llx o_pmds=0x%llx must_switch=%u "
-+			     "o_thres=%llu o_thres_ref=%llu",
-+			     old_val > new_val ? "64-bit" : "HW",
-+			     i,
-+			     (unsigned long long)new_val,
-+			     (unsigned long long)old_val,
-+			     (unsigned long long)pfm_read_pmd(ctx, i),
-+			     (unsigned long long)set->povfl_pmds[0],
-+			     must_switch,
-+			     (unsigned long long)set->pmds[i].ovflsw_thres,
-+			     (unsigned long long)set->pmds[i].ovflsw_ref_thres);
-+	}
-+	/*
-+	 * update public bitmask of 64-bit overflowed pmds
-+	 */
-+	if (num_64b_ovfls)
-+		bitmap_copy(cast_ulp(set->ovfl_pmds), cast_ulp(set->povfl_pmds),
-+			    max_intr);
-+
-+	if (must_switch)
-+		*ovfl_ctrl |= PFM_OVFL_CTRL_SWITCH;
-+
-+	/*
-+	 * mark the overflows as consumed
-+	 */
-+	set->npend_ovfls = 0;
-+	bitmap_zero(cast_ulp(set->povfl_pmds), max_intr);
-+
-+	return num_64b_ovfls;
-+}
-+
-+/**
-+ * pfm_intr_get_smpl_pmds_values - copy 64-bit pmd values for sampling format
-+ * @ctx: context to work on
-+ * @set: current event set
-+ * @arg: overflow arg to be passed to format
-+ * @smpl_pmds: list of PMDs of interest for the overflowed register
-+ *
-+ * build an array of 46-bit PMD values based on smpl_pmds. Values are
-+ * stored in increasing order of the PMD indexes
-+ */
-+static void pfm_intr_get_smpl_pmds_values(struct pfm_context *ctx,
-+					  struct pfm_event_set *set,
-+					  struct pfm_ovfl_arg *arg,
-+					  u64 *smpl_pmds)
-+{
-+	u16 j, k, max_pmd;
-+	u64 new_val, ovfl_mask;
-+	u64 *cnt_pmds;
-+
-+	cnt_pmds = ctx->regs.cnt_pmds;
-+	max_pmd = ctx->regs.max_pmd;
-+	ovfl_mask = pfm_pmu_conf->ovfl_mask;
-+
-+	for (j = k = 0; j < max_pmd; j++) {
-+
-+		if (!test_bit(j, cast_ulp(smpl_pmds)))
-+			continue;
-+
-+		new_val = pfm_read_pmd(ctx, j);
-+
-+		/* for counters, build 64-bit value */
-+		if (test_bit(j, cast_ulp(cnt_pmds)))
-+			new_val = (set->pmds[j].value & ~ovfl_mask)
-+				| (new_val & ovfl_mask);
-+
-+		arg->smpl_pmds_values[k++] = new_val;
-+
-+		PFM_DBG_ovfl("s_pmd_val[%u]=pmd%u=0x%llx", k, j,
-+			     (unsigned long long)new_val);
-+	}
-+	arg->num_smpl_pmds = k;
-+}
-+
-+/**
-+ * pfm_intr_process_smpl_fmt -- handle sampling format callback
-+ * @ctx: context to work on
-+ * @set: current event set
-+ * @ip: interrupted instruction pointer
-+ * @now: timestamp
-+ * @num_ovfls: number of 64-bit overflows
-+ * @ovfl_ctrl: set of controls for interrupt handler tail processing
-+ * @regs: register state
-+ *
-+ * Prepare argument (ovfl_arg) to be passed to sampling format callback, then
-+ * invoke the callback (fmt_handler)
-+ */
-+static int pfm_intr_process_smpl_fmt(struct pfm_context *ctx,
-+				    struct pfm_event_set *set,
-+				    unsigned long ip,
-+				    u64 now,
-+				    u64 num_ovfls,
-+				    u32 *ovfl_ctrl,
-+				    struct pt_regs *regs)
-+{
-+	struct pfm_ovfl_arg *ovfl_arg;
-+	u64 start_cycles, end_cycles;
-+	u16 i, max_pmd;
-+	int ret = 0;
-+
-+	ovfl_arg = &ctx->ovfl_arg;
-+
-+	ovfl_arg->active_set = set->id;
-+	max_pmd = ctx->regs.max_pmd;
-+
-+	/*
-+	 * first_intr_pmd: first PMD which can generate PMU interrupts
-+	 */
-+	for (i = ctx->regs.first_intr_pmd; num_ovfls; i++) {
-+		/*
-+		 * skip pmd which did not have 64-bit overflows
-+		 */
-+		if (!test_bit(i, cast_ulp(set->ovfl_pmds)))
-+			continue;
-+
-+		num_ovfls--;
-+
-+		/*
-+		 * prepare argument to fmt_handler
-+		 */
-+		ovfl_arg->ovfl_pmd = i;
-+		ovfl_arg->ovfl_ctrl = 0;
-+
-+		ovfl_arg->pmd_last_reset = set->pmds[i].lval;
-+		ovfl_arg->pmd_eventid = set->pmds[i].eventid;
-+		ovfl_arg->num_smpl_pmds = 0;
-+
-+		/*
-+		 * copy values of pmds of interest, if any
-+		 * Sampling format may use them
-+		 * We do not initialize the unused smpl_pmds_values
-+		 */
-+		if (!bitmap_empty(cast_ulp(set->pmds[i].smpl_pmds), max_pmd))
-+			pfm_intr_get_smpl_pmds_values(ctx, set, ovfl_arg,
-+						      set->pmds[i].smpl_pmds);
-+
-+		pfm_stats_inc(fmt_handler_calls);
-+
-+		/*
-+		 * call format record (handler) routine
-+		 */
-+		start_cycles = sched_clock();
-+		ret = (*ctx->smpl_fmt->fmt_handler)(ctx, ip, now, regs);
-+		end_cycles = sched_clock();
-+
-+		/*
-+		 * The reset_pmds mask is constructed automatically
-+		 * on overflow. When the actual reset takes place
-+		 * depends on the masking, switch and notification
-+		 * status. It may be deferred until pfm_restart().
-+		 */
-+		*ovfl_ctrl |= ovfl_arg->ovfl_ctrl;
-+
-+		pfm_stats_add(fmt_handler_ns, end_cycles - start_cycles);
-+	}
-+	/*
-+	 * when the format cannot handle the rest of the overflow, we abort
-+	 */
-+	if (ret)
-+		PFM_DBG_ovfl("handler aborted at PMD%u ret=%d", i, ret);
-+	return ret;
-+}
-+/**
-+ * pfm_overflow_handler - main overflow processing routine.
-+ * @ctx: context to work on (always current context)
-+ * @set: current event set
-+ * @ip: interrupt instruction pointer
-+ * @regs: machine state
-+ *
-+ * set->num_ovfl_pmds is 0 when returning from this function even though
-+ * set->ovfl_pmds[] may have bits set. When leaving set->num_ovfl_pmds
-+ * must never be used to determine if there was a pending overflow.
-+ */
-+static void pfm_overflow_handler(struct pfm_context *ctx,
-+				 struct pfm_event_set *set,
-+				 unsigned long ip,
-+				 struct pt_regs *regs)
-+{
-+	struct pfm_event_set *set_orig;
-+	u64 now;
-+	u32 ovfl_ctrl;
-+	u16 max_intr, max_pmd;
-+	u16 num_ovfls;
-+	int ret, has_notify;
-+
-+	/*
-+	 * take timestamp
-+	 */
-+	now = sched_clock();
-+
-+	max_pmd = ctx->regs.max_pmd;
-+	max_intr = ctx->regs.max_intr_pmd;
-+
-+	set_orig = set;
-+	ovfl_ctrl = 0;
-+
-+	/*
-+	 * skip ZOMBIE case
-+	 */
-+	if (unlikely(ctx->state == PFM_CTX_ZOMBIE))
-+		goto stop_monitoring;
-+
-+	PFM_DBG_ovfl("intr_pmds=0x%llx npend=%u ip=%p, blocking=%d "
-+		     "u_pmds=0x%llx use_fmt=%u",
-+		     (unsigned long long)set->povfl_pmds[0],
-+		     set->npend_ovfls,
-+		     (void *)ip,
-+		     ctx->flags.block,
-+		     (unsigned long long)set->used_pmds[0],
-+		     !!ctx->smpl_fmt);
-+
-+	/*
-+	 * return number of 64-bit overflows
-+	 */
-+	num_ovfls = pfm_intr_process_64bit_ovfls(ctx, set, &ovfl_ctrl);
-+
-+	/*
-+	 * there were no 64-bit overflows
-+	 * nothing else to do
-+	 */
-+	if (!num_ovfls)
-+		return;
-+
-+	/*
-+	 * tmp_ovfl_notify = ovfl_pmds & ovfl_notify
-+	 * with:
-+	 *   - ovfl_pmds: last 64-bit overflowed pmds
-+	 *   - ovfl_notify: notify on overflow registers
-+	 */
-+	bitmap_and(cast_ulp(ctx->tmp_ovfl_notify),
-+		   cast_ulp(set->ovfl_pmds),
-+		   cast_ulp(set->ovfl_notify),
-+		   max_intr);
-+
-+	has_notify = !bitmap_empty(cast_ulp(ctx->tmp_ovfl_notify), max_intr);
-+
-+	/*
-+	 * check for sampling format and invoke fmt_handler
-+	 */
-+	if (likely(ctx->smpl_fmt)) {
-+		pfm_intr_process_smpl_fmt(ctx, set, ip, now, num_ovfls,
-+					  &ovfl_ctrl, regs);
-+	} else {
-+		/*
-+		 * When no sampling format is used, the default
-+		 * is:
-+		 * 	- mask monitoring if not switching
-+		 * 	- notify user if requested
-+		 *
-+		 * If notification is not requested, monitoring is masked
-+		 * and overflowed registers are not reset (saturation).
-+		 * This mimics the behavior of the default sampling format.
-+		 */
-+		ovfl_ctrl |= PFM_OVFL_CTRL_NOTIFY;
-+		if (has_notify || !(ovfl_ctrl & PFM_OVFL_CTRL_SWITCH))
-+			ovfl_ctrl |= PFM_OVFL_CTRL_MASK;
-+	}
-+
-+	PFM_DBG_ovfl("set%u o_notify=0x%llx o_pmds=0x%llx "
-+		     "r_pmds=0x%llx ovfl_ctrl=0x%x",
-+		     set->id,
-+		     (unsigned long long)ctx->tmp_ovfl_notify[0],
-+		     (unsigned long long)set->ovfl_pmds[0],
-+		     (unsigned long long)set->reset_pmds[0],
-+		     ovfl_ctrl);
-+
-+	/*
-+	 * execute the various controls
-+	 *        ORDER MATTERS
-+	 */
-+
-+
-+	/*
-+	 * mask monitoring
-+	 */
-+	if (ovfl_ctrl & PFM_OVFL_CTRL_MASK) {
-+		pfm_mask_monitoring(ctx, set);
-+		/*
-+		 * when masking, reset is deferred until
-+		 * pfm_restart()
-+		 */
-+		ovfl_ctrl &= ~PFM_OVFL_CTRL_RESET;
-+
-+		/*
-+		 * when masking, switching is deferred until
-+		 * pfm_restart and we need to remember it
-+		 */
-+		if (ovfl_ctrl & PFM_OVFL_CTRL_SWITCH) {
-+			set->priv_flags |= PFM_SETFL_PRIV_SWITCH;
-+			ovfl_ctrl &= ~PFM_OVFL_CTRL_SWITCH;
-+		}
-+	}
-+
-+	/*
-+	 * switch event set
-+	 */
-+	if (ovfl_ctrl & PFM_OVFL_CTRL_SWITCH) {
-+		pfm_switch_sets_from_intr(ctx);
-+		/* update view of active set */
-+		set = ctx->active_set;
-+	}
-+	/*
-+	 * send overflow notification
-+	 *
-+	 * only necessary if at least one overflowed
-+	 * register had the notify flag set
-+	 */
-+	if (has_notify && (ovfl_ctrl & PFM_OVFL_CTRL_NOTIFY)) {
-+		/*
-+		 * block on notify, not on masking
-+		 */
-+		if (ctx->flags.block)
-+			pfm_post_work(current, ctx, PFM_WORK_BLOCK);
-+
-+		/*
-+		 * send notification and passed original set id
-+		 * if error, queue full, for instance, then default
-+		 * to masking monitoring, i.e., saturate
-+		 */
-+		ret = pfm_ovfl_notify(ctx, set_orig, ip);
-+		if (unlikely(ret)) {
-+			if (ctx->state == PFM_CTX_LOADED) {
-+				pfm_mask_monitoring(ctx, set);
-+				ovfl_ctrl &= ~PFM_OVFL_CTRL_RESET;
-+			}
-+		} else {
-+			ctx->flags.can_restart++;
-+			PFM_DBG_ovfl("can_restart=%u", ctx->flags.can_restart);
-+		}
-+	}
-+
-+	/*
-+	 * reset overflowed registers
-+	 */
-+	if (ovfl_ctrl & PFM_OVFL_CTRL_RESET) {
-+		u16 nn;
-+		nn = bitmap_weight(cast_ulp(set->reset_pmds), max_pmd);
-+		if (nn)
-+			pfm_reset_pmds(ctx, set, nn, PFM_PMD_RESET_SHORT);
-+	}
-+	return;
-+
-+stop_monitoring:
-+	/*
-+	 * Does not happen for a system-wide context nor for a
-+	 * self-monitored context. We cannot attach to kernel-only
-+	 * thread, thus it is safe to set TIF bits, i.e., the thread
-+	 * will eventually leave the kernel or die and either we will
-+	 * catch the context and clean it up in pfm_handler_work() or
-+	 * pfm_exit_thread().
-+	 *
-+	 * Mask until we get to pfm_handle_work()
-+	 */
-+	pfm_mask_monitoring(ctx, set);
-+
-+	PFM_DBG_ovfl("ctx is zombie, converted to spurious");
-+	pfm_post_work(current, ctx, PFM_WORK_ZOMBIE);
-+}
-+
-+/**
-+ * __pfm_interrupt_handler - 1st level interrupt handler
-+ * @ip: interrupted instruction pointer
-+ * @regs: machine state
-+ *
-+ * Function is static because we use a wrapper to easily capture timing infos.
-+ *
-+ *
-+ * Context locking necessary to avoid concurrent accesses from other CPUs
-+ * 	- For per-thread, we must prevent pfm_restart() which works when
-+ * 	  context is LOADED or MASKED
-+ */
-+static void __pfm_interrupt_handler(unsigned long ip, struct pt_regs *regs)
-+{
-+	struct task_struct *task;
-+	struct pfm_context *ctx;
-+	struct pfm_event_set *set;
-+
-+
-+	task = __get_cpu_var(pmu_owner);
-+	ctx = __get_cpu_var(pmu_ctx);
-+
-+	/*
-+	 * verify if there is a context on this CPU
-+	 */
-+	if (unlikely(ctx == NULL)) {
-+		PFM_DBG_ovfl("no ctx");
-+		goto spurious;
-+	}
-+
-+	/*
-+	 * we need to lock context because it could be accessed
-+	 * from another CPU. Depending on the priority level of
-+	 * the PMU interrupt or the arch, it may be necessary to
-+	 * mask interrupts alltogether to avoid race condition with
-+	 * the timer interrupt in case of time-based set switching,
-+	 * for instance.
-+	 */
-+	spin_lock(&ctx->lock);
-+
-+	set = ctx->active_set;
-+
-+	/*
-+	 * For SMP per-thread, it is not possible to have
-+	 * owner != NULL && task != current.
-+	 *
-+	 * For UP per-thread, because of lazy save, it
-+	 * is possible to receive an interrupt in another task
-+	 * which is not using the PMU. This means
-+	 * that the interrupt was in-flight at the
-+	 * time of pfm_ctxswout_thread(). In that
-+	 * case, it will be replayed when the task
-+	 * is scheduled again. Hence we convert to spurious.
-+	 *
-+	 * The basic rule is that an overflow is always
-+	 * processed in the context of the task that
-+	 * generated it for all per-thread contexts.
-+	 *
-+	 * for system-wide, task is always NULL
-+	 */
-+#ifndef CONFIG_SMP
-+	if (unlikely((task && current->pfm_context != ctx))) {
-+		PFM_DBG_ovfl("spurious: not owned by current task");
-+		goto spurious;
-+	}
-+#endif
-+	if (unlikely(ctx->state == PFM_CTX_MASKED)) {
-+		PFM_DBG_ovfl("spurious: monitoring masked");
-+		goto spurious;
-+	}
-+
-+	/*
-+	 * check that monitoring is active, otherwise convert
-+	 * to spurious
-+	 */
-+	if (unlikely(!pfm_arch_is_active(ctx))) {
-+		PFM_DBG_ovfl("spurious: monitoring non active");
-+		goto spurious;
-+	}
-+
-+	/*
-+	 * freeze PMU and collect overflowed PMD registers
-+	 * into set->povfl_pmds. Number of overflowed PMDs
-+	 * reported in set->npend_ovfls
-+	 */
-+	pfm_arch_intr_freeze_pmu(ctx, set);
-+
-+	/*
-+	 * no overflow detected, interrupt may have come
-+	 * from the previous thread running on this CPU
-+	 */
-+	if (unlikely(!set->npend_ovfls)) {
-+		PFM_DBG_ovfl("no npend_ovfls");
-+		goto spurious;
-+	}
-+
-+	pfm_stats_inc(ovfl_intr_regular_count);
-+
-+	/*
-+	 * invoke actual handler
-+	 */
-+	pfm_overflow_handler(ctx, set, ip, regs);
-+
-+	/*
-+	 * unfreeze PMU, monitoring may not actual be restarted
-+	 * if context is MASKED
-+	 */
-+	pfm_arch_intr_unfreeze_pmu(ctx);
-+
-+	spin_unlock(&ctx->lock);
-+
-+	return;
-+
-+spurious:
-+	/* ctx may be NULL */
-+	pfm_arch_intr_unfreeze_pmu(ctx);
-+	if (ctx)
-+		spin_unlock(&ctx->lock);
-+
-+	pfm_stats_inc(ovfl_intr_spurious_count);
-+}
-+
-+
-+/**
-+ * pfm_interrupt_handler - 1st level interrupt handler
-+ * @ip: interrupt instruction pointer
-+ * @regs: machine state
-+ *
-+ * Function called from the low-level assembly code or arch-specific perfmon
-+ * code. Simple wrapper used for timing purpose. Actual work done in
-+ * __pfm_overflow_handler()
-+ */
-+void pfm_interrupt_handler(unsigned long ip, struct pt_regs *regs)
-+{
-+	u64 start;
-+
-+	pfm_stats_inc(ovfl_intr_all_count);
-+
-+	BUG_ON(!irqs_disabled());
-+
-+	start = sched_clock();
-+
-+	__pfm_interrupt_handler(ip, regs);
-+
-+	pfm_stats_add(ovfl_intr_ns, sched_clock() - start);
-+}
-+EXPORT_SYMBOL(pfm_interrupt_handler);
-+
-diff --git a/perfmon/perfmon_msg.c b/perfmon/perfmon_msg.c
-new file mode 100644
-index 0000000..b8a1e4c
---- /dev/null
-+++ b/perfmon/perfmon_msg.c
-@@ -0,0 +1,229 @@
-+/*
-+ * perfmon_msg.c: perfmon2 notification message queue management
-+ *
-+ * This file implements the perfmon2 interface which
-+ * provides access to the hardware performance counters
-+ * of the host processor.
-+ *
-+ * The initial version of perfmon.c was written by
-+ * Ganesh Venkitachalam, IBM Corp.
-+ *
-+ * Then it was modified for perfmon-1.x by Stephane Eranian and
-+ * David Mosberger, Hewlett Packard Co.
-+ *
-+ * Version Perfmon-2.x is a complete rewrite of perfmon-1.x
-+ * by Stephane Eranian, Hewlett Packard Co.
-+ *
-+ * Copyright (c) 1999-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *                David Mosberger-Tang <davidm@hpl.hp.com>
-+ *
-+ * More information about perfmon available at:
-+ * 	http://perfmon2.sf.net
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/kernel.h>
-+#include <linux/poll.h>
-+#include <linux/perfmon_kern.h>
-+
-+/**
-+ * pfm_get_new_msg - get a new message slot from the queue
-+ * @ctx: context to operate on
-+ *
-+ * if queue if full NULL is returned
-+ */
-+static union pfarg_msg *pfm_get_new_msg(struct pfm_context *ctx)
-+{
-+	int next;
-+
-+	next = ctx->msgq_head & PFM_MSGQ_MASK;
-+
-+	if ((ctx->msgq_head - ctx->msgq_tail) == PFM_MSGS_COUNT)
-+		return NULL;
-+
-+	/*
-+	 * move to next possible slot
-+	 */
-+	ctx->msgq_head++;
-+
-+	PFM_DBG_ovfl("head=%d tail=%d msg=%d",
-+		ctx->msgq_head & PFM_MSGQ_MASK,
-+		ctx->msgq_tail & PFM_MSGQ_MASK,
-+		next);
-+
-+	return ctx->msgq+next;
-+}
-+
-+/**
-+ * pfm_notify_user - wakeup any thread wiating on msg queue,  post SIGIO
-+ * @ctx: context to operate on
-+ *
-+ * message is already enqueued
-+ */
-+static void pfm_notify_user(struct pfm_context *ctx)
-+{
-+	if (ctx->state == PFM_CTX_ZOMBIE) {
-+		PFM_DBG("no notification, context is zombie");
-+		return;
-+	}
-+
-+	PFM_DBG_ovfl("waking up");
-+
-+	wake_up_interruptible(&ctx->msgq_wait);
-+
-+	/*
-+	 * it is safe to call kill_fasync() from an interrupt
-+	 * handler. kill_fasync()  grabs two RW locks (fasync_lock,
-+	 * tasklist_lock) in read mode. There is conflict only in
-+	 * case the PMU interrupt occurs during a write mode critical
-+	 * section. This cannot happen because for both locks, the
-+	 * write mode is always using interrupt masking (write_lock_irq).
-+	 */
-+	kill_fasync(&ctx->async_queue, SIGIO, POLL_IN);
-+}
-+
-+/**
-+ * pfm_ovfl_notify - send overflow notification
-+ * @ctx: context to operate on
-+ * @set: which set the overflow comes from
-+ * @ip: overflow interrupt instruction address (IIP)
-+ *
-+ * Appends an overflow notification message to context queue.
-+ * call pfm_notify() to wakeup any threads and/or send a signal
-+ *
-+ * Context is locked and interrupts are disabled (no preemption).
-+ */
-+int pfm_ovfl_notify(struct pfm_context *ctx,
-+			struct pfm_event_set *set,
-+			unsigned long ip)
-+{
-+	union pfarg_msg *msg = NULL;
-+	u64 *ovfl_pmds;
-+
-+	if (!ctx->flags.no_msg) {
-+		msg = pfm_get_new_msg(ctx);
-+		if (msg == NULL) {
-+			/*
-+			 * when message queue fills up it is because the user
-+			 * did not extract the message, yet issued
-+			 * pfm_restart(). At this point, we stop sending
-+			 * notification, thus the user will not be able to get
-+			 * new samples when using the default format.
-+			 */
-+			PFM_DBG_ovfl("no more notification msgs");
-+			return -1;
-+		}
-+
-+		msg->pfm_ovfl_msg.msg_type = PFM_MSG_OVFL;
-+		msg->pfm_ovfl_msg.msg_ovfl_pid = current->pid;
-+		msg->pfm_ovfl_msg.msg_active_set = set->id;
-+
-+		ovfl_pmds = msg->pfm_ovfl_msg.msg_ovfl_pmds;
-+
-+		/*
-+		 * copy bitmask of all pmd that interrupted last
-+		 */
-+		bitmap_copy(cast_ulp(ovfl_pmds), cast_ulp(set->ovfl_pmds),
-+			    ctx->regs.max_intr_pmd);
-+
-+		msg->pfm_ovfl_msg.msg_ovfl_cpu = smp_processor_id();
-+		msg->pfm_ovfl_msg.msg_ovfl_tid = current->tgid;
-+		msg->pfm_ovfl_msg.msg_ovfl_ip = ip;
-+
-+		pfm_stats_inc(ovfl_notify_count);
-+	}
-+
-+	PFM_DBG_ovfl("ip=0x%lx o_pmds=0x%llx",
-+		     ip,
-+		     (unsigned long long)set->ovfl_pmds[0]);
-+
-+	pfm_notify_user(ctx);
-+	return 0;
-+}
-+
-+/**
-+ * pfm_end_notify_user - notify of thread termination
-+ * @ctx: context to operate on
-+ *
-+ * In per-thread mode, when not self-monitoring, perfmon
-+ * sends a 'end' notification message when the monitored
-+ * thread where the context is attached is exiting.
-+ *
-+ * This helper message alleviates the need to track the activity
-+ * of the thread/process when it is not directly related, i.e.,
-+ * was attached. In other words, no needto keep the thread
-+ * ptraced.
-+ *
-+ * The context must be locked and interrupts disabled.
-+ */
-+int pfm_end_notify(struct pfm_context *ctx)
-+{
-+	union pfarg_msg *msg;
-+
-+	msg = pfm_get_new_msg(ctx);
-+	if (msg == NULL) {
-+		PFM_ERR("%s no more msgs", __func__);
-+		return -1;
-+	}
-+	/* no leak */
-+	memset(msg, 0, sizeof(*msg));
-+
-+	msg->type = PFM_MSG_END;
-+
-+	PFM_DBG("end msg: msg=%p no_msg=%d",
-+		msg,
-+		ctx->flags.no_msg);
-+
-+	pfm_notify_user(ctx);
-+	return 0;
-+}
-+
-+/**
-+ * pfm_get_next_msg - copy the oldest message from the queue and move tail
-+ * @ctx: context to use
-+ * @m: where to copy the message into
-+ *
-+ * The tail of the queue is moved as a consequence of this call
-+ */
-+void pfm_get_next_msg(struct pfm_context *ctx, union pfarg_msg *m)
-+{
-+	union pfarg_msg *next;
-+
-+	PFM_DBG_ovfl("in head=%d tail=%d",
-+		ctx->msgq_head & PFM_MSGQ_MASK,
-+		ctx->msgq_tail & PFM_MSGQ_MASK);
-+
-+	/*
-+	 * get oldest message
-+	 */
-+	next = ctx->msgq + (ctx->msgq_tail & PFM_MSGQ_MASK);
-+
-+	/*
-+	 * move tail forward
-+	 */
-+	ctx->msgq_tail++;
-+
-+	/*
-+	 * copy message, we cannot simply point to it
-+	 * as it may be re-used before we copy it out
-+	 */
-+	*m = *next;
-+
-+	PFM_DBG_ovfl("out head=%d tail=%d type=%d",
-+		ctx->msgq_head & PFM_MSGQ_MASK,
-+		ctx->msgq_tail & PFM_MSGQ_MASK,
-+		m->type);
-+}
-diff --git a/perfmon/perfmon_pmu.c b/perfmon/perfmon_pmu.c
-new file mode 100644
-index 0000000..df7a9c9
---- /dev/null
-+++ b/perfmon/perfmon_pmu.c
-@@ -0,0 +1,590 @@
-+/*
-+ * perfmon_pmu.c: perfmon2 PMU configuration management
-+ *
-+ * This file implements the perfmon2 interface which
-+ * provides access to the hardware performance counters
-+ * of the host processor.
-+ *
-+ * The initial version of perfmon.c was written by
-+ * Ganesh Venkitachalam, IBM Corp.
-+ *
-+ * Then it was modified for perfmon-1.x by Stephane Eranian and
-+ * David Mosberger, Hewlett Packard Co.
-+ *
-+ * Version Perfmon-2.x is a complete rewrite of perfmon-1.x
-+ * by Stephane Eranian, Hewlett Packard Co.
-+ *
-+ * Copyright (c) 1999-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *                David Mosberger-Tang <davidm@hpl.hp.com>
-+ *
-+ * More information about perfmon available at:
-+ * 	http://perfmon2.sf.net
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/module.h>
-+#include <linux/perfmon_kern.h>
-+#include "perfmon_priv.h"
-+
-+#ifndef CONFIG_MODULE_UNLOAD
-+#define module_refcount(n)	1
-+#endif
-+
-+static __cacheline_aligned_in_smp int request_mod_in_progress;
-+static __cacheline_aligned_in_smp DEFINE_SPINLOCK(pfm_pmu_conf_lock);
-+
-+static __cacheline_aligned_in_smp DEFINE_SPINLOCK(pfm_pmu_acq_lock);
-+static u32 pfm_pmu_acquired;
-+
-+/*
-+ * perfmon core must acces PMU information ONLY through pfm_pmu_conf
-+ * if pfm_pmu_conf is NULL, then no description is registered
-+ */
-+struct pfm_pmu_config	*pfm_pmu_conf;
-+EXPORT_SYMBOL(pfm_pmu_conf);
-+
-+static inline int pmu_is_module(struct pfm_pmu_config *c)
-+{
-+	return !(c->flags & PFM_PMUFL_IS_BUILTIN);
-+}
-+/**
-+ * pfm_pmu_regdesc_init -- initialize regdesc structure from PMU table
-+ * @regs: the regdesc structure to initialize
-+ * @excl_type: the register type(s) to exclude from this regdesc
-+ * @unvail_pmcs: unavailable PMC registers
-+ * @unavail_pmds: unavailable PMD registers
-+ *
-+ * Return:
-+ * 	0 success
-+ * 	errno in case of error
-+ */
-+static int pfm_pmu_regdesc_init(struct pfm_regdesc *regs, int excl_type,
-+				u64 *unavail_pmcs, u64 *unavail_pmds)
-+{
-+	struct pfm_regmap_desc *d;
-+	u16 n, n2, n_counters, i;
-+	int first_intr_pmd = -1, max1, max2, max3;
-+
-+	/*
-+	 * compute the number of implemented PMC from the
-+	 * description table
-+	 */
-+	n = 0;
-+	max1 = max2 = -1;
-+	d = pfm_pmu_conf->pmc_desc;
-+	for (i = 0; i < pfm_pmu_conf->num_pmc_entries;  i++, d++) {
-+		if (!(d->type & PFM_REG_I))
-+			continue;
-+
-+		if (test_bit(i, cast_ulp(unavail_pmcs)))
-+			continue;
-+
-+		if (d->type & excl_type)
-+			continue;
-+
-+		__set_bit(i, cast_ulp(regs->pmcs));
-+
-+		max1 = i;
-+		n++;
-+	}
-+
-+	if (!n) {
-+		PFM_INFO("%s PMU description has no PMC registers",
-+			 pfm_pmu_conf->pmu_name);
-+		return -EINVAL;
-+	}
-+
-+	regs->max_pmc = max1 + 1;
-+	regs->num_pmcs = n;
-+
-+	n = n_counters = n2 = 0;
-+	max1 = max2 = max3 = -1;
-+	d = pfm_pmu_conf->pmd_desc;
-+	for (i = 0; i < pfm_pmu_conf->num_pmd_entries;  i++, d++) {
-+		if (!(d->type & PFM_REG_I))
-+			continue;
-+
-+		if (test_bit(i, cast_ulp(unavail_pmds)))
-+			continue;
-+
-+		if (d->type & excl_type)
-+			continue;
-+
-+		__set_bit(i, cast_ulp(regs->pmds));
-+		max1 = i;
-+		n++;
-+
-+		/*
-+		 * read-write registers
-+		 */
-+		if (!(d->type & PFM_REG_RO)) {
-+			__set_bit(i, cast_ulp(regs->rw_pmds));
-+			max3 = i;
-+			n2++;
-+		}
-+
-+		/*
-+		 * counter registers
-+		 */
-+		if (d->type & PFM_REG_C64) {
-+			__set_bit(i, cast_ulp(regs->cnt_pmds));
-+			n_counters++;
-+		}
-+
-+		/*
-+		 * PMD with intr capabilities
-+		 */
-+		if (d->type & PFM_REG_INTR) {
-+			__set_bit(i, cast_ulp(regs->intr_pmds));
-+			if (first_intr_pmd == -1)
-+				first_intr_pmd = i;
-+			max2 = i;
-+		}
-+	}
-+
-+	if (!n) {
-+		PFM_INFO("%s PMU description has no PMD registers",
-+			 pfm_pmu_conf->pmu_name);
-+		return -EINVAL;
-+	}
-+
-+	regs->max_pmd = max1 + 1;
-+	regs->first_intr_pmd = first_intr_pmd;
-+	regs->max_intr_pmd  = max2 + 1;
-+
-+	regs->num_counters = n_counters;
-+	regs->num_pmds = n;
-+	regs->max_rw_pmd = max3 + 1;
-+	regs->num_rw_pmd = n2;
-+
-+	return 0;
-+}
-+
-+/**
-+ * pfm_pmu_regdesc_init_all -- initialize all regdesc structures
-+ * @una_pmcs : unavailable PMC registers
-+ * @una_pmds : unavailable PMD registers
-+ *
-+ * Return:
-+ * 	0 sucess
-+ * 	errno if error
-+ *
-+ * We maintain 3 regdesc:
-+ * 	regs_all: all available registers
-+ * 	regs_sys: registers available to system-wide contexts only
-+ * 	regs_thr: registers available to per-thread contexts only
-+ */
-+static int pfm_pmu_regdesc_init_all(u64 *una_pmcs, u64 *una_pmds)
-+{
-+	int ret;
-+
-+	memset(&pfm_pmu_conf->regs_all, 0, sizeof(struct pfm_regdesc));
-+	memset(&pfm_pmu_conf->regs_thr, 0, sizeof(struct pfm_regdesc));
-+	memset(&pfm_pmu_conf->regs_sys, 0, sizeof(struct pfm_regdesc));
-+
-+	ret = pfm_pmu_regdesc_init(&pfm_pmu_conf->regs_all,
-+				   0,
-+				   una_pmcs, una_pmds);
-+	if (ret)
-+		return ret;
-+
-+	PFM_DBG("regs_all.pmcs=0x%llx",
-+		(unsigned long long)pfm_pmu_conf->regs_all.pmcs[0]);
-+
-+	ret = pfm_pmu_regdesc_init(&pfm_pmu_conf->regs_thr,
-+				   PFM_REG_SYS,
-+				   una_pmcs, una_pmds);
-+	if (ret)
-+		return ret;
-+	PFM_DBG("regs.thr.pmcs=0x%llx",
-+		(unsigned long long)pfm_pmu_conf->regs_thr.pmcs[0]);
-+
-+	ret = pfm_pmu_regdesc_init(&pfm_pmu_conf->regs_sys,
-+				    PFM_REG_THR,
-+				    una_pmcs, una_pmds);
-+
-+	PFM_DBG("regs_sys.pmcs=0x%llx",
-+		(unsigned long long)pfm_pmu_conf->regs_sys.pmcs[0]);
-+
-+	return ret;
-+}
-+
-+int pfm_pmu_register(struct pfm_pmu_config *cfg)
-+{
-+	u16 i, nspec, nspec_ro, num_pmcs, num_pmds, num_wc = 0;
-+	int type, ret = -EBUSY;
-+
-+	if (perfmon_disabled) {
-+		PFM_INFO("perfmon disabled, cannot add PMU description");
-+		return -ENOSYS;
-+	}
-+
-+	nspec = nspec_ro = num_pmds = num_pmcs = 0;
-+
-+	/* some sanity checks */
-+	if (cfg == NULL || cfg->pmu_name == NULL) {
-+		PFM_INFO("PMU config descriptor is invalid");
-+		return -EINVAL;
-+	}
-+
-+	/* must have a probe */
-+	if (cfg->probe_pmu == NULL) {
-+		PFM_INFO("PMU config has no probe routine");
-+		return -EINVAL;
-+	}
-+
-+	/*
-+	 * execute probe routine before anything else as it
-+	 * may update configuration tables
-+	 */
-+	if ((*cfg->probe_pmu)() == -1) {
-+		PFM_INFO("%s PMU detection failed", cfg->pmu_name);
-+		return -EINVAL;
-+	}
-+
-+	if (!(cfg->flags & PFM_PMUFL_IS_BUILTIN) && cfg->owner == NULL) {
-+		PFM_INFO("PMU config %s is missing owner", cfg->pmu_name);
-+		return -EINVAL;
-+	}
-+
-+	if (!cfg->num_pmd_entries) {
-+		PFM_INFO("%s needs to define num_pmd_entries", cfg->pmu_name);
-+		return -EINVAL;
-+	}
-+
-+	if (!cfg->num_pmc_entries) {
-+		PFM_INFO("%s needs to define num_pmc_entries", cfg->pmu_name);
-+		return -EINVAL;
-+	}
-+
-+	if (!cfg->counter_width) {
-+		PFM_INFO("PMU config %s, zero width counters", cfg->pmu_name);
-+		return -EINVAL;
-+	}
-+
-+	/*
-+	 * REG_RO, REG_V not supported on PMC registers
-+	 */
-+	for (i = 0; i < cfg->num_pmc_entries;  i++) {
-+
-+		type = cfg->pmc_desc[i].type;
-+
-+		if (type & PFM_REG_I)
-+			num_pmcs++;
-+
-+		if (type & PFM_REG_WC)
-+			num_wc++;
-+
-+		if (type & PFM_REG_V) {
-+			PFM_INFO("PFM_REG_V is not supported on "
-+				 "PMCs (PMC%d)", i);
-+			return -EINVAL;
-+		}
-+		if (type & PFM_REG_RO) {
-+			PFM_INFO("PFM_REG_RO meaningless on "
-+				 "PMCs (PMC%u)", i);
-+			return -EINVAL;
-+		}
-+	}
-+
-+	if (num_wc && cfg->pmc_write_check == NULL) {
-+		PFM_INFO("some PMCs have write-checker but no callback provided\n");
-+		return -EINVAL;
-+	}
-+
-+	/*
-+	 * check virtual PMD registers
-+	 */
-+	num_wc = 0;
-+	for (i = 0; i < cfg->num_pmd_entries;  i++) {
-+
-+		type = cfg->pmd_desc[i].type;
-+
-+		if (type & PFM_REG_I)
-+			num_pmds++;
-+
-+		if (type & PFM_REG_V) {
-+			nspec++;
-+			if (type & PFM_REG_RO)
-+				nspec_ro++;
-+		}
-+
-+		if (type & PFM_REG_WC)
-+			num_wc++;
-+	}
-+
-+	if (num_wc && cfg->pmd_write_check == NULL) {
-+		PFM_INFO("PMD have write-checker but no callback provided\n");
-+		return -EINVAL;
-+	}
-+
-+	if (nspec && cfg->pmd_sread == NULL) {
-+		PFM_INFO("PMU config is missing pmd_sread()");
-+		return -EINVAL;
-+	}
-+
-+	nspec = nspec - nspec_ro;
-+	if (nspec && cfg->pmd_swrite == NULL) {
-+		PFM_INFO("PMU config is missing pmd_swrite()");
-+		return -EINVAL;
-+	}
-+
-+	if (num_pmcs >= PFM_MAX_PMCS) {
-+		PFM_INFO("%s PMCS registers exceed name space [0-%u]",
-+			 cfg->pmu_name,
-+			 PFM_MAX_PMCS);
-+		return -EINVAL;
-+	}
-+	if (num_pmds >= PFM_MAX_PMDS) {
-+		PFM_INFO("%s PMDS registers exceed name space [0-%u]",
-+			 cfg->pmu_name,
-+			 PFM_MAX_PMDS);
-+		return -EINVAL;
-+	}
-+	spin_lock(&pfm_pmu_conf_lock);
-+
-+	if (pfm_pmu_conf)
-+		goto unlock;
-+
-+	if (!cfg->version)
-+		cfg->version = "0.0";
-+
-+	pfm_pmu_conf = cfg;
-+	pfm_pmu_conf->ovfl_mask = (1ULL << cfg->counter_width) - 1;
-+
-+	ret = pfm_arch_pmu_config_init(cfg);
-+	if (ret)
-+		goto unlock;
-+
-+	ret = pfm_sysfs_add_pmu(pfm_pmu_conf);
-+	if (ret)
-+		pfm_pmu_conf = NULL;
-+
-+unlock:
-+	spin_unlock(&pfm_pmu_conf_lock);
-+
-+	if (ret) {
-+		PFM_INFO("register %s PMU error %d", cfg->pmu_name, ret);
-+	} else {
-+		PFM_INFO("%s PMU installed", cfg->pmu_name);
-+		/*
-+		 * (re)initialize PMU on each PMU now that we have a description
-+		 */
-+		on_each_cpu(__pfm_init_percpu, cfg, 0);
-+	}
-+	return ret;
-+}
-+EXPORT_SYMBOL(pfm_pmu_register);
-+
-+/*
-+ * remove PMU description. Caller must pass address of current
-+ * configuration. This is mostly for sanity checking as only
-+ * one config can exist at any time.
-+ *
-+ * We are using the module refcount mechanism to protect against
-+ * removal while the configuration is being used. As long as there is
-+ * one context, a PMU configuration cannot be removed. The protection is
-+ * managed in module logic.
-+ */
-+void pfm_pmu_unregister(struct pfm_pmu_config *cfg)
-+{
-+	if (!(cfg || pfm_pmu_conf))
-+		return;
-+
-+	spin_lock(&pfm_pmu_conf_lock);
-+
-+	BUG_ON(module_refcount(pfm_pmu_conf->owner));
-+
-+	if (cfg->owner == pfm_pmu_conf->owner) {
-+		pfm_sysfs_remove_pmu(pfm_pmu_conf);
-+		pfm_pmu_conf = NULL;
-+	}
-+
-+	spin_unlock(&pfm_pmu_conf_lock);
-+}
-+EXPORT_SYMBOL(pfm_pmu_unregister);
-+
-+static int pfm_pmu_request_module(void)
-+{
-+	char *mod_name;
-+	int ret;
-+
-+	mod_name = pfm_arch_get_pmu_module_name();
-+	if (mod_name == NULL)
-+		return -ENOSYS;
-+
-+	ret = request_module(mod_name);
-+
-+	PFM_DBG("mod=%s ret=%d\n", mod_name, ret);
-+	return ret;
-+}
-+
-+/*
-+ * autoload:
-+ * 	0     : do not try to autoload the PMU description module
-+ * 	not 0 : try to autoload the PMU description module
-+ */
-+int pfm_pmu_conf_get(int autoload)
-+{
-+	int ret;
-+
-+	spin_lock(&pfm_pmu_conf_lock);
-+
-+	if (request_mod_in_progress) {
-+		ret = -ENOSYS;
-+		goto skip;
-+	}
-+
-+	if (autoload && pfm_pmu_conf == NULL) {
-+
-+		request_mod_in_progress = 1;
-+
-+		spin_unlock(&pfm_pmu_conf_lock);
-+
-+		pfm_pmu_request_module();
-+
-+		spin_lock(&pfm_pmu_conf_lock);
-+
-+		request_mod_in_progress = 0;
-+
-+		/*
-+		 * request_module() may succeed but the module
-+		 * may not have registered properly so we need
-+		 * to check
-+		 */
-+	}
-+
-+	ret = pfm_pmu_conf == NULL ? -ENOSYS : 0;
-+	if (!ret && pmu_is_module(pfm_pmu_conf)
-+	    && !try_module_get(pfm_pmu_conf->owner))
-+		ret = -ENOSYS;
-+
-+skip:
-+	spin_unlock(&pfm_pmu_conf_lock);
-+
-+	return ret;
-+}
-+
-+void pfm_pmu_conf_put(void)
-+{
-+	if (pfm_pmu_conf == NULL || !pmu_is_module(pfm_pmu_conf))
-+		return;
-+
-+	spin_lock(&pfm_pmu_conf_lock);
-+	module_put(pfm_pmu_conf->owner);
-+	spin_unlock(&pfm_pmu_conf_lock);
-+}
-+
-+
-+/*
-+ * acquire PMU resource from lower-level PMU register allocator
-+ * (currently perfctr-watchdog.c)
-+ *
-+ * acquisition is done when the first context is created (and not
-+ * when it is loaded). We grab all that is defined in the description
-+ * module and then we make adjustments at the arch-specific level.
-+ *
-+ * The PMU resource is released when the last perfmon context is
-+ * destroyed.
-+ *
-+ * interrupts are not masked
-+ */
-+int pfm_pmu_acquire(struct pfm_context *ctx)
-+{
-+	u64 unavail_pmcs[PFM_PMC_BV];
-+	u64 unavail_pmds[PFM_PMD_BV];
-+	int ret = 0;
-+
-+	spin_lock(&pfm_pmu_acq_lock);
-+
-+	PFM_DBG("pmu_acquired=%u", pfm_pmu_acquired);
-+
-+	pfm_pmu_acquired++;
-+
-+	/*
-+	 * we need to initialize regdesc each  time we re-acquire
-+	 * the PMU for the first time as there may have been changes
-+	 * in the list of available registers, e.g., NMI may have
-+	 * been disabled. Checking on PMU module insert is not
-+	 * enough
-+	 */
-+	if (pfm_pmu_acquired == 1) {
-+		memset(unavail_pmcs, 0, sizeof(unavail_pmcs));
-+		memset(unavail_pmds, 0, sizeof(unavail_pmds));
-+
-+		ret = pfm_arch_pmu_acquire(unavail_pmcs, unavail_pmds);
-+		if (ret) {
-+			pfm_pmu_acquired--;
-+		} else {
-+			pfm_pmu_regdesc_init_all(unavail_pmcs, unavail_pmds);
-+
-+			/* available PMU ressources */
-+			PFM_DBG("PMU acquired: %u PMCs, %u PMDs, %u counters",
-+				pfm_pmu_conf->regs_all.num_pmcs,
-+				pfm_pmu_conf->regs_all.num_pmds,
-+				pfm_pmu_conf->regs_all.num_counters);
-+		}
-+	}
-+	spin_unlock(&pfm_pmu_acq_lock);
-+
-+	/*
-+	 * copy the regdesc that corresponds to the context
-+	 * we copy and not just point because it helps with
-+	 * memory locality. the regdesc structure is accessed
-+	 * very frequently in performance critical code such
-+	 * as context switch and interrupt handling. By using
-+	 * a local copy, we increase memory footprint, but
-+	 * increase chance to have local memory access,
-+	 * especially for system-wide contexts.
-+	 */
-+	if (ctx->flags.system)
-+		ctx->regs = pfm_pmu_conf->regs_sys;
-+	else
-+		ctx->regs = pfm_pmu_conf->regs_thr;
-+
-+	return ret;
-+}
-+
-+/*
-+ * release the PMU resource
-+ *
-+ * actual release happens when last context is destroyed
-+ *
-+ * interrupts are not masked
-+ */
-+void pfm_pmu_release(void)
-+{
-+	BUG_ON(irqs_disabled());
-+
-+	/*
-+	 * we need to use a spinlock because release takes some time
-+	 * and we may have a race with pfm_pmu_acquire()
-+	 */
-+	spin_lock(&pfm_pmu_acq_lock);
-+
-+	PFM_DBG("pmu_acquired=%d", pfm_pmu_acquired);
-+
-+	/*
-+	 * we decouple test and decrement because if we had errors
-+	 * in pfm_pmu_acquire(), we still come here on pfm_context_free()
-+	 * but with pfm_pmu_acquire=0
-+	 */
-+	if (pfm_pmu_acquired > 0 && --pfm_pmu_acquired == 0) {
-+		pfm_arch_pmu_release();
-+		PFM_DBG("PMU released");
-+	}
-+	spin_unlock(&pfm_pmu_acq_lock);
-+}
-diff --git a/perfmon/perfmon_priv.h b/perfmon/perfmon_priv.h
-new file mode 100644
-index 0000000..5b485de
---- /dev/null
-+++ b/perfmon/perfmon_priv.h
-@@ -0,0 +1,182 @@
-+/*
-+ * Copyright (c) 2001-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+
-+#ifndef __PERFMON_PRIV_H__
-+#define __PERFMON_PRIV_H__
-+/*
-+ * This file contains all the definitions of data structures, variables, macros
-+ * that are to private to the generic code, i.e., not shared with any code that
-+ * lives under arch/ or include/asm-XX
-+ *
-+ * For shared definitions, use include/linux/perfmon_kern.h
-+ */
-+
-+#ifdef CONFIG_PERFMON
-+
-+/*
-+ * type of PMD reset for pfm_reset_pmds() or pfm_switch_sets*()
-+ */
-+#define PFM_PMD_RESET_SHORT	1	/* use short reset value */
-+#define PFM_PMD_RESET_LONG	2	/* use long reset value  */
-+
-+/*
-+ * context lazy save/restore activation count
-+ */
-+#define PFM_INVALID_ACTIVATION	((u64)~0)
-+
-+DECLARE_PER_CPU(u64, pmu_activation_number);
-+DECLARE_PER_CPU(struct hrtimer, pfm_hrtimer);
-+
-+static inline void pfm_set_pmu_owner(struct task_struct *task,
-+				     struct pfm_context *ctx)
-+{
-+	__get_cpu_var(pmu_owner) = task;
-+	__get_cpu_var(pmu_ctx) = ctx;
-+}
-+
-+static inline int pfm_msgq_is_empty(struct pfm_context *ctx)
-+{
-+	return ctx->msgq_head == ctx->msgq_tail;
-+}
-+
-+void pfm_get_next_msg(struct pfm_context *ctx, union pfarg_msg *m);
-+int pfm_end_notify(struct pfm_context *ctx);
-+int pfm_ovfl_notify(struct pfm_context *ctx, struct pfm_event_set *set,
-+		    unsigned long ip);
-+
-+int pfm_alloc_fd(struct file **cfile);
-+
-+int __pfm_delete_evtsets(struct pfm_context *ctx, void *arg, int count);
-+int __pfm_getinfo_evtsets(struct pfm_context *ctx, struct pfarg_setinfo *req,
-+			  int count);
-+int __pfm_create_evtsets(struct pfm_context *ctx, struct pfarg_setdesc *req,
-+			int count);
-+
-+
-+int pfm_init_ctx(void);
-+
-+int pfm_pmu_acquire(struct pfm_context *ctx);
-+void pfm_pmu_release(void);
-+
-+int pfm_session_acquire(int is_system, u32 cpu);
-+void pfm_session_release(int is_system, u32 cpu);
-+
-+int pfm_smpl_buf_space_acquire(struct pfm_context *ctx, size_t size);
-+int pfm_smpl_buf_load_context(struct pfm_context *ctx);
-+void pfm_smpl_buf_unload_context(struct pfm_context *ctx);
-+
-+int  pfm_init_sysfs(void);
-+
-+#ifdef CONFIG_PERFMON_DEBUG_FS
-+int  pfm_init_debugfs(void);
-+int pfm_debugfs_add_cpu(int mycpu);
-+void pfm_debugfs_del_cpu(int mycpu);
-+#else
-+static inline int pfm_init_debugfs(void)
-+{
-+	return 0;
-+}
-+static inline int pfm_debugfs_add_cpu(int mycpu)
-+{
-+	return 0;
-+}
-+
-+static inline void pfm_debugfs_del_cpu(int mycpu)
-+{}
-+#endif
-+
-+
-+void pfm_reset_pmds(struct pfm_context *ctx, struct pfm_event_set *set,
-+		    int num_pmds,
-+		    int reset_mode);
-+
-+struct pfm_event_set *pfm_prepare_sets(struct pfm_context *ctx, u16 load_set);
-+int pfm_init_sets(void);
-+
-+ssize_t pfm_sysfs_res_show(char *buf, size_t sz, int what);
-+
-+void pfm_free_sets(struct pfm_context *ctx);
-+int pfm_create_initial_set(struct pfm_context *ctx);
-+void pfm_switch_sets_from_intr(struct pfm_context *ctx);
-+void pfm_restart_timer(struct pfm_context *ctx, struct pfm_event_set *set);
-+enum hrtimer_restart pfm_handle_switch_timeout(struct hrtimer *t);
-+
-+enum hrtimer_restart pfm_switch_sets(struct pfm_context *ctx,
-+		    struct pfm_event_set *new_set,
-+		    int reset_mode,
-+		    int no_restart);
-+
-+/**
-+ * pfm_save_prev_ctx - check if previous context exists and save state
-+ *
-+ * called from pfm_load_ctx_thread() and __pfm_ctxsin_thread() to
-+ * check if previous context exists. If so saved its PMU state. This is used
-+ * only for UP kernels.
-+ *
-+ * PMU ownership is not cleared because the function is always called while
-+ * trying to install a new owner.
-+ */
-+static inline void pfm_check_save_prev_ctx(void)
-+{
-+#ifdef CONFIG_SMP
-+	struct pfm_event_set *set;
-+	struct pfm_context *ctxp;
-+
-+	ctxp = __get_cpu_var(pmu_ctx);
-+	if (!ctxp)
-+		return;
-+	/*
-+	 * in UP per-thread, due to lazy save
-+	 * there could be a context from another
-+	 * task. We need to push it first before
-+	 * installing our new state
-+	 */
-+	set = ctxp->active_set;
-+	pfm_save_pmds(ctxp, set);
-+	/*
-+	 * do not clear ownership because we rewrite
-+	 * right away
-+	 */
-+#endif
-+}
-+
-+
-+int pfm_init_fs(void);
-+
-+int pfm_init_hotplug(void);
-+
-+void pfm_mask_monitoring(struct pfm_context *ctx, struct pfm_event_set *set);
-+void pfm_resume_after_ovfl(struct pfm_context *ctx);
-+int pfm_setup_smpl_fmt(struct pfm_context *ctx, u32 ctx_flags, void *fmt_arg,
-+		       struct file *filp);
-+
-+static inline void pfm_post_work(struct task_struct *task,
-+				 struct pfm_context *ctx, int type)
-+{
-+	ctx->flags.work_type = type;
-+	set_tsk_thread_flag(task, TIF_PERFMON_WORK);
-+	pfm_arch_arm_handle_work(task);
-+}
-+
-+#define PFM_PMC_STK_ARG	PFM_ARCH_PMC_STK_ARG
-+#define PFM_PMD_STK_ARG	PFM_ARCH_PMD_STK_ARG
-+
-+#endif /* CONFIG_PERFMON */
-+
-+#endif /* __PERFMON_PRIV_H__ */
-diff --git a/perfmon/perfmon_res.c b/perfmon/perfmon_res.c
-new file mode 100644
-index 0000000..7b0382b
---- /dev/null
-+++ b/perfmon/perfmon_res.c
-@@ -0,0 +1,450 @@
-+/*
-+ * perfmon_res.c:  perfmon2 resource allocations
-+ *
-+ * This file implements the perfmon2 interface which
-+ * provides access to the hardware performance counters
-+ * of the host processor.
-+ *
-+ * The initial version of perfmon.c was written by
-+ * Ganesh Venkitachalam, IBM Corp.
-+ *
-+ * Then it was modified for perfmon-1.x by Stephane Eranian and
-+ * David Mosberger, Hewlett Packard Co.
-+ *
-+ * Version Perfmon-2.x is a complete rewrite of perfmon-1.x
-+ * by Stephane Eranian, Hewlett Packard Co.
-+ *
-+ * Copyright (c) 1999-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *                David Mosberger-Tang <davidm@hpl.hp.com>
-+ *
-+ * More information about perfmon available at:
-+ * 	http://perfmon2.sf.net
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/kernel.h>
-+#include <linux/module.h>
-+#include <linux/perfmon_kern.h>
-+#include "perfmon_priv.h"
-+
-+/*
-+ * global information about all sessions
-+ * mostly used to synchronize between system wide and per-process
-+ */
-+struct pfm_resources {
-+	size_t		smpl_buf_mem_cur;/* current smpl buf mem usage */
-+	cpumask_t	sys_cpumask;     /* bitmask of used cpus */
-+	u32		thread_sessions; /* #num loaded per-thread sessions */
-+};
-+
-+static struct pfm_resources pfm_res;
-+
-+static __cacheline_aligned_in_smp DEFINE_SPINLOCK(pfm_res_lock);
-+
-+/**
-+ * pfm_smpl_buf_space_acquire - check memory resource usage for sampling buffer
-+ * @ctx: context of interest
-+ * @size: size fo requested buffer
-+ *
-+ * sampling buffer allocated by perfmon must be
-+ * checked against max locked memory usage thresholds
-+ * for security reasons.
-+ *
-+ * The first level check is against the system wide limit
-+ * as indicated by the system administrator in /sys/kernel/perfmon
-+ *
-+ * The second level check is on a per-process basis using
-+ * RLIMIT_MEMLOCK limit.
-+ *
-+ * Operating on the current task only.
-+ */
-+int pfm_smpl_buf_space_acquire(struct pfm_context *ctx, size_t size)
-+{
-+	struct mm_struct *mm;
-+	unsigned long locked;
-+	unsigned long buf_mem, buf_mem_max;
-+	unsigned long flags;
-+
-+	spin_lock_irqsave(&pfm_res_lock, flags);
-+
-+	/*
-+	 * check against global buffer limit
-+	 */
-+	buf_mem_max = pfm_controls.smpl_buffer_mem_max;
-+	buf_mem = pfm_res.smpl_buf_mem_cur + size;
-+
-+	if (buf_mem <= buf_mem_max) {
-+		pfm_res.smpl_buf_mem_cur = buf_mem;
-+
-+		PFM_DBG("buf_mem_max=%lu current_buf_mem=%lu",
-+			buf_mem_max,
-+			buf_mem);
-+	}
-+
-+	spin_unlock_irqrestore(&pfm_res_lock, flags);
-+
-+	if (buf_mem > buf_mem_max) {
-+		PFM_DBG("smpl buffer memory threshold reached");
-+		return -ENOMEM;
-+	}
-+
-+	/*
-+	 * check against per-process RLIMIT_MEMLOCK
-+	 */
-+	mm = get_task_mm(current);
-+
-+	down_write(&mm->mmap_sem);
-+
-+	locked  = mm->locked_vm << PAGE_SHIFT;
-+	locked += size;
-+
-+	if (locked > current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur) {
-+
-+		PFM_DBG("RLIMIT_MEMLOCK reached ask_locked=%lu rlim_cur=%lu",
-+			locked,
-+			current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur);
-+
-+		up_write(&mm->mmap_sem);
-+		mmput(mm);
-+		goto unres;
-+	}
-+
-+	mm->locked_vm = locked >> PAGE_SHIFT;
-+
-+	up_write(&mm->mmap_sem);
-+
-+	mmput(mm);
-+
-+	return 0;
-+
-+unres:
-+	/*
-+	 * remove global buffer memory allocation
-+	 */
-+	spin_lock_irqsave(&pfm_res_lock, flags);
-+
-+	pfm_res.smpl_buf_mem_cur -= size;
-+
-+	spin_unlock_irqrestore(&pfm_res_lock, flags);
-+
-+	return -ENOMEM;
-+}
-+/**
-+ * pfm_smpl_buf_space_release - release resource usage for sampling buffer
-+ * @ctx: perfmon context of interest
-+ *
-+ * There exist multiple paths leading to this function. We need to
-+ * be very careful withlokcing on the mmap_sem as it may already be
-+ * held by the time we come here.
-+ * The following paths exist:
-+ *
-+ * exit path:
-+ * sys_exit_group
-+ *    do_group_exit
-+ *     do_exit
-+ *      exit_mm
-+ *       mmput
-+ *        exit_mmap
-+ *         remove_vma
-+ *          fput
-+ *           __fput
-+ *            pfm_close
-+ *             __pfm_close
-+ *              pfm_context_free
-+ * 	         pfm_release_buf_space
-+ * munmap path:
-+ * sys_munmap
-+ *  do_munmap
-+ *   remove_vma
-+ *    fput
-+ *     __fput
-+ *      pfm_close
-+ *       __pfm_close
-+ *        pfm_context_free
-+ *         pfm_release_buf_space
-+ *
-+ * close path:
-+ * sys_close
-+ *  filp_close
-+ *   fput
-+ *    __fput
-+ *     pfm_close
-+ *      __pfm_close
-+ *       pfm_context_free
-+ *        pfm_release_buf_space
-+ *
-+ * The issue is that on the munmap() path, the mmap_sem is already held
-+ * in write-mode by the time we come here. To avoid the deadlock, we need
-+ * to know where we are coming from and skip down_write(). If is fairly
-+ * difficult to know this because of the lack of good hooks and
-+ * the fact that, there may not have been any mmap() of the sampling buffer
-+ * (i.e. create_context() followed by close() or exit()).
-+ *
-+ * We use a set flag ctx->flags.mmap_nlock which is toggled in the vm_ops
-+ * callback in remove_vma() which is called systematically for the call, so
-+ * on all but the pure close() path. The exit path does not already hold
-+ * the lock but this is exit so there is no task->mm by the time we come here.
-+ *
-+ * The mmap_nlock is set only when unmapping and this is the LAST reference
-+ * to the file (i.e., close() followed by munmap()).
-+ */
-+void pfm_smpl_buf_space_release(struct pfm_context *ctx, size_t size)
-+{
-+	unsigned long flags;
-+	struct mm_struct *mm;
-+
-+	mm = get_task_mm(current);
-+	if (mm) {
-+		if (ctx->flags.mmap_nlock == 0) {
-+			PFM_DBG("doing down_write");
-+			down_write(&mm->mmap_sem);
-+		}
-+
-+		mm->locked_vm -= size >> PAGE_SHIFT;
-+
-+		PFM_DBG("size=%zu locked_vm=%lu", size, mm->locked_vm);
-+
-+		if (ctx->flags.mmap_nlock == 0)
-+			up_write(&mm->mmap_sem);
-+
-+		mmput(mm);
-+	}
-+
-+	spin_lock_irqsave(&pfm_res_lock, flags);
-+
-+	pfm_res.smpl_buf_mem_cur -= size;
-+
-+	spin_unlock_irqrestore(&pfm_res_lock, flags);
-+}
-+
-+/**
-+ * pfm_session_acquire - reserve a per-thread or per-cpu session
-+ * @is_system: true if per-cpu session
-+ * @cpu: cpu number for per-cpu session
-+ *
-+ * return:
-+ * 	 0    : success
-+ * 	-EBUSY: if conflicting session exist
-+ */
-+int pfm_session_acquire(int is_system, u32 cpu)
-+{
-+	unsigned long flags;
-+	u32 nsys_cpus;
-+	int ret = 0;
-+
-+	/*
-+	 * validy checks on cpu_mask have been done upstream
-+	 */
-+	spin_lock_irqsave(&pfm_res_lock, flags);
-+
-+	nsys_cpus = cpus_weight(pfm_res.sys_cpumask);
-+
-+	PFM_DBG("in  sys=%u task=%u is_sys=%d cpu=%u",
-+		nsys_cpus,
-+		pfm_res.thread_sessions,
-+		is_system,
-+		cpu);
-+
-+	if (is_system) {
-+		/*
-+		 * cannot mix system wide and per-task sessions
-+		 */
-+		if (pfm_res.thread_sessions > 0) {
-+			PFM_DBG("%u conflicting thread_sessions",
-+				pfm_res.thread_sessions);
-+			ret = -EBUSY;
-+			goto abort;
-+		}
-+
-+		if (cpu_isset(cpu, pfm_res.sys_cpumask)) {
-+			PFM_DBG("conflicting session on CPU%u", cpu);
-+			ret = -EBUSY;
-+			goto abort;
-+		}
-+
-+		PFM_DBG("reserved session on CPU%u", cpu);
-+
-+		cpu_set(cpu, pfm_res.sys_cpumask);
-+		nsys_cpus++;
-+	} else {
-+		if (nsys_cpus) {
-+			ret = -EBUSY;
-+			goto abort;
-+		}
-+		pfm_res.thread_sessions++;
-+	}
-+
-+	PFM_DBG("out sys=%u task=%u is_sys=%d cpu=%u",
-+		nsys_cpus,
-+		pfm_res.thread_sessions,
-+		is_system,
-+		cpu);
-+
-+abort:
-+	spin_unlock_irqrestore(&pfm_res_lock, flags);
-+
-+	return ret;
-+}
-+
-+/**
-+ * pfm_session_release - release a per-cpu or per-thread session
-+ * @is_system: true if per-cpu session
-+ * @cpu: cpu number for per-cpu session
-+ *
-+ * called from __pfm_unload_context()
-+ */
-+void pfm_session_release(int is_system, u32 cpu)
-+{
-+	unsigned long flags;
-+
-+	spin_lock_irqsave(&pfm_res_lock, flags);
-+
-+	PFM_DBG("in sys_sessions=%u thread_sessions=%u syswide=%d cpu=%u",
-+		cpus_weight(pfm_res.sys_cpumask),
-+		pfm_res.thread_sessions,
-+		is_system, cpu);
-+
-+	if (is_system)
-+		cpu_clear(cpu, pfm_res.sys_cpumask);
-+	else
-+		pfm_res.thread_sessions--;
-+
-+	PFM_DBG("out sys_sessions=%u thread_sessions=%u syswide=%d cpu=%u",
-+		cpus_weight(pfm_res.sys_cpumask),
-+		pfm_res.thread_sessions,
-+		is_system, cpu);
-+
-+	spin_unlock_irqrestore(&pfm_res_lock, flags);
-+}
-+
-+/**
-+ * pfm_session_allcpus_acquire - acquire per-cpu sessions on all available cpus
-+ *
-+ * currently used by Oprofile on X86
-+ */
-+int pfm_session_allcpus_acquire(void)
-+{
-+	unsigned long flags;
-+	u32 nsys_cpus, cpu;
-+	int ret = -EBUSY;
-+
-+	spin_lock_irqsave(&pfm_res_lock, flags);
-+
-+	nsys_cpus = cpus_weight(pfm_res.sys_cpumask);
-+
-+	PFM_DBG("in  sys=%u task=%u",
-+		nsys_cpus,
-+		pfm_res.thread_sessions);
-+
-+	if (nsys_cpus) {
-+		PFM_DBG("already some system-wide sessions");
-+		goto abort;
-+	}
-+
-+	/*
-+	 * cannot mix system wide and per-task sessions
-+	 */
-+	if (pfm_res.thread_sessions) {
-+		PFM_DBG("%u conflicting thread_sessions",
-+			pfm_res.thread_sessions);
-+		goto abort;
-+	}
-+
-+	for_each_online_cpu(cpu) {
-+		cpu_set(cpu, pfm_res.sys_cpumask);
-+		nsys_cpus++;
-+	}
-+
-+	PFM_DBG("out sys=%u task=%u",
-+		nsys_cpus,
-+		pfm_res.thread_sessions);
-+
-+	ret = 0;
-+abort:
-+	spin_unlock_irqrestore(&pfm_res_lock, flags);
-+
-+	return ret;
-+}
-+EXPORT_SYMBOL(pfm_session_allcpus_acquire);
-+
-+/**
-+ * pfm_session_allcpus_release - relase per-cpu sessions on all cpus
-+ *
-+ * currently used by Oprofile code
-+ */
-+void pfm_session_allcpus_release(void)
-+{
-+	unsigned long flags;
-+	u32 nsys_cpus, cpu;
-+
-+	spin_lock_irqsave(&pfm_res_lock, flags);
-+
-+	nsys_cpus = cpus_weight(pfm_res.sys_cpumask);
-+
-+	PFM_DBG("in  sys=%u task=%u",
-+		nsys_cpus,
-+		pfm_res.thread_sessions);
-+
-+	/*
-+	 * XXX: could use __cpus_clear() with nbits
-+	 */
-+	for_each_online_cpu(cpu) {
-+		cpu_clear(cpu, pfm_res.sys_cpumask);
-+		nsys_cpus--;
-+	}
-+
-+	PFM_DBG("out sys=%u task=%u",
-+		nsys_cpus,
-+		pfm_res.thread_sessions);
-+
-+	spin_unlock_irqrestore(&pfm_res_lock, flags);
-+}
-+EXPORT_SYMBOL(pfm_session_allcpus_release);
-+
-+/**
-+ * pfm_sysfs_res_show - return currnt resourcde usage for sysfs
-+ * @buf: buffer to hold string in return
-+ * @sz: size of buf
-+ * @what: what to produce
-+ *        what=0 : thread_sessions
-+ *        what=1 : cpus_weight(sys_cpumask)
-+ *        what=2 : smpl_buf_mem_cur
-+ *        what=3 : pmu model name
-+ *
-+ * called from perfmon_sysfs.c
-+ * return number of bytes written into buf (up to sz)
-+ */
-+ssize_t pfm_sysfs_res_show(char *buf, size_t sz, int what)
-+{
-+	unsigned long flags;
-+
-+	spin_lock_irqsave(&pfm_res_lock, flags);
-+
-+	switch (what) {
-+	case 0: snprintf(buf, sz, "%u\n", pfm_res.thread_sessions);
-+		break;
-+	case 1: snprintf(buf, sz, "%d\n", cpus_weight(pfm_res.sys_cpumask));
-+		break;
-+	case 2: snprintf(buf, sz, "%zu\n", pfm_res.smpl_buf_mem_cur);
-+		break;
-+	case 3:
-+		snprintf(buf, sz, "%s\n",
-+			pfm_pmu_conf ?	pfm_pmu_conf->pmu_name
-+				     :	"unknown\n");
-+	}
-+	spin_unlock_irqrestore(&pfm_res_lock, flags);
-+	return strlen(buf);
-+}
-diff --git a/perfmon/perfmon_rw.c b/perfmon/perfmon_rw.c
-new file mode 100644
-index 0000000..3168eb7
---- /dev/null
-+++ b/perfmon/perfmon_rw.c
-@@ -0,0 +1,733 @@
-+/*
-+ * perfmon.c: perfmon2 PMC/PMD read/write system calls
-+ *
-+ * This file implements the perfmon2 interface which
-+ * provides access to the hardware performance counters
-+ * of the host processor.
-+ *
-+ * The initial version of perfmon.c was written by
-+ * Ganesh Venkitachalam, IBM Corp.
-+ *
-+ * Then it was modified for perfmon-1.x by Stephane Eranian and
-+ * David Mosberger, Hewlett Packard Co.
-+ *
-+ * Version Perfmon-2.x is a complete rewrite of perfmon-1.x
-+ * by Stephane Eranian, Hewlett Packard Co.
-+ *
-+ * Copyright (c) 1999-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *                David Mosberger-Tang <davidm@hpl.hp.com>
-+ *
-+ * More information about perfmon available at:
-+ * 	http://perfmon2.sf.net/
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/module.h>
-+#include <linux/kernel.h>
-+#include <linux/perfmon_kern.h>
-+#include "perfmon_priv.h"
-+
-+#define PFM_REGFL_PMC_ALL	(PFM_REGFL_NO_EMUL64)
-+#define PFM_REGFL_PMD_ALL	(PFM_REGFL_RANDOM|PFM_REGFL_OVFL_NOTIFY)
-+
-+/**
-+ * update_used_reg -- updated used_pmcs for a single PMD
-+ * @set: set to update
-+ * @cnum: new PMD to add
-+ *
-+ * This function adds the pmds and pmcs depending on PMD cnum
-+ */
-+static inline void update_used_reg(struct pfm_context *ctx,
-+				   struct pfm_event_set *set, u16 cnum)
-+{
-+	bitmap_or(cast_ulp(set->used_pmcs),
-+		  cast_ulp(set->used_pmcs),
-+		  cast_ulp(pfm_pmu_conf->pmd_desc[cnum].dep_pmcs),
-+		  ctx->regs.max_pmc);
-+}
-+
-+/**
-+ * update_used -- update used_pmcs bitmask
-+ * @set: event set to update
-+ * @bv: bitmask to inspect for new PMD registers
-+ *
-+ * This function updates the used_pmcs bitmask for
-+ * the set using bv, a bitmask of pmds. For each pmd in bv,
-+ * its depending pmcs are added to used_pmcs.
-+ */
-+static void update_used_pmcs(struct pfm_context *ctx,
-+			     struct pfm_event_set *set, unsigned long *bv)
-+{
-+	u16 max_pmd;
-+	int n, p, q;
-+
-+	max_pmd = ctx->regs.max_pmd;
-+
-+	n = bitmap_weight(bv, max_pmd);
-+	for(p = 0; n; n--, p = q+1) {
-+		q = find_next_bit(bv, max_pmd, p);
-+		update_used_reg(ctx, set, q);
-+	}
-+}
-+
-+/**
-+ * update_changes -- update nused_pmcs, nused_pmds, write newly touched pmcs
-+ * @ctx: context to use
-+ * @set: event set to use
-+ * @old_used_pmcs: former used_pmc bitmask
-+ * @can_access: non-zero if PMU is accessible, i.e., can be written to
-+ *
-+ * This function updates nused_pmcs and nused_pmds after the last modificiation
-+ * to an event set. When new pmcs are used, then they must be initialized such
-+ * that we do not pick up stale values from another session.
-+ */
-+static inline int update_changes(struct pfm_context *ctx, struct pfm_event_set *set,
-+				 unsigned long *old_used_pmcs)
-+{
-+	struct pfarg_pmc req;
-+	u16 max_pmc, max_pmd;
-+	int n, p, q, ret = 0;
-+
-+	max_pmd = ctx->regs.max_pmd;
-+	max_pmc = ctx->regs.max_pmc;
-+
-+	/*
-+	 * update used counts
-+	 */
-+	set->nused_pmds = bitmap_weight(cast_ulp(set->used_pmds), max_pmd);
-+	set->nused_pmcs = bitmap_weight(cast_ulp(set->used_pmcs), max_pmc);
-+
-+	PFM_DBG("set%u u_pmds=0x%llx nu_pmds=%u u_pmcs=0x%llx nu_pmcs=%u",
-+			set->id,
-+			(unsigned long long)set->used_pmds[0],
-+			set->nused_pmds,
-+			(unsigned long long)set->used_pmcs[0],
-+			set->nused_pmcs);
-+
-+	memset(&req, 0, sizeof(req));
-+
-+	n = bitmap_weight(cast_ulp(set->used_pmcs), max_pmc);
-+	for(p = 0; n; n--, p = q+1) {
-+		q = find_next_bit(cast_ulp(set->used_pmcs), max_pmc, p);
-+
-+		if (test_bit(q, cast_ulp(old_used_pmcs)))
-+			continue;
-+
-+		req.reg_num = q;
-+		req.reg_value = set->pmcs[q];
-+
-+		ret = __pfm_write_pmcs(ctx, &req, 1);
-+		if (ret)
-+			break;
-+	}
-+	return ret;
-+}
-+
-+/**
-+ * handle_smpl_bv - checks sampling bitmasks for new PMDs
-+ * @ctx: context to use
-+ * @set: set to use
-+ * @bv: sampling bitmask
-+ *
-+ * scans the smpl bitmask looking for new PMDs (not yet used), if found
-+ * invoke pfm_write_pmds() on them to get them initialized and marked used
-+ */
-+static int handle_smpl_bv(struct pfm_context *ctx, struct pfm_event_set *set,
-+			  unsigned long *bv)
-+{
-+	struct pfarg_pmd req;
-+	int p, q, n, ret = 0;
-+	u16 max_pmd;
-+
-+	memset(&req, 0, sizeof(req));
-+
-+	max_pmd = ctx->regs.max_pmd;
-+
-+	n = bitmap_weight(cast_ulp(bv), max_pmd);
-+
-+	for(p = 0; n; n--, p = q+1) {
-+		q = find_next_bit(cast_ulp(bv), max_pmd, p);
-+
-+		if (test_bit(q, cast_ulp(set->used_pmds)))
-+			continue;
-+
-+		req.reg_num = q;
-+		req.reg_value = 0;
-+
-+		ret = __pfm_write_pmds(ctx, &req, 1, 0);
-+		if (ret)
-+			break;
-+	}
-+	return ret;
-+}
-+
-+/**
-+ * is_invalid -- check if register index is within limits
-+ * @cnum: register index
-+ * @impl: bitmask of implemented registers
-+ * @max: highest implemented registers + 1
-+ *
-+ * return:
-+ *    0 is register index is valid
-+ *    1 if invalid
-+ */
-+static inline int is_invalid(u16 cnum, unsigned long *impl, u16 max)
-+{
-+	return cnum >= max || !test_bit(cnum, impl);
-+}
-+
-+/**
-+ * __pfm_write_pmds - modified data registers
-+ * @ctx: context to operate on
-+ * @req: pfarg_pmd_t request from user
-+ * @count: number of element in the pfarg_pmd_t vector
-+ * @compat: used only on IA-64 to maintain backward compatibility with v2.0
-+ *
-+ * The function succeeds whether the context is attached or not.
-+ * When attached to another thread, that thread must be stopped.
-+ *
-+ * The context is locked and interrupts are disabled.
-+ */
-+int __pfm_write_pmds(struct pfm_context *ctx, struct pfarg_pmd *req, int count,
-+		     int compat)
-+{
-+	struct pfm_event_set *set, *active_set;
-+	u64 old_used_pmcs[PFM_PMC_BV];
-+	unsigned long *smpl_pmds, *reset_pmds, *impl_pmds, *impl_rw_pmds;
-+	u32 req_flags, flags;
-+	u16 cnum, pmd_type, max_pmd;
-+	u16 set_id;
-+	int i, can_access_pmu;
-+	int ret;
-+	pfm_pmd_check_t	wr_func;
-+
-+	active_set = ctx->active_set;
-+	max_pmd	= ctx->regs.max_pmd;
-+	impl_pmds = cast_ulp(ctx->regs.pmds);
-+	impl_rw_pmds = cast_ulp(ctx->regs.rw_pmds);
-+	wr_func = pfm_pmu_conf->pmd_write_check;
-+	set = list_first_entry(&ctx->set_list, struct pfm_event_set, list);
-+
-+	can_access_pmu = 0;
-+
-+	/*
-+	 * we cannot access the actual PMD registers when monitoring is masked
-+	 */
-+	if (unlikely(ctx->state == PFM_CTX_LOADED))
-+		can_access_pmu = __get_cpu_var(pmu_owner) == ctx->task
-+			|| ctx->flags.system;
-+
-+	bitmap_copy(cast_ulp(old_used_pmcs),
-+		    cast_ulp(set->used_pmcs),
-+		    ctx->regs.max_pmc);
-+
-+	ret = -EINVAL;
-+	for (i = 0; i < count; i++, req++) {
-+
-+		cnum = req->reg_num;
-+		set_id = req->reg_set;
-+		req_flags = req->reg_flags;
-+		smpl_pmds = cast_ulp(req->reg_smpl_pmds);
-+		reset_pmds = cast_ulp(req->reg_reset_pmds);
-+		flags = 0;
-+
-+		/*
-+		 * cannot write to unexisting
-+		 * writes to read-only register are ignored
-+		 */
-+		if (unlikely(is_invalid(cnum, impl_pmds, max_pmd))) {
-+			PFM_DBG("pmd%u is not available", cnum);
-+			goto error;
-+		}
-+
-+		pmd_type = pfm_pmu_conf->pmd_desc[cnum].type;
-+
-+		/*
-+		 * ensure only valid flags are set
-+		 */
-+		if (req_flags & ~(PFM_REGFL_PMD_ALL)) {
-+			PFM_DBG("pmd%u: invalid flags=0x%x",
-+				cnum, req_flags);
-+			goto error;
-+		}
-+
-+		/*
-+		 * OVFL_NOTIFY is valid for all types of PMD.
-+		 * non counting PMD may trigger PMU interrupt
-+		 * and thus may trigger recording of a sample.
-+		 * This is true with IBS on AMD family 16.
-+		 */
-+		if (req_flags & PFM_REGFL_OVFL_NOTIFY)
-+			flags |= PFM_REGFL_OVFL_NOTIFY;
-+
-+		/*
-+		 * We allow randomization to non counting PMD
-+		 */
-+		if (req_flags & PFM_REGFL_RANDOM)
-+			flags |= PFM_REGFL_RANDOM;
-+
-+		/*
-+		 * verify validity of smpl_pmds
-+		 */
-+		if (unlikely(!bitmap_subset(smpl_pmds, impl_pmds, PFM_MAX_PMDS))) {
-+			PFM_DBG("invalid smpl_pmds=0x%llx for pmd%u",
-+				(unsigned long long)req->reg_smpl_pmds[0],
-+				cnum);
-+			goto error;
-+		}
-+
-+		/*
-+		 * verify validity of reset_pmds
-+		 * check against impl_rw_pmds because it is not
-+		 * possible to reset read-only PMDs
-+		 */
-+		if (unlikely(!bitmap_subset(reset_pmds, impl_rw_pmds, PFM_MAX_PMDS))) {
-+			PFM_DBG("invalid reset_pmds=0x%llx for pmd%u",
-+				(unsigned long long)req->reg_reset_pmds[0],
-+				cnum);
-+			goto error;
-+		}
-+
-+		/*
-+		 * locate event set
-+		 */
-+		if (set_id != set->id) {
-+			/* update number of used register for previous set */
-+			if (i) {
-+				ret = update_changes(ctx, set, cast_ulp(old_used_pmcs));
-+				if (ret)
-+					goto error;
-+			}
-+
-+			set = pfm_find_set(ctx, set_id, 0);
-+			if (set == NULL) {
-+				PFM_DBG("event set%u does not exist",
-+						set_id);
-+				goto error;
-+			}
-+			bitmap_copy(cast_ulp(old_used_pmcs),
-+				    cast_ulp(set->used_pmcs),
-+				    ctx->regs.max_pmc);
-+		}
-+
-+		/*
-+		 * execute write checker, if any
-+		 */
-+		if (unlikely(wr_func && (pmd_type & PFM_REG_WC))) {
-+			ret = (*wr_func)(ctx, set, req);
-+			if (ret)
-+				goto error;
-+
-+		}
-+
-+
-+		/*
-+		 * now commit changes to software state
-+		 */
-+
-+		if (unlikely(compat))
-+			goto skip_set;
-+
-+		if (bitmap_weight(smpl_pmds, max_pmd)) {
-+			ret = handle_smpl_bv(ctx, set, smpl_pmds);
-+			if (ret)
-+				goto error;
-+			update_used_pmcs(ctx, set, cast_ulp(smpl_pmds));
-+		}
-+
-+		bitmap_copy(cast_ulp(set->pmds[cnum].smpl_pmds),
-+			    smpl_pmds,
-+			    max_pmd);
-+
-+
-+		if (bitmap_weight(reset_pmds, max_pmd)) {
-+			ret = handle_smpl_bv(ctx, set, reset_pmds);
-+			if (ret)
-+				goto error;
-+			update_used_pmcs(ctx, set, cast_ulp(reset_pmds));
-+		}
-+
-+		bitmap_copy(cast_ulp(set->pmds[cnum].reset_pmds),
-+			   reset_pmds,
-+			   max_pmd);
-+
-+		set->pmds[cnum].flags = flags;
-+
-+		__set_bit(cnum, cast_ulp(set->used_pmds));
-+		update_used_reg(ctx, set, cnum);
-+
-+		/*
-+		 * we reprogram the PMD hence, we clear any pending
-+		 * ovfl. Does affect ovfl switch on restart but new
-+		 * value has already been established here
-+		 */
-+		if (test_bit(cnum, cast_ulp(set->povfl_pmds))) {
-+			set->npend_ovfls--;
-+			__clear_bit(cnum, cast_ulp(set->povfl_pmds));
-+		}
-+		__clear_bit(cnum, cast_ulp(set->ovfl_pmds));
-+
-+		/*
-+		 * update ovfl_notify
-+		 */
-+		if (flags & PFM_REGFL_OVFL_NOTIFY)
-+			__set_bit(cnum, cast_ulp(set->ovfl_notify));
-+		else
-+			__clear_bit(cnum, cast_ulp(set->ovfl_notify));
-+
-+		/*
-+		 * establish new switch count
-+		 */
-+		set->pmds[cnum].ovflsw_thres = req->reg_ovfl_switch_cnt;
-+		set->pmds[cnum].ovflsw_ref_thres = req->reg_ovfl_switch_cnt;
-+skip_set:
-+
-+		/*
-+		 * set last value to new value for all types of PMD
-+		 */
-+		set->pmds[cnum].lval = req->reg_value;
-+		set->pmds[cnum].value = req->reg_value;
-+
-+		/*
-+		 * update reset values (not just for counters)
-+		 */
-+		set->pmds[cnum].long_reset = req->reg_long_reset;
-+		set->pmds[cnum].short_reset = req->reg_short_reset;
-+
-+		/*
-+		 * update randomization mask
-+		 */
-+		set->pmds[cnum].mask = req->reg_random_mask;
-+
-+		set->pmds[cnum].eventid = req->reg_smpl_eventid;
-+
-+		if (set == active_set) {
-+			set->priv_flags |= PFM_SETFL_PRIV_MOD_PMDS;
-+			if (can_access_pmu)
-+				pfm_write_pmd(ctx, cnum, req->reg_value);
-+		}
-+
-+
-+		PFM_DBG("set%u pmd%u=0x%llx flags=0x%x a_pmu=%d "
-+			"ctx_pmd=0x%llx s_reset=0x%llx "
-+			"l_reset=0x%llx s_pmds=0x%llx "
-+			"r_pmds=0x%llx o_pmds=0x%llx "
-+			"o_thres=%llu compat=%d eventid=%llx",
-+			set->id,
-+			cnum,
-+			(unsigned long long)req->reg_value,
-+			set->pmds[cnum].flags,
-+			can_access_pmu,
-+			(unsigned long long)set->pmds[cnum].value,
-+			(unsigned long long)set->pmds[cnum].short_reset,
-+			(unsigned long long)set->pmds[cnum].long_reset,
-+			(unsigned long long)set->pmds[cnum].smpl_pmds[0],
-+			(unsigned long long)set->pmds[cnum].reset_pmds[0],
-+			(unsigned long long)set->ovfl_pmds[0],
-+			(unsigned long long)set->pmds[cnum].ovflsw_thres,
-+			compat,
-+			(unsigned long long)set->pmds[cnum].eventid);
-+	}
-+	ret = 0;
-+
-+error:
-+	update_changes(ctx, set, cast_ulp(old_used_pmcs));
-+
-+	/*
-+	 * make changes visible
-+	 */
-+	if (can_access_pmu)
-+		pfm_arch_serialize();
-+
-+	return ret;
-+}
-+
-+/**
-+ * __pfm_write_pmcs - modified config registers
-+ * @ctx: context to operate on
-+ * @req: pfarg_pmc_t request from user
-+ * @count: number of element in the pfarg_pmc_t vector
-+ *
-+ *
-+ * The function succeeds whether the context is * attached or not.
-+ * When attached to another thread, that thread must be stopped.
-+ *
-+ * The context is locked and interrupts are disabled.
-+ */
-+int __pfm_write_pmcs(struct pfm_context *ctx, struct pfarg_pmc *req, int count)
-+{
-+	struct pfm_event_set *set, *active_set;
-+	u64 value, dfl_val, rsvd_msk;
-+	unsigned long *impl_pmcs;
-+	int i, can_access_pmu;
-+	int ret;
-+	u16 set_id;
-+	u16 cnum, pmc_type, max_pmc;
-+	u32 flags, expert;
-+	pfm_pmc_check_t	wr_func;
-+
-+	active_set = ctx->active_set;
-+
-+	wr_func = pfm_pmu_conf->pmc_write_check;
-+	max_pmc = ctx->regs.max_pmc;
-+	impl_pmcs = cast_ulp(ctx->regs.pmcs);
-+	set = list_first_entry(&ctx->set_list, struct pfm_event_set, list);
-+
-+	expert = pfm_controls.flags & PFM_CTRL_FL_RW_EXPERT;
-+
-+	can_access_pmu = 0;
-+
-+	/*
-+	 * we cannot access the actual PMC registers when monitoring is masked
-+	 */
-+	if (unlikely(ctx->state == PFM_CTX_LOADED))
-+		can_access_pmu = __get_cpu_var(pmu_owner) == ctx->task
-+			|| ctx->flags.system;
-+
-+	ret = -EINVAL;
-+
-+	for (i = 0; i < count; i++, req++) {
-+
-+		cnum = req->reg_num;
-+		set_id = req->reg_set;
-+		value = req->reg_value;
-+		flags = req->reg_flags;
-+
-+		/*
-+		 * no access to unavailable PMC register
-+		 */
-+		if (unlikely(is_invalid(cnum, impl_pmcs, max_pmc))) {
-+			PFM_DBG("pmc%u is not available", cnum);
-+			goto error;
-+		}
-+
-+		pmc_type = pfm_pmu_conf->pmc_desc[cnum].type;
-+		dfl_val = pfm_pmu_conf->pmc_desc[cnum].dfl_val;
-+		rsvd_msk = pfm_pmu_conf->pmc_desc[cnum].rsvd_msk;
-+
-+		/*
-+		 * ensure only valid flags are set
-+		 */
-+		if (flags & ~PFM_REGFL_PMC_ALL) {
-+			PFM_DBG("pmc%u: invalid flags=0x%x", cnum, flags);
-+			goto error;
-+		}
-+
-+		/*
-+		 * locate event set
-+		 */
-+		if (set_id != set->id) {
-+			set = pfm_find_set(ctx, set_id, 0);
-+			if (set == NULL) {
-+				PFM_DBG("event set%u does not exist",
-+					set_id);
-+				goto error;
-+			}
-+		}
-+
-+		/*
-+		 * set reserved bits to default values
-+		 * (reserved bits must be 1 in rsvd_msk)
-+		 *
-+		 * bypass via /sys/kernel/perfmon/mode = 1
-+		 */
-+		if (likely(!expert))
-+			value = (value & ~rsvd_msk) | (dfl_val & rsvd_msk);
-+
-+		if (flags & PFM_REGFL_NO_EMUL64) {
-+			if (!(pmc_type & PFM_REG_NO64)) {
-+				PFM_DBG("pmc%u no support for "
-+					"PFM_REGFL_NO_EMUL64", cnum);
-+				goto error;
-+			}
-+			value &= ~pfm_pmu_conf->pmc_desc[cnum].no_emul64_msk;
-+		}
-+
-+		/*
-+		 * execute write checker, if any
-+		 */
-+		if (likely(wr_func && (pmc_type & PFM_REG_WC))) {
-+			req->reg_value = value;
-+			ret = (*wr_func)(ctx, set, req);
-+			if (ret)
-+				goto error;
-+			value = req->reg_value;
-+		}
-+
-+		/*
-+		 * Now we commit the changes
-+		 */
-+
-+		/*
-+		 * mark PMC register as used
-+		 * We do not track associated PMC register based on
-+		 * the fact that they will likely need to be written
-+		 * in order to become useful at which point the statement
-+		 * below will catch that.
-+		 *
-+		 * The used_pmcs bitmask is only useful on architectures where
-+		 * the PMC needs to be modified for particular bits, especially
-+		 * on overflow or to stop/start.
-+		 */
-+		if (!test_bit(cnum, cast_ulp(set->used_pmcs))) {
-+			__set_bit(cnum, cast_ulp(set->used_pmcs));
-+			set->nused_pmcs++;
-+		}
-+
-+		set->pmcs[cnum] = value;
-+
-+		if (set == active_set) {
-+			set->priv_flags |= PFM_SETFL_PRIV_MOD_PMCS;
-+			if (can_access_pmu)
-+				pfm_arch_write_pmc(ctx, cnum, value);
-+		}
-+
-+		PFM_DBG("set%u pmc%u=0x%llx a_pmu=%d "
-+			"u_pmcs=0x%llx nu_pmcs=%u",
-+			set->id,
-+			cnum,
-+			(unsigned long long)value,
-+			can_access_pmu,
-+			(unsigned long long)set->used_pmcs[0],
-+			set->nused_pmcs);
-+	}
-+	ret = 0;
-+error:
-+	/*
-+	 * make sure the changes are visible
-+	 */
-+	if (can_access_pmu)
-+		pfm_arch_serialize();
-+
-+	return ret;
-+}
-+
-+/**
-+ * __pfm_read_pmds - read data registers
-+ * @ctx: context to operate on
-+ * @req: pfarg_pmd_t request from user
-+ * @count: number of element in the pfarg_pmd_t vector
-+ *
-+ *
-+ * The function succeeds whether the context is attached or not.
-+ * When attached to another thread, that thread must be stopped.
-+ *
-+ * The context is locked and interrupts are disabled.
-+ */
-+int __pfm_read_pmds(struct pfm_context *ctx, struct pfarg_pmd *req, int count)
-+{
-+	u64 val = 0, lval, ovfl_mask, hw_val;
-+	u64 sw_cnt;
-+	unsigned long *impl_pmds;
-+	struct pfm_event_set *set, *active_set;
-+	int i, ret, can_access_pmu = 0;
-+	u16 cnum, pmd_type, set_id, max_pmd;
-+
-+	ovfl_mask = pfm_pmu_conf->ovfl_mask;
-+	impl_pmds = cast_ulp(ctx->regs.pmds);
-+	max_pmd   = ctx->regs.max_pmd;
-+	active_set = ctx->active_set;
-+	set = list_first_entry(&ctx->set_list, struct pfm_event_set, list);
-+
-+	if (likely(ctx->state == PFM_CTX_LOADED)) {
-+		can_access_pmu = __get_cpu_var(pmu_owner) == ctx->task
-+			|| ctx->flags.system;
-+
-+		if (can_access_pmu)
-+			pfm_arch_serialize();
-+	}
-+
-+	/*
-+	 * on both UP and SMP, we can only read the PMD from the hardware
-+	 * register when the task is the owner of the local PMU.
-+	 */
-+	ret = -EINVAL;
-+	for (i = 0; i < count; i++, req++) {
-+
-+		cnum = req->reg_num;
-+		set_id = req->reg_set;
-+
-+		if (unlikely(is_invalid(cnum, impl_pmds, max_pmd))) {
-+			PFM_DBG("pmd%u is not implemented/unaccessible", cnum);
-+			goto error;
-+		}
-+
-+		pmd_type = pfm_pmu_conf->pmd_desc[cnum].type;
-+
-+		/*
-+		 * locate event set
-+		 */
-+		if (set_id != set->id) {
-+			set = pfm_find_set(ctx, set_id, 0);
-+			if (set == NULL) {
-+				PFM_DBG("event set%u does not exist",
-+					set_id);
-+				goto error;
-+			}
-+		}
-+		/*
-+		 * it is not possible to read a PMD which was not requested:
-+		 * 	- explicitly written via pfm_write_pmds()
-+		 * 	- provided as a reg_smpl_pmds[] to another PMD during
-+		 * 	  pfm_write_pmds()
-+		 *
-+		 * This is motivated by security and for optimization purposes:
-+		 * 	- on context switch restore, we can restore only what
-+		 * 	  we use (except when regs directly readable at user
-+		 * 	  level, e.g., IA-64 self-monitoring, I386 RDPMC).
-+		 * 	- do not need to maintain PMC -> PMD dependencies
-+		 */
-+		if (unlikely(!test_bit(cnum, cast_ulp(set->used_pmds)))) {
-+			PFM_DBG("pmd%u cannot read, because not used", cnum);
-+			goto error;
-+		}
-+
-+		val = set->pmds[cnum].value;
-+		lval = set->pmds[cnum].lval;
-+
-+		/*
-+		 * extract remaining ovfl to switch
-+		 */
-+		sw_cnt = set->pmds[cnum].ovflsw_thres;
-+
-+		/*
-+		 * If the task is not the current one, then we check if the
-+		 * PMU state is still in the local live register due to lazy
-+		 * ctxsw. If true, then we read directly from the registers.
-+		 */
-+		if (set == active_set && can_access_pmu) {
-+			hw_val = pfm_read_pmd(ctx, cnum);
-+			if (pmd_type & PFM_REG_C64)
-+				val = (val & ~ovfl_mask) | (hw_val & ovfl_mask);
-+			else
-+				val = hw_val;
-+		}
-+
-+		PFM_DBG("set%u pmd%u=0x%llx sw_thr=%llu lval=0x%llx",
-+			set->id,
-+			cnum,
-+			(unsigned long long)val,
-+			(unsigned long long)sw_cnt,
-+			(unsigned long long)lval);
-+
-+		req->reg_value = val;
-+		req->reg_last_reset_val = lval;
-+		req->reg_ovfl_switch_cnt = sw_cnt;
-+	}
-+	ret = 0;
-+error:
-+	return ret;
-+}
-diff --git a/perfmon/perfmon_sets.c b/perfmon/perfmon_sets.c
-new file mode 100644
-index 0000000..24534cb
---- /dev/null
-+++ b/perfmon/perfmon_sets.c
-@@ -0,0 +1,873 @@
-+/*
-+ * perfmon_sets.c: perfmon2 event sets and multiplexing functions
-+ *
-+ * This file implements the perfmon2 interface which
-+ * provides access to the hardware performance counters
-+ * of the host processor.
-+ *
-+ * The initial version of perfmon.c was written by
-+ * Ganesh Venkitachalam, IBM Corp.
-+ *
-+ * Then it was modified for perfmon-1.x by Stephane Eranian and
-+ * David Mosberger, Hewlett Packard Co.
-+ *
-+ * Version Perfmon-2.x is a complete rewrite of perfmon-1.x
-+ * by Stephane Eranian, Hewlett Packard Co.
-+ *
-+ * Copyright (c) 1999-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *                David Mosberger-Tang <davidm@hpl.hp.com>
-+ *
-+ * More information about perfmon available at:
-+ * 	http://perfmon2.sf.net
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/kernel.h>
-+#include <linux/perfmon_kern.h>
-+#include "perfmon_priv.h"
-+
-+static struct kmem_cache	*pfm_set_cachep;
-+
-+/**
-+ * pfm_reload_switch_thresholds - reload overflow-based switch thresholds per set
-+ * @set: the set for which to reload thresholds
-+ *
-+ */
-+static void pfm_reload_switch_thresholds(struct pfm_context *ctx,
-+					 struct pfm_event_set *set)
-+{
-+	u64 *used_pmds;
-+	u16 i, max, first;
-+
-+	used_pmds = set->used_pmds;
-+	first = ctx->regs.first_intr_pmd;
-+	max = ctx->regs.max_intr_pmd;
-+
-+	for (i = first; i < max; i++) {
-+		if (test_bit(i, cast_ulp(used_pmds))) {
-+			set->pmds[i].ovflsw_thres = set->pmds[i].ovflsw_ref_thres;
-+
-+			PFM_DBG("set%u pmd%u ovflsw_thres=%llu",
-+				set->id,
-+				i,
-+				(unsigned long long)set->pmds[i].ovflsw_thres);
-+		}
-+	}
-+}
-+
-+/**
-+ * pfm_prepare_sets - initialize sets on pfm_load_context
-+ * @ctx : context to operate on
-+ * @load_set: set to activate first
-+ *
-+ * connect all sets, reset internal fields
-+ */
-+struct pfm_event_set *pfm_prepare_sets(struct pfm_context *ctx, u16 load_set)
-+{
-+	struct pfm_event_set *set, *p;
-+	u16 max;
-+
-+	/*
-+	 * locate first set to activate
-+	 */
-+	set = pfm_find_set(ctx, load_set, 0);
-+	if (!set)
-+		return NULL;
-+
-+	if (set->flags & PFM_SETFL_OVFL_SWITCH)
-+		pfm_reload_switch_thresholds(ctx, set);
-+
-+	max = ctx->regs.max_intr_pmd;
-+
-+	list_for_each_entry(p, &ctx->set_list, list) {
-+		/*
-+		 * cleanup bitvectors
-+		 */
-+		bitmap_zero(cast_ulp(p->ovfl_pmds), max);
-+		bitmap_zero(cast_ulp(p->povfl_pmds), max);
-+
-+		p->npend_ovfls = 0;
-+
-+		/*
-+		 * we cannot just use plain clear because of arch-specific flags
-+		 */
-+		p->priv_flags &= ~(PFM_SETFL_PRIV_MOD_BOTH|PFM_SETFL_PRIV_SWITCH);
-+		/*
-+		 * neither duration nor runs are reset because typically loading/unloading
-+		 * does not mean counts are reset. To reset, the set must be modified
-+		 */
-+	}
-+	return set;
-+}
-+
-+/*
-+ * called by hrtimer_interrupt()
-+ *
-+ * This is the only function where we come with
-+ * cpu_base->lock held before ctx->lock
-+ *
-+ * interrupts are disabled
-+ */
-+enum hrtimer_restart pfm_handle_switch_timeout(struct hrtimer *t)
-+{
-+	struct pfm_event_set *set;
-+	struct pfm_context *ctx;
-+	unsigned long flags;
-+	enum hrtimer_restart ret = HRTIMER_NORESTART;
-+
-+	/*
-+	 * prevent against race with unload
-+	 */
-+	ctx  = __get_cpu_var(pmu_ctx);
-+	if (!ctx)
-+		return HRTIMER_NORESTART;
-+
-+	spin_lock_irqsave(&ctx->lock, flags);
-+
-+	set = ctx->active_set;
-+
-+	/*
-+	 * switching occurs only when context is attached
-+	 */
-+	if (ctx->state != PFM_CTX_LOADED)
-+		goto done;
-+	/*
-+	 * timer does not run while monitoring is inactive (not started)
-+	 */
-+	if (!pfm_arch_is_active(ctx))
-+		goto done;
-+
-+	pfm_stats_inc(handle_timeout_count);
-+
-+	ret  = pfm_switch_sets(ctx, NULL, PFM_PMD_RESET_SHORT, 0);
-+done:
-+	spin_unlock_irqrestore(&ctx->lock, flags);
-+	return ret;
-+}
-+
-+/*
-+ *
-+ * always operating on the current task
-+ * interrupts are masked
-+ *
-+ * input:
-+ * 	- new_set: new set to switch to, if NULL follow normal chain
-+ */
-+enum hrtimer_restart pfm_switch_sets(struct pfm_context *ctx,
-+				     struct pfm_event_set *new_set,
-+				     int reset_mode,
-+				     int no_restart)
-+{
-+	struct pfm_event_set *set;
-+	u64 now, end;
-+	u32 new_flags;
-+	int is_system, is_active, nn;
-+	enum hrtimer_restart ret = HRTIMER_NORESTART;
-+
-+	now = sched_clock();
-+	set = ctx->active_set;
-+	is_active = pfm_arch_is_active(ctx);
-+
-+	/*
-+	 * if no set is explicitly requested,
-+	 * use the set_switch_next field
-+	 */
-+	if (!new_set) {
-+		/*
-+		 * we use round-robin unless the user specified
-+		 * a particular set to go to.
-+		 */
-+		new_set = list_first_entry(&set->list, struct pfm_event_set, list);
-+		if (&new_set->list == &ctx->set_list)
-+			new_set = list_first_entry(&ctx->set_list, struct pfm_event_set, list);
-+	}
-+
-+	PFM_DBG_ovfl("state=%d act=%d cur_set=%u cur_runs=%llu cur_npend=%d next_set=%u "
-+		  "next_runs=%llu new_npend=%d reset_mode=%d reset_pmds=%llx",
-+		  ctx->state,
-+		  is_active,
-+		  set->id,
-+		  (unsigned long long)set->runs,
-+		  set->npend_ovfls,
-+		  new_set->id,
-+		  (unsigned long long)new_set->runs,
-+		  new_set->npend_ovfls,
-+		  reset_mode,
-+		  (unsigned long long)new_set->reset_pmds[0]);
-+
-+	is_system = ctx->flags.system;
-+	new_flags = new_set->flags;
-+
-+	/*
-+	 * nothing more to do
-+	 */
-+	if (new_set == set)
-+		goto skip_same_set;
-+
-+	if (is_active) {
-+		pfm_arch_stop(current, ctx);
-+		pfm_save_pmds(ctx, set);
-+		/*
-+		 * compute elapsed ns for active set
-+		 */
-+		set->duration += now - set->duration_start;
-+	}
-+
-+	pfm_arch_restore_pmds(ctx, new_set);
-+	/*
-+	 * if masked, we must restore the pmcs such that they
-+	 * do not capture anything.
-+	 */
-+	pfm_arch_restore_pmcs(ctx, new_set);
-+
-+	if (new_set->npend_ovfls) {
-+		pfm_arch_resend_irq(ctx);
-+		pfm_stats_inc(ovfl_intr_replay_count);
-+	}
-+
-+	new_set->priv_flags &= ~PFM_SETFL_PRIV_MOD_BOTH;
-+
-+skip_same_set:
-+	new_set->runs++;
-+	/*
-+	 * reset switch threshold
-+	 */
-+	if (new_flags & PFM_SETFL_OVFL_SWITCH)
-+		pfm_reload_switch_thresholds(ctx, new_set);
-+
-+	/*
-+	 * reset overflowed PMD registers in new set
-+	 */
-+	nn = bitmap_weight(cast_ulp(new_set->reset_pmds), ctx->regs.max_pmd);
-+	if (nn)
-+		pfm_reset_pmds(ctx, new_set, nn, reset_mode);
-+
-+
-+	/*
-+	 * This is needed when coming from pfm_start()
-+	 *
-+	 * When switching to the same set, there is no
-+	 * need to restart
-+	 */
-+	if (no_restart)
-+		goto skip_restart;
-+
-+	if (is_active) {
-+		/*
-+		 * do not need to restart when same set
-+		 */
-+		if (new_set != set) {
-+			ctx->active_set = new_set;
-+			new_set->duration_start = now;
-+			pfm_arch_start(current, ctx);
-+		}
-+		/*
-+		 * install new timeout if necessary
-+		 */
-+		if (new_flags & PFM_SETFL_TIME_SWITCH) {
-+			struct hrtimer *h;
-+			h = &__get_cpu_var(pfm_hrtimer);
-+			hrtimer_forward(h, h->base->get_time(), new_set->hrtimer_exp);
-+			new_set->hrtimer_rem = new_set->hrtimer_exp;
-+			ret = HRTIMER_RESTART;
-+		}
-+	}
-+
-+skip_restart:
-+	ctx->active_set = new_set;
-+
-+	end = sched_clock();
-+
-+	pfm_stats_inc(set_switch_count);
-+	pfm_stats_add(set_switch_ns, end - now);
-+
-+	return ret;
-+}
-+
-+/*
-+ * called from __pfm_overflow_handler() to switch event sets.
-+ * monitoring is stopped, task is current, interrupts are masked.
-+ * compared to pfm_switch_sets(), this version is simplified because
-+ * it knows about the call path. There is no need to stop monitoring
-+ * because it is already frozen by PMU handler.
-+ */
-+void pfm_switch_sets_from_intr(struct pfm_context *ctx)
-+{
-+	struct pfm_event_set *set, *new_set;
-+	u64 now, end;
-+	u32 new_flags;
-+	int is_system, n;
-+
-+	now = sched_clock();
-+	set = ctx->active_set;
-+	new_set = list_first_entry(&set->list, struct pfm_event_set, list);
-+	if (&new_set->list == &ctx->set_list)
-+		new_set = list_first_entry(&ctx->set_list, struct pfm_event_set, list);
-+
-+	PFM_DBG_ovfl("state=%d cur_set=%u cur_runs=%llu cur_npend=%d next_set=%u "
-+		  "next_runs=%llu new_npend=%d new_r_pmds=%llx",
-+		  ctx->state,
-+		  set->id,
-+		  (unsigned long long)set->runs,
-+		  set->npend_ovfls,
-+		  new_set->id,
-+		  (unsigned long long)new_set->runs,
-+		  new_set->npend_ovfls,
-+		  (unsigned long long)new_set->reset_pmds[0]);
-+
-+	is_system = ctx->flags.system;
-+	new_flags = new_set->flags;
-+
-+	/*
-+	 * nothing more to do
-+	 */
-+	if (new_set == set)
-+		goto skip_same_set;
-+
-+	/*
-+	 * switch on intr only when set has OVFL_SWITCH
-+	 */
-+	BUG_ON(set->flags & PFM_SETFL_TIME_SWITCH);
-+
-+	/*
-+	 * when called from PMU intr handler, monitoring
-+	 * is already stopped
-+	 *
-+	 * save current PMD registers, we use a special
-+	 * form for performance reason. On some architectures,
-+	 * such as x86, the pmds are already saved when entering
-+	 * the PMU interrupt handler via pfm-arch_intr_freeze()
-+	 * so we don't need to save them again. On the contrary,
-+	 * on IA-64, they are not saved by freeze, thus we have to
-+	 * to it here.
-+	 */
-+	pfm_arch_save_pmds_from_intr(ctx, set);
-+
-+	/*
-+	 * compute elapsed ns for active set
-+	 */
-+	set->duration += now - set->duration_start;
-+
-+	pfm_arch_restore_pmds(ctx, new_set);
-+
-+	/*
-+	 * must not be restored active as we are still executing in the
-+	 * PMU interrupt handler. activation is deferred to unfreeze PMU
-+	 */
-+	pfm_arch_restore_pmcs(ctx, new_set);
-+
-+	/*
-+	 * check for pending interrupt on incoming set.
-+	 * interrupts are masked so handler call deferred
-+	 */
-+	if (new_set->npend_ovfls) {
-+		pfm_arch_resend_irq(ctx);
-+		pfm_stats_inc(ovfl_intr_replay_count);
-+	}
-+	/*
-+	 * no need to restore anything, that is already done
-+	 */
-+	new_set->priv_flags &= ~PFM_SETFL_PRIV_MOD_BOTH;
-+	/*
-+	 * reset duration counter
-+	 */
-+	new_set->duration_start = now;
-+
-+skip_same_set:
-+	new_set->runs++;
-+
-+	/*
-+	 * reset switch threshold
-+	 */
-+	if (new_flags & PFM_SETFL_OVFL_SWITCH)
-+		pfm_reload_switch_thresholds(ctx, new_set);
-+
-+	/*
-+	 * reset overflowed PMD registers
-+	 */
-+	n = bitmap_weight(cast_ulp(new_set->reset_pmds), ctx->regs.max_pmd);
-+	if (n)
-+		pfm_reset_pmds(ctx, new_set, n, PFM_PMD_RESET_SHORT);
-+
-+	/*
-+	 * XXX: isactive?
-+	 *
-+	 * Came here following a interrupt which triggered a switch, i.e.,
-+	 * previous set was using OVFL_SWITCH, thus we just need to arm
-+	 * check if the next set is using timeout, and if so arm the timer.
-+	 *
-+	 * Timeout is always at least one tick away. No risk of having to
-+	 * invoke the timeout handler right now. In any case, cb_mode is
-+	 * set to HRTIMER_CB_IRQSAFE_NO_SOFTIRQ such that hrtimer_start
-+	 * will not try to wakeup the softirqd which could cause a locking
-+	 * problem.
-+	 */
-+	if (new_flags & PFM_SETFL_TIME_SWITCH) {
-+		hrtimer_start(&__get_cpu_var(pfm_hrtimer), set->hrtimer_exp, HRTIMER_MODE_REL);
-+		PFM_DBG("armed new timeout for set%u", new_set->id);
-+	}
-+
-+	ctx->active_set = new_set;
-+
-+	end = sched_clock();
-+
-+	pfm_stats_inc(set_switch_count);
-+	pfm_stats_add(set_switch_ns, end - now);
-+}
-+
-+
-+static int pfm_setfl_sane(struct pfm_context *ctx, u32 flags)
-+{
-+#define PFM_SETFL_BOTH_SWITCH	(PFM_SETFL_OVFL_SWITCH|PFM_SETFL_TIME_SWITCH)
-+	int ret;
-+
-+	ret = pfm_arch_setfl_sane(ctx, flags);
-+	if (ret)
-+		return ret;
-+
-+	if ((flags & PFM_SETFL_BOTH_SWITCH) == PFM_SETFL_BOTH_SWITCH) {
-+		PFM_DBG("both switch ovfl and switch time are set");
-+		return -EINVAL;
-+	}
-+	return 0;
-+}
-+
-+/*
-+ * it is never possible to change the identification of an existing set
-+ */
-+static int pfm_change_evtset(struct pfm_context *ctx,
-+			       struct pfm_event_set *set,
-+			       struct pfarg_setdesc *req)
-+{
-+	struct timeval tv;
-+	struct timespec ts;
-+	ktime_t kt;
-+	long d, res_ns;
-+	s32 rem;
-+	u32 flags;
-+	int ret;
-+	u16 set_id;
-+
-+	BUG_ON(ctx->state == PFM_CTX_LOADED);
-+
-+	set_id = req->set_id;
-+	flags = req->set_flags;
-+
-+	ret = pfm_setfl_sane(ctx, flags);
-+	if (ret) {
-+		PFM_DBG("invalid flags 0x%x set %u", flags, set_id);
-+		return -EINVAL;
-+	}
-+
-+	/*
-+	 * compute timeout value
-+	 */
-+	if (flags & PFM_SETFL_TIME_SWITCH) {
-+		/*
-+		 * timeout value of zero is illegal
-+		 */
-+		if (req->set_timeout == 0) {
-+			PFM_DBG("invalid timeout 0");
-+			return -EINVAL;
-+		}
-+
-+		hrtimer_get_res(CLOCK_MONOTONIC, &ts);
-+		res_ns = (long)ktime_to_ns(timespec_to_ktime(ts));
-+
-+		/*
-+		 * round-up to multiple of clock resolution
-+		 * timeout = ((req->set_timeout+res_ns-1)/res_ns)*res_ns;
-+		 *
-+		 * u64 division missing on 32-bit arch, so use div_s64_rem
-+		 */
-+		d = div_s64_rem(req->set_timeout, res_ns, &rem);
-+
-+		PFM_DBG("set%u flags=0x%x req_timeout=%lluns "
-+				"HZ=%u TICK_NSEC=%lu clock_res=%ldns rem=%dns",
-+				set_id,
-+				flags,
-+				(unsigned long long)req->set_timeout,
-+				HZ, TICK_NSEC,
-+				res_ns,
-+				rem);
-+
-+		/*
-+		 * Only accept timeout, we can actually achieve.
-+		 * users can invoke clock_getres(CLOCK_MONOTONIC)
-+		 * to figure out resolution and adjust timeout
-+		 */
-+		if (rem) {
-+			PFM_DBG("set%u invalid timeout=%llu",
-+				set_id,
-+				(unsigned long long)req->set_timeout);
-+			return -EINVAL;
-+		}
-+
-+		tv = ns_to_timeval(req->set_timeout);
-+		kt = timeval_to_ktime(tv);
-+		set->hrtimer_exp = kt;
-+	} else {
-+		set->hrtimer_exp = ktime_set(0, 0);
-+	}
-+
-+	/*
-+	 * commit changes
-+	 */
-+	set->id = set_id;
-+	set->flags = flags;
-+	set->priv_flags = 0;
-+
-+	/*
-+	 * activation and duration counters are reset as
-+	 * most likely major things will change in the set
-+	 */
-+	set->runs = 0;
-+	set->duration = 0;
-+
-+	return 0;
-+}
-+
-+/*
-+ * this function does not modify the next field
-+ */
-+static void pfm_initialize_set(struct pfm_context *ctx,
-+			       struct pfm_event_set *set)
-+{
-+	u64 *impl_pmcs;
-+	u16 i, max_pmc;
-+
-+	max_pmc = ctx->regs.max_pmc;
-+	impl_pmcs =  ctx->regs.pmcs;
-+
-+	/*
-+	 * install default values for all PMC  registers
-+	 */
-+	for (i = 0; i < max_pmc; i++) {
-+		if (test_bit(i, cast_ulp(impl_pmcs))) {
-+			set->pmcs[i] = pfm_pmu_conf->pmc_desc[i].dfl_val;
-+			PFM_DBG("set%u pmc%u=0x%llx",
-+				set->id,
-+				i,
-+				(unsigned long long)set->pmcs[i]);
-+		}
-+	}
-+
-+	/*
-+	 * PMD registers are set to 0 when the event set is allocated,
-+	 * hence we do not need to explicitly initialize them.
-+	 *
-+	 * For virtual PMD registers (i.e., those tied to a SW resource)
-+	 * their value becomes meaningful once the context is attached.
-+	 */
-+}
-+
-+/*
-+ * look for an event set using its identification. If the set does not
-+ * exist:
-+ * 	- if alloc == 0 then return error
-+ * 	- if alloc == 1  then allocate set
-+ *
-+ * alloc is one ONLY when coming from pfm_create_evtsets() which can only
-+ * be called when the context is detached, i.e. monitoring is stopped.
-+ */
-+struct pfm_event_set *pfm_find_set(struct pfm_context *ctx, u16 set_id, int alloc)
-+{
-+	struct pfm_event_set *set = NULL, *prev, *new_set;
-+
-+	PFM_DBG("looking for set=%u", set_id);
-+
-+	prev = NULL;
-+	list_for_each_entry(set, &ctx->set_list, list) {
-+		if (set->id == set_id)
-+			return set;
-+		if (set->id > set_id)
-+			break;
-+		prev = set;
-+	}
-+
-+	if (!alloc)
-+		return NULL;
-+
-+	/*
-+	 * we are holding the context spinlock and interrupts
-+	 * are unmasked. We must use GFP_ATOMIC as we cannot
-+	 * sleep while holding a spin lock.
-+	 */
-+	new_set = kmem_cache_zalloc(pfm_set_cachep, GFP_ATOMIC);
-+	if (!new_set)
-+		return NULL;
-+
-+	new_set->id = set_id;
-+
-+	INIT_LIST_HEAD(&new_set->list);
-+
-+	if (prev == NULL) {
-+		list_add(&(new_set->list), &ctx->set_list);
-+	} else {
-+		PFM_DBG("add after set=%u", prev->id);
-+		list_add(&(new_set->list), &prev->list);
-+	}
-+	return new_set;
-+}
-+
-+/**
-+ * pfm_create_initial_set - create initial set from __pfm_c reate_context
-+ * @ctx: context to atatched the set to
-+ */
-+int pfm_create_initial_set(struct pfm_context *ctx)
-+{
-+	struct pfm_event_set *set;
-+
-+	/*
-+	 * create initial set0
-+	 */
-+	if (!pfm_find_set(ctx, 0, 1))
-+		return -ENOMEM;
-+
-+	set = list_first_entry(&ctx->set_list, struct pfm_event_set, list);
-+
-+	pfm_initialize_set(ctx, set);
-+
-+	return 0;
-+}
-+
-+/*
-+ * context is unloaded for this command. Interrupts are enabled
-+ */
-+int __pfm_create_evtsets(struct pfm_context *ctx, struct pfarg_setdesc *req,
-+			int count)
-+{
-+	struct pfm_event_set *set;
-+	u16 set_id;
-+	int i, ret;
-+
-+	for (i = 0; i < count; i++, req++) {
-+		set_id = req->set_id;
-+
-+		PFM_DBG("set_id=%u", set_id);
-+
-+		set = pfm_find_set(ctx, set_id, 1);
-+		if (set == NULL)
-+			goto error_mem;
-+
-+		ret = pfm_change_evtset(ctx, set, req);
-+		if (ret)
-+			goto error_params;
-+
-+		pfm_initialize_set(ctx, set);
-+	}
-+	return 0;
-+error_mem:
-+	PFM_DBG("cannot allocate set %u", set_id);
-+	return -ENOMEM;
-+error_params:
-+	return ret;
-+}
-+
-+int __pfm_getinfo_evtsets(struct pfm_context *ctx, struct pfarg_setinfo *req,
-+				 int count)
-+{
-+	struct pfm_event_set *set;
-+	int i, is_system, is_loaded, is_self, ret;
-+	u16 set_id;
-+	u64 end;
-+
-+	end = sched_clock();
-+
-+	is_system = ctx->flags.system;
-+	is_loaded = ctx->state == PFM_CTX_LOADED;
-+	is_self   = ctx->task == current || is_system;
-+
-+	ret = -EINVAL;
-+	for (i = 0; i < count; i++, req++) {
-+
-+		set_id = req->set_id;
-+
-+		list_for_each_entry(set, &ctx->set_list, list) {
-+			if (set->id == set_id)
-+				goto found;
-+			if (set->id > set_id)
-+				goto error;
-+		}
-+found:
-+		req->set_flags = set->flags;
-+
-+		/*
-+		 * compute leftover timeout
-+		 *
-+		 * lockdep may complain about lock inversion
-+		 * because of get_remaining() however, this
-+		 * applies to self-montoring only, thus the
-+		 * thread cannot be in the timeout handler
-+		 * and here at the same time given that we
-+		 * run with interrupts disabled
-+		 */
-+		if (is_loaded && is_self) {
-+			struct hrtimer *h;
-+			h = &__get_cpu_var(pfm_hrtimer);
-+			req->set_timeout = ktime_to_ns(hrtimer_get_remaining(h));
-+		} else {
-+			/*
-+			 * hrtimer_rem zero when not using
-+			 * timeout-based switching
-+			 */
-+			req->set_timeout = ktime_to_ns(set->hrtimer_rem);
-+		}
-+
-+		req->set_runs = set->runs;
-+		req->set_act_duration = set->duration;
-+
-+		/*
-+		 * adjust for active set if needed
-+		 */
-+		if (is_system && is_loaded && ctx->flags.started
-+		    && set == ctx->active_set)
-+			req->set_act_duration  += end - set->duration_start;
-+
-+		/*
-+		 * copy the list of pmds which last overflowed
-+		 */
-+		bitmap_copy(cast_ulp(req->set_ovfl_pmds),
-+			    cast_ulp(set->ovfl_pmds),
-+			    PFM_MAX_PMDS);
-+
-+		/*
-+		 * copy bitmask of available PMU registers
-+		 *
-+		 * must copy over the entire vector to avoid
-+		 * returning bogus upper bits pass by user
-+		 */
-+		bitmap_copy(cast_ulp(req->set_avail_pmcs),
-+			    cast_ulp(ctx->regs.pmcs),
-+			    PFM_MAX_PMCS);
-+
-+		bitmap_copy(cast_ulp(req->set_avail_pmds),
-+			    cast_ulp(ctx->regs.pmds),
-+			    PFM_MAX_PMDS);
-+
-+		PFM_DBG("set%u flags=0x%x eff_usec=%llu runs=%llu "
-+			"a_pmcs=0x%llx a_pmds=0x%llx",
-+			set_id,
-+			set->flags,
-+			(unsigned long long)req->set_timeout,
-+			(unsigned long long)set->runs,
-+			(unsigned long long)ctx->regs.pmcs[0],
-+			(unsigned long long)ctx->regs.pmds[0]);
-+	}
-+	ret = 0;
-+error:
-+	return ret;
-+}
-+
-+/*
-+ * context is unloaded for this command. Interrupts are enabled
-+ */
-+int __pfm_delete_evtsets(struct pfm_context *ctx, void *arg, int count)
-+{
-+	struct pfarg_setdesc *req = arg;
-+	struct pfm_event_set *set;
-+	u16 set_id;
-+	int i, ret;
-+
-+	ret = -EINVAL;
-+	for (i = 0; i < count; i++, req++) {
-+		set_id = req->set_id;
-+
-+		list_for_each_entry(set, &ctx->set_list, list) {
-+			if (set->id == set_id)
-+				goto found;
-+			if (set->id > set_id)
-+				goto error;
-+		}
-+		goto error;
-+found:
-+		/*
-+		 * clear active set if necessary.
-+		 * will be updated when context is loaded
-+		 */
-+		if (set == ctx->active_set)
-+			ctx->active_set = NULL;
-+
-+		list_del(&set->list);
-+
-+		kmem_cache_free(pfm_set_cachep, set);
-+
-+		PFM_DBG("set%u deleted", set_id);
-+	}
-+	ret = 0;
-+error:
-+	return ret;
-+}
-+
-+/*
-+ * called from pfm_context_free() to free all sets
-+ */
-+void pfm_free_sets(struct pfm_context *ctx)
-+{
-+	struct pfm_event_set *set, *tmp;
-+
-+	list_for_each_entry_safe(set, tmp, &ctx->set_list, list) {
-+		list_del(&set->list);
-+		kmem_cache_free(pfm_set_cachep, set);
-+	}
-+}
-+
-+/**
-+ * pfm_restart_timer - restart hrtimer taking care of expired timeout
-+ * @ctx : context to work with
-+ * @set : current active set
-+ *
-+ * Must be called on the processor on which the timer is to be armed.
-+ * Assumes context is locked and interrupts are masked
-+ *
-+ * Upon return the active set for the context may have changed
-+ */
-+void pfm_restart_timer(struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	struct hrtimer *h;
-+	enum hrtimer_restart ret;
-+
-+	h = &__get_cpu_var(pfm_hrtimer);
-+
-+	PFM_DBG_ovfl("hrtimer=%lld", (long long)ktime_to_ns(set->hrtimer_rem));
-+
-+	if (ktime_to_ns(set->hrtimer_rem) > 0) {
-+		hrtimer_start(h, set->hrtimer_rem, HRTIMER_MODE_REL);
-+	} else {
-+		/*
-+		 * timer was not re-armed because it has already expired
-+		 * timer was not enqueued, we need to switch set now
-+		 */
-+		pfm_stats_inc(set_switch_exp);
-+
-+		ret = pfm_switch_sets(ctx, NULL, 1, 0);
-+		set = ctx->active_set;
-+		if (ret == HRTIMER_RESTART)
-+			hrtimer_start(h, set->hrtimer_rem, HRTIMER_MODE_REL);
-+	}
-+}
-+
-+int __init pfm_init_sets(void)
-+{
-+	pfm_set_cachep = kmem_cache_create("pfm_event_set",
-+					   sizeof(struct pfm_event_set),
-+					   SLAB_HWCACHE_ALIGN, 0, NULL);
-+	if (!pfm_set_cachep) {
-+		PFM_ERR("cannot initialize event set slab");
-+		return -ENOMEM;
-+	}
-+	return 0;
-+}
-diff --git a/perfmon/perfmon_smpl.c b/perfmon/perfmon_smpl.c
-new file mode 100644
-index 0000000..e31fb15
---- /dev/null
-+++ b/perfmon/perfmon_smpl.c
-@@ -0,0 +1,865 @@
-+/*
-+ * perfmon_smpl.c: perfmon2 sampling management
-+ *
-+ * This file implements the perfmon2 interface which
-+ * provides access to the hardware performance counters
-+ * of the host processor.
-+ *
-+ *
-+ * The initial version of perfmon.c was written by
-+ * Ganesh Venkitachalam, IBM Corp.
-+ *
-+ * Then it was modified for perfmon-1.x by Stephane Eranian and
-+ * David Mosberger, Hewlett Packard Co.
-+ *
-+ * Version Perfmon-2.x is a complete rewrite of perfmon-1.x
-+ * by Stephane Eranian, Hewlett Packard Co.
-+ *
-+ * Copyright (c) 1999-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *                David Mosberger-Tang <davidm@hpl.hp.com>
-+ *
-+ * More information about perfmon available at:
-+ * 	http://perfmon2.sf.net
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/module.h>
-+#include <linux/kernel.h>
-+#include <linux/vmalloc.h>
-+#include <linux/fs.h>
-+#include <linux/mm.h>
-+#include <linux/random.h>
-+#include <linux/uaccess.h>
-+#include <linux/perfmon_kern.h>
-+
-+#include "perfmon_priv.h"
-+
-+/**
-+ * pfm_smpl_buf_alloc - allocate memory for sampling buffer
-+ * @ctx: context to operate on
-+ * @rsize: requested size
-+ *
-+ * called from pfm_smpl_buffer_alloc_old() (IA64-COMPAT)
-+ * and pfm_setup_smpl_fmt()
-+ *
-+ * interrupts are enabled, context is not locked.
-+ *
-+ * function is not static because it is called from the IA-64
-+ * compatibility module (perfmon_compat.c)
-+ */
-+int pfm_smpl_buf_alloc(struct pfm_context *ctx, size_t rsize)
-+{
-+#if PFM_ARCH_SMPL_ALIGN_SIZE > 0
-+#define PFM_ALIGN_SMPL(a, f) (void *)((((unsigned long)(a))+(f-1)) & ~(f-1))
-+#else
-+#define PFM_ALIGN_SMPL(a, f) (a)
-+#endif
-+	void *addr, *real_addr;
-+	size_t size, real_size;
-+	int ret;
-+
-+	might_sleep();
-+
-+	/*
-+	 * align page boundary
-+	 */
-+	size = PAGE_ALIGN(rsize);
-+
-+	/*
-+	 * On some arch, it may be necessary to get an alignment greater
-+	 * than page size to avoid certain cache effects (e.g., MIPS).
-+	 * This is the reason for PFM_ARCH_SMPL_ALIGN_SIZE.
-+	 */
-+	real_size = size + PFM_ARCH_SMPL_ALIGN_SIZE;
-+
-+	PFM_DBG("req_size=%zu size=%zu real_size=%zu",
-+		rsize,
-+		size,
-+		real_size);
-+
-+	ret = pfm_smpl_buf_space_acquire(ctx, real_size);
-+	if (ret)
-+		return ret;
-+
-+	/*
-+	 * vmalloc can sleep. we do not hold
-+	 * any spinlock and interrupts are enabled
-+	 */
-+	real_addr = addr = vmalloc(real_size);
-+	if (!real_addr) {
-+		PFM_DBG("cannot allocate sampling buffer");
-+		goto unres;
-+	}
-+
-+	/*
-+	 * align the useable sampling buffer address to the arch requirement
-+	 * This is a nop on most architectures
-+	 */
-+	addr = PFM_ALIGN_SMPL(real_addr, PFM_ARCH_SMPL_ALIGN_SIZE);
-+
-+	memset(addr, 0, real_size);
-+
-+	/*
-+	 * due to cache aliasing, it may be necessary to flush the pages
-+	 * on certain architectures (e.g., MIPS)
-+	 */
-+	pfm_cacheflush(addr, real_size);
-+
-+	/*
-+	 * what needs to be freed
-+	 */
-+	ctx->smpl_real_addr = real_addr;
-+	ctx->smpl_real_size = real_size;
-+
-+	/*
-+	 * what is actually available to user
-+	 */
-+	ctx->smpl_addr = addr;
-+	ctx->smpl_size = size;
-+
-+	PFM_DBG("addr=%p real_addr=%p", addr, real_addr);
-+
-+	return 0;
-+unres:
-+	/*
-+	 * smpl_addr is NULL, no double freeing possible in pfm_context_free()
-+	 */
-+	pfm_smpl_buf_space_release(ctx, real_size);
-+
-+	return -ENOMEM;
-+}
-+
-+/**
-+ * pfm_smpl_buf_free - free resources associated with sampling
-+ * @ctx: context to operate on
-+ */
-+void pfm_smpl_buf_free(struct pfm_context *ctx)
-+{
-+	struct pfm_smpl_fmt *fmt;
-+
-+	fmt = ctx->smpl_fmt;
-+
-+	/*
-+	 * some formats may not use a buffer, yet they may
-+	 * need to be called on exit
-+	 */
-+	if (fmt) {
-+		if (fmt->fmt_exit)
-+			(*fmt->fmt_exit)(ctx->smpl_addr);
-+		/*
-+		 * decrease refcount of sampling format
-+		 */
-+		pfm_smpl_fmt_put(fmt);
-+	}
-+
-+	if (ctx->smpl_addr) {
-+		pfm_smpl_buf_space_release(ctx, ctx->smpl_real_size);
-+
-+		PFM_DBG("free buffer real_addr=0x%p real_size=%zu",
-+			ctx->smpl_real_addr,
-+			ctx->smpl_real_size);
-+
-+		vfree(ctx->smpl_real_addr);
-+	}
-+}
-+
-+/**
-+ * pfm_setup_smpl_fmt - initialization of sampling format and buffer
-+ * @ctx: context to operate on
-+ * @fmt_arg: smapling format arguments
-+ * @ctx_flags: context flags as passed by user
-+ * @filp: file descriptor associated with context
-+ *
-+ * called from __pfm_create_context()
-+ */
-+int pfm_setup_smpl_fmt(struct pfm_context *ctx, u32 ctx_flags, void *fmt_arg,
-+		       struct file *filp)
-+{
-+	struct pfm_smpl_fmt *fmt;
-+	size_t size = 0;
-+	int ret = 0;
-+
-+	fmt = ctx->smpl_fmt;
-+
-+	/*
-+	 * validate parameters
-+	 */
-+	if (fmt->fmt_validate) {
-+		ret = (*fmt->fmt_validate)(ctx_flags,
-+					   ctx->regs.num_pmds,
-+					   fmt_arg);
-+		PFM_DBG("validate(0x%x,%p)=%d", ctx_flags, fmt_arg, ret);
-+		if (ret)
-+			goto error;
-+	}
-+
-+	/*
-+	 * check if buffer format needs buffer allocation
-+	 */
-+	size = 0;
-+	if (fmt->fmt_getsize) {
-+		ret = (*fmt->fmt_getsize)(ctx_flags, fmt_arg, &size);
-+		if (ret) {
-+			PFM_DBG("cannot get size ret=%d", ret);
-+			goto error;
-+		}
-+	}
-+
-+	/*
-+	 * allocate buffer
-+	 * v20_compat is for IA-64 backward compatibility with perfmon v2.0
-+	 */
-+	if (size) {
-+#ifdef CONFIG_IA64_PERFMON_COMPAT
-+		/*
-+		 * backward compatibility with perfmon v2.0 on Ia-64
-+		 */
-+		if (ctx->flags.ia64_v20_compat)
-+			ret = pfm_smpl_buf_alloc_compat(ctx, size, filp);
-+		else
-+#endif
-+			ret = pfm_smpl_buf_alloc(ctx, size);
-+
-+		if (ret)
-+			goto error;
-+
-+	}
-+
-+	if (fmt->fmt_init) {
-+		ret = (*fmt->fmt_init)(ctx, ctx->smpl_addr, ctx_flags,
-+				       ctx->regs.num_pmds,
-+				       fmt_arg);
-+	}
-+	/*
-+	 * if there was an error, the buffer/resource will be freed by
-+	 * via pfm_context_free()
-+	 */
-+error:
-+	return ret;
-+}
-+
-+void pfm_mask_monitoring(struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	u64 now;
-+
-+	now = sched_clock();
-+
-+	/*
-+	 * we save the PMD values such that we can read them while
-+	 * MASKED without having the thread stopped
-+	 * because monitoring is stopped
-+	 *
-+	 * pfm_save_pmds() could be avoided if we knew
-+	 * that pfm_arch_intr_freeze() had saved them already
-+	 */
-+	pfm_save_pmds(ctx, set);
-+	pfm_arch_mask_monitoring(ctx, set);
-+	/*
-+	 * accumulate the set duration up to this point
-+	 */
-+	set->duration += now - set->duration_start;
-+
-+	ctx->state = PFM_CTX_MASKED;
-+
-+	/*
-+	 * need to stop timer and remember remaining time
-+	 * will be reloaded in pfm_unmask_monitoring
-+	 * hrtimer is cancelled in the tail of the interrupt
-+	 * handler once the context is unlocked
-+	 */
-+	if (set->flags & PFM_SETFL_TIME_SWITCH) {
-+		struct hrtimer *h = &__get_cpu_var(pfm_hrtimer);
-+		hrtimer_cancel(h);
-+		set->hrtimer_rem = hrtimer_get_remaining(h);
-+	}
-+	PFM_DBG_ovfl("can_restart=%u", ctx->flags.can_restart);
-+}
-+
-+/**
-+ * pfm_unmask_monitoring - unmask monitoring
-+ * @ctx: context to work with
-+ * @set: current active set
-+ *
-+ * interrupts are masked when entering this function.
-+ * context must be in MASKED state when calling.
-+ *
-+ * Upon return, the active set may have changed when using timeout
-+ * based switching.
-+ */
-+static void pfm_unmask_monitoring(struct pfm_context *ctx, struct pfm_event_set *set)
-+{
-+	if (ctx->state != PFM_CTX_MASKED)
-+		return;
-+
-+	PFM_DBG_ovfl("unmasking monitoring");
-+
-+	/*
-+	 * must be done before calling
-+	 * pfm_arch_unmask_monitoring()
-+	 */
-+	ctx->state = PFM_CTX_LOADED;
-+
-+	/*
-+	 * we need to restore the PMDs because they
-+	 * may have been modified by user while MASKED in
-+	 * which case the actual registers have no yet
-+	 * been updated
-+	 */
-+	pfm_arch_restore_pmds(ctx, set);
-+
-+	/*
-+	 * call arch specific handler
-+	 */
-+	pfm_arch_unmask_monitoring(ctx, set);
-+
-+	/*
-+	 * clear force reload flag. May have been set
-+	 * in pfm_write_pmcs or pfm_write_pmds
-+	 */
-+	set->priv_flags &= ~PFM_SETFL_PRIV_MOD_BOTH;
-+
-+	/*
-+	 * reset set duration timer
-+	 */
-+	set->duration_start = sched_clock();
-+
-+	/*
-+	 * restart hrtimer if needed
-+	 */
-+	if (set->flags & PFM_SETFL_TIME_SWITCH) {
-+		pfm_restart_timer(ctx, set);
-+		/* careful here as pfm_restart_timer may switch sets */
-+	}
-+}
-+
-+void pfm_reset_pmds(struct pfm_context *ctx,
-+		    struct pfm_event_set *set,
-+		    int num_pmds,
-+		    int reset_mode)
-+{
-+	u64 val, mask, new_seed;
-+	struct pfm_pmd *reg;
-+	unsigned int i, not_masked;
-+
-+	not_masked = ctx->state != PFM_CTX_MASKED;
-+
-+	PFM_DBG_ovfl("%s r_pmds=0x%llx not_masked=%d",
-+		reset_mode == PFM_PMD_RESET_LONG ? "long" : "short",
-+		(unsigned long long)set->reset_pmds[0],
-+		not_masked);
-+
-+	pfm_stats_inc(reset_pmds_count);
-+
-+	for (i = 0; num_pmds; i++) {
-+		if (test_bit(i, cast_ulp(set->reset_pmds))) {
-+			num_pmds--;
-+
-+			reg = set->pmds + i;
-+
-+			val = reset_mode == PFM_PMD_RESET_LONG ?
-+			       reg->long_reset : reg->short_reset;
-+
-+			if (reg->flags & PFM_REGFL_RANDOM) {
-+				mask = reg->mask;
-+				new_seed = random32();
-+
-+				/* construct a full 64-bit random value: */
-+				if ((unlikely(mask >> 32) != 0))
-+					new_seed |= (u64)random32() << 32;
-+
-+				/* counter values are negative numbers! */
-+				val -= (new_seed & mask);
-+			}
-+
-+			set->pmds[i].value = val;
-+			reg->lval = val;
-+
-+			/*
-+			 * not all PMD to reset are necessarily
-+			 * counters
-+			 */
-+			if (not_masked)
-+				pfm_write_pmd(ctx, i, val);
-+
-+			PFM_DBG_ovfl("set%u pmd%u sval=0x%llx",
-+					set->id,
-+					i,
-+					(unsigned long long)val);
-+		}
-+	}
-+
-+	/*
-+	 * done with reset
-+	 */
-+	bitmap_zero(cast_ulp(set->reset_pmds), i);
-+
-+	/*
-+	 * make changes visible
-+	 */
-+	if (not_masked)
-+		pfm_arch_serialize();
-+}
-+
-+/*
-+ * called from pfm_handle_work() and __pfm_restart()
-+ * for system-wide and per-thread context to resume
-+ * monitoring after a user level notification.
-+ *
-+ * In both cases, the context is locked and interrupts
-+ * are disabled.
-+ */
-+void pfm_resume_after_ovfl(struct pfm_context *ctx)
-+{
-+	struct pfm_smpl_fmt *fmt;
-+	u32 rst_ctrl;
-+	struct pfm_event_set *set;
-+	u64 *reset_pmds;
-+	void *hdr;
-+	int state, ret;
-+
-+	hdr = ctx->smpl_addr;
-+	fmt = ctx->smpl_fmt;
-+	state = ctx->state;
-+	set = ctx->active_set;
-+	ret = 0;
-+
-+	if (hdr) {
-+		rst_ctrl = 0;
-+		prefetch(hdr);
-+	} else {
-+		rst_ctrl = PFM_OVFL_CTRL_RESET;
-+	}
-+
-+	/*
-+	 * if using a sampling buffer format and it has a restart callback,
-+	 * then invoke it. hdr may be NULL, if the format does not use a
-+	 * perfmon buffer
-+	 */
-+	if (fmt && fmt->fmt_restart)
-+		ret = (*fmt->fmt_restart)(state == PFM_CTX_LOADED, &rst_ctrl,
-+					  hdr);
-+
-+	reset_pmds = set->reset_pmds;
-+
-+	PFM_DBG("fmt_restart=%d reset_count=%d set=%u r_pmds=0x%llx switch=%d "
-+		"ctx_state=%d",
-+		ret,
-+		ctx->flags.reset_count,
-+		set->id,
-+		(unsigned long long)reset_pmds[0],
-+		(set->priv_flags & PFM_SETFL_PRIV_SWITCH),
-+		state);
-+
-+	if (!ret) {
-+		/*
-+		 * switch set if needed
-+		 */
-+		if (set->priv_flags & PFM_SETFL_PRIV_SWITCH) {
-+			set->priv_flags &= ~PFM_SETFL_PRIV_SWITCH;
-+			pfm_switch_sets(ctx, NULL, PFM_PMD_RESET_LONG, 0);
-+			set = ctx->active_set;
-+		} else if (rst_ctrl & PFM_OVFL_CTRL_RESET) {
-+			int nn;
-+			nn = bitmap_weight(cast_ulp(set->reset_pmds),
-+					   ctx->regs.max_pmd);
-+			if (nn)
-+				pfm_reset_pmds(ctx, set, nn, PFM_PMD_RESET_LONG);
-+		}
-+
-+		if (!(rst_ctrl & PFM_OVFL_CTRL_MASK))
-+			pfm_unmask_monitoring(ctx, set);
-+		else
-+			PFM_DBG("stopping monitoring?");
-+		ctx->state = PFM_CTX_LOADED;
-+	}
-+}
-+
-+/*
-+ * This function is called when we need to perform asynchronous
-+ * work on a context. This function is called ONLY when about to
-+ * return to user mode (very much like with signal handling).
-+ *
-+ * There are several reasons why we come here:
-+ *
-+ *  - per-thread mode, not self-monitoring, to reset the counters
-+ *    after a pfm_restart()
-+ *
-+ *  - we are zombie and we need to cleanup our state
-+ *
-+ *  - we need to block after an overflow notification
-+ *    on a context with the PFM_OVFL_NOTIFY_BLOCK flag
-+ *
-+ * This function is never called for a system-wide context.
-+ *
-+ * pfm_handle_work() can be called with interrupts enabled
-+ * (TIF_NEED_RESCHED) or disabled. The down_interruptible
-+ * call may sleep, therefore we must re-enable interrupts
-+ * to avoid deadlocks. It is safe to do so because this function
-+ * is called ONLY when returning to user level, in which case
-+ * there is no risk of kernel stack overflow due to deep
-+ * interrupt nesting.
-+ */
-+void pfm_handle_work(struct pt_regs *regs)
-+{
-+	struct pfm_context *ctx;
-+	unsigned long flags, dummy_flags;
-+	int type, ret, info;
-+
-+#ifdef CONFIG_PPC
-+	/*
-+	 * This is just a temporary fix. Obviously we'd like to fix the powerpc
-+	 * code to make that check before calling __pfm_handle_work() to
-+	 * prevent the function call overhead, but the call is made from
-+	 * assembly code, so it will take a little while to figure out how to
-+	 * perform the check correctly.
-+	 */
-+	if (!test_thread_flag(TIF_PERFMON_WORK))
-+		return;
-+#endif
-+
-+	if (!user_mode(regs))
-+		return;
-+
-+	clear_thread_flag(TIF_PERFMON_WORK);
-+
-+	pfm_stats_inc(handle_work_count);
-+
-+	ctx = current->pfm_context;
-+	if (ctx == NULL) {
-+		PFM_DBG("[%d] has no ctx", current->pid);
-+		return;
-+	}
-+
-+	BUG_ON(ctx->flags.system);
-+
-+	spin_lock_irqsave(&ctx->lock, flags);
-+
-+	type = ctx->flags.work_type;
-+	ctx->flags.work_type = PFM_WORK_NONE;
-+
-+	PFM_DBG("work_type=%d reset_count=%d",
-+		type,
-+		ctx->flags.reset_count);
-+
-+	switch (type) {
-+	case PFM_WORK_ZOMBIE:
-+		goto do_zombie;
-+	case PFM_WORK_RESET:
-+		/* simply reset, no blocking */
-+		goto skip_blocking;
-+	case PFM_WORK_NONE:
-+		PFM_DBG("unexpected PFM_WORK_NONE");
-+		goto nothing_todo;
-+	case PFM_WORK_BLOCK:
-+		break;
-+	default:
-+		PFM_DBG("unkown type=%d", type);
-+		goto nothing_todo;
-+	}
-+
-+	/*
-+	 * restore interrupt mask to what it was on entry.
-+	 * Could be enabled/disabled.
-+	 */
-+	spin_unlock_irqrestore(&ctx->lock, flags);
-+
-+	/*
-+	 * force interrupt enable because of down_interruptible()
-+	 */
-+	local_irq_enable();
-+
-+	PFM_DBG("before block sleeping");
-+
-+	/*
-+	 * may go through without blocking on SMP systems
-+	 * if restart has been received already by the time we call down()
-+	 */
-+	ret = wait_for_completion_interruptible(&ctx->restart_complete);
-+
-+	PFM_DBG("after block sleeping ret=%d", ret);
-+
-+	/*
-+	 * lock context and mask interrupts again
-+	 * We save flags into a dummy because we may have
-+	 * altered interrupts mask compared to entry in this
-+	 * function.
-+	 */
-+	spin_lock_irqsave(&ctx->lock, dummy_flags);
-+
-+	if (ctx->state == PFM_CTX_ZOMBIE)
-+		goto do_zombie;
-+
-+	/*
-+	 * in case of interruption of down() we don't restart anything
-+	 */
-+	if (ret < 0)
-+		goto nothing_todo;
-+
-+skip_blocking:
-+	/*
-+	 * iterate over the number of pending resets
-+	 * There are certain situations where there may be
-+	 * multiple notifications sent before a pfm_restart().
-+	 * As such, it may be that multiple pfm_restart() are
-+	 * issued before the monitored thread gets to
-+	 * pfm_handle_work(). To avoid losing restarts, pfm_restart()
-+	 * increments a counter (reset_counts). Here, we take this
-+	 * into account by potentially calling pfm_resume_after_ovfl()
-+	 * multiple times. It is up to the sampling format to take the
-+	 * appropriate actions.
-+	 */
-+	while (ctx->flags.reset_count) {
-+		pfm_resume_after_ovfl(ctx);
-+		/* careful as active set may have changed */
-+		ctx->flags.reset_count--;
-+	}
-+
-+nothing_todo:
-+	/*
-+	 * restore flags as they were upon entry
-+	 */
-+	spin_unlock_irqrestore(&ctx->lock, flags);
-+	return;
-+
-+do_zombie:
-+	PFM_DBG("context is zombie, bailing out");
-+
-+	__pfm_unload_context(ctx, &info);
-+
-+	/*
-+	 * keep the spinlock check happy
-+	 */
-+	spin_unlock(&ctx->lock);
-+
-+	/*
-+	 * enable interrupt for vfree()
-+	 */
-+	local_irq_enable();
-+
-+	/*
-+	 * cancel timer now that context is unlocked
-+	 */
-+	if (info & 0x2) {
-+		ret = hrtimer_cancel(&__get_cpu_var(pfm_hrtimer));
-+		PFM_DBG("timeout cancel=%d", ret);
-+	}
-+
-+	/*
-+	 * actual context free
-+	 */
-+	pfm_free_context(ctx);
-+
-+	/*
-+	 * restore interrupts as they were upon entry
-+	 */
-+	local_irq_restore(flags);
-+
-+	/* always true */
-+	if (info & 0x1)
-+		pfm_session_release(0, 0);
-+}
-+
-+/**
-+ * __pfm_restart - resume monitoring after user-level notification
-+ * @ctx: context to operate on
-+ * @info: return information used to free resource once unlocked
-+ *
-+ * function called from sys_pfm_restart(). It is used when overflow
-+ * notification is requested. For each notification received, the user
-+ * must call pfm_restart() to indicate to the kernel that it is done
-+ * processing the notification.
-+ *
-+ * When the caller is doing user level sampling, this function resets
-+ * the overflowed counters and resumes monitoring which is normally stopped
-+ * during notification (always the consequence of a counter overflow).
-+ *
-+ * When using a sampling format, the format restart() callback is invoked,
-+ * overflowed PMDS may be reset based upon decision from sampling format.
-+ *
-+ * When operating in per-thread mode, and when not self-monitoring, the
-+ * monitored thread DOES NOT need to be stopped, unlike for many other calls.
-+ *
-+ * This means that the effect of the restart may not necessarily be observed
-+ * right when returning from the call. For instance, counters may not already
-+ * be reset in the other thread.
-+ *
-+ * When operating in system-wide, the caller must be running on the monitored
-+ * CPU.
-+ *
-+ * The context is locked and interrupts are disabled.
-+ *
-+ * info value upon return:
-+ * 	- bit 0: when set, mudt issue complete() on restart semaphore
-+ */
-+int __pfm_restart(struct pfm_context *ctx, int *info)
-+{
-+	int state;
-+
-+	state = ctx->state;
-+
-+	PFM_DBG("state=%d can_restart=%d reset_count=%d",
-+		state,
-+		ctx->flags.can_restart,
-+		ctx->flags.reset_count);
-+
-+	*info = 0;
-+
-+	switch (state) {
-+	case PFM_CTX_MASKED:
-+		break;
-+	case PFM_CTX_LOADED:
-+		if (ctx->smpl_addr && ctx->smpl_fmt->fmt_restart)
-+			break;
-+	default:
-+		PFM_DBG("invalid state=%d", state);
-+		return -EBUSY;
-+	}
-+
-+	/*
-+	 * first check if allowed to restart, i.e., notifications received
-+	 */
-+	if (!ctx->flags.can_restart) {
-+		PFM_DBG("no restart can_restart=0");
-+		return -EBUSY;
-+	}
-+
-+	pfm_stats_inc(pfm_restart_count);
-+
-+	/*
-+	 * at this point, the context is either LOADED or MASKED
-+	 */
-+	ctx->flags.can_restart--;
-+
-+	/*
-+	 * handle self-monitoring case and system-wide
-+	 */
-+	if (ctx->task == current || ctx->flags.system) {
-+		pfm_resume_after_ovfl(ctx);
-+		return 0;
-+	}
-+
-+	/*
-+	 * restart another task
-+	 */
-+
-+	/*
-+	 * if blocking, then post the semaphore if PFM_CTX_MASKED, i.e.
-+	 * the task is blocked or on its way to block. That's the normal
-+	 * restart path. If the monitoring is not masked, then the task
-+	 * can be actively monitoring and we cannot directly intervene.
-+	 * Therefore we use the trap mechanism to catch the task and
-+	 * force it to reset the buffer/reset PMDs.
-+	 *
-+	 * if non-blocking, then we ensure that the task will go into
-+	 * pfm_handle_work() before returning to user mode.
-+	 *
-+	 * We cannot explicitly reset another task, it MUST always
-+	 * be done by the task itself. This works for system wide because
-+	 * the tool that is controlling the session is logically doing
-+	 * "self-monitoring".
-+	 */
-+	if (ctx->flags.block && state == PFM_CTX_MASKED) {
-+		PFM_DBG("unblocking [%d]", ctx->task->pid);
-+		/*
-+		 * It is not possible to call complete() with the context locked
-+		 * otherwise we have a potential deadlock with the PMU context
-+		 * switch code due to a lock inversion between task_rq_lock()
-+		 * and the context lock.
-+		 * Instead we mark whether or not we need to issue the complete
-+		 * and we invoke the function once the context lock is released
-+		 * in sys_pfm_restart()
-+		 */
-+		*info = 1;
-+	} else {
-+		PFM_DBG("[%d] armed exit trap", ctx->task->pid);
-+		pfm_post_work(ctx->task, ctx, PFM_WORK_RESET);
-+	}
-+	ctx->flags.reset_count++;
-+	return 0;
-+}
-+
-+/**
-+ * pfm_get_smpl_arg -- copy user arguments to pfm_create_context() related to sampling format
-+ * @name: format name as passed by user
-+ * @fmt_arg: format optional argument as passed by user
-+ * @uszie: size of structure pass in fmt_arg
-+ * @arg: kernel copy of fmt_arg
-+ * @fmt: pointer to sampling format upon success
-+ *
-+ * arg is kmalloc'ed, thus it needs a kfree by caller
-+ */
-+int pfm_get_smpl_arg(char __user *fmt_uname, void __user *fmt_uarg, size_t usize, void **arg,
-+		     struct pfm_smpl_fmt **fmt)
-+{
-+	struct pfm_smpl_fmt *f;
-+	char *fmt_name;
-+	void *addr = NULL;
-+	size_t sz;
-+	int ret;
-+
-+	fmt_name = getname(fmt_uname);
-+	if (!fmt_name) {
-+		PFM_DBG("getname failed");
-+		return -ENOMEM;
-+	}
-+
-+	/*
-+	 * find fmt and increase refcount
-+	 */
-+	f = pfm_smpl_fmt_get(fmt_name);
-+
-+	putname(fmt_name);
-+
-+	if (f == NULL) {
-+		PFM_DBG("buffer format not found");
-+		return -EINVAL;
-+	}
-+
-+	/*
-+	 * expected format argument size
-+	 */
-+	sz = f->fmt_arg_size;
-+
-+	/*
-+	 * check user size matches expected size
-+	 * usize = -1 is for IA-64 backward compatibility
-+	 */
-+	ret = -EINVAL;
-+	if (sz != usize && usize != -1) {
-+		PFM_DBG("invalid arg size %zu, format expects %zu",
-+			usize, sz);
-+		goto error;
-+	}
-+
-+	if (sz) {
-+		ret = -ENOMEM;
-+		addr = kmalloc(sz, GFP_KERNEL);
-+		if (addr == NULL)
-+			goto error;
-+
-+		ret = -EFAULT;
-+		if (copy_from_user(addr, fmt_uarg, sz))
-+			goto error;
-+	}
-+	*arg = addr;
-+	*fmt = f;
-+	return 0;
-+
-+error:
-+	kfree(addr);
-+	pfm_smpl_fmt_put(f);
-+	return ret;
-+}
-diff --git a/perfmon/perfmon_syscalls.c b/perfmon/perfmon_syscalls.c
-new file mode 100644
-index 0000000..8777b58
---- /dev/null
-+++ b/perfmon/perfmon_syscalls.c
-@@ -0,0 +1,1060 @@
-+/*
-+ * perfmon_syscalls.c: perfmon2 system call interface
-+ *
-+ * This file implements the perfmon2 interface which
-+ * provides access to the hardware performance counters
-+ * of the host processor.
-+ *
-+ * The initial version of perfmon.c was written by
-+ * Ganesh Venkitachalam, IBM Corp.
-+ *
-+ * Then it was modified for perfmon-1.x by Stephane Eranian and
-+ * David Mosberger, Hewlett Packard Co.
-+ *
-+ * Version Perfmon-2.x is a complete rewrite of perfmon-1.x
-+ * by Stephane Eranian, Hewlett Packard Co.
-+ *
-+ * Copyright (c) 1999-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *                David Mosberger-Tang <davidm@hpl.hp.com>
-+ *
-+ * More information about perfmon available at:
-+ * 	http://perfmon2.sf.net
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/kernel.h>
-+#include <linux/fs.h>
-+#include <linux/ptrace.h>
-+#include <linux/perfmon_kern.h>
-+#include <linux/uaccess.h>
-+#include "perfmon_priv.h"
-+
-+/*
-+ * Context locking rules:
-+ * ---------------------
-+ * 	- any thread with access to the file descriptor of a context can
-+ * 	  potentially issue perfmon calls
-+ *
-+ * 	- calls must be serialized to guarantee correctness
-+ *
-+ * 	- as soon as a context is attached to a thread or CPU, it may be
-+ * 	  actively monitoring. On some architectures, such as IA-64, this
-+ * 	  is true even though the pfm_start() call has not been made. This
-+ * 	  comes from the fact that on some architectures, it is possible to
-+ * 	  start/stop monitoring from userland.
-+ *
-+ *	- If monitoring is active, then there can PMU interrupts. Because
-+ *	  context accesses must be serialized, the perfmon system calls
-+ *	  must mask interrupts as soon as the context is attached.
-+ *
-+ *	- perfmon system calls that operate with the context unloaded cannot
-+ *	  assume it is actually unloaded when they are called. They first need
-+ *	  to check and for that they need interrupts masked. Then, if the
-+ *	  context is actually unloaded, they can unmask interrupts.
-+ *
-+ *	- interrupt masking holds true for other internal perfmon functions as
-+ *	  well. Except for PMU interrupt handler because those interrupts
-+ *	  cannot be nested.
-+ *
-+ * 	- we mask ALL interrupts instead of just the PMU interrupt because we
-+ * 	  also need to protect against timer interrupts which could trigger
-+ * 	  a set switch.
-+ */
-+#ifdef CONFIG_UTRACE
-+#include <linux/utrace.h>
-+
-+static u32
-+stopper_quiesce(struct utrace_attached_engine *engine, struct task_struct *tsk)
-+{
-+	PFM_DBG("quiesced [%d]", tsk->pid);
-+	complete(engine->data);
-+	return UTRACE_ACTION_RESUME;
-+}
-+
-+void
-+pfm_resume_task(struct task_struct *t, void *data)
-+{
-+	PFM_DBG("utrace detach [%d]", t->pid);
-+	(void) utrace_detach(t, data);
-+}
-+
-+static const struct utrace_engine_ops utrace_ops =
-+{
-+	.report_quiesce = stopper_quiesce,
-+};
-+
-+static int pfm_wait_task_stopped(struct task_struct *task, void **data)
-+{
-+	DECLARE_COMPLETION_ONSTACK(done);
-+	struct utrace_attached_engine *eng;
-+	int ret;
-+
-+	eng = utrace_attach(task, UTRACE_ATTACH_CREATE, &utrace_ops, &done);
-+	if (IS_ERR(eng))
-+		return PTR_ERR(eng);
-+
-+	ret = utrace_set_flags(task, eng,
-+			       UTRACE_ACTION_QUIESCE | UTRACE_EVENT(QUIESCE));
-+	PFM_DBG("wait quiesce [%d]", task->pid);
-+	if (!ret)
-+		ret = wait_for_completion_interruptible(&done);
-+
-+	if (ret)
-+		(void) utrace_detach(task, eng);
-+	else
-+		*data = eng;
-+	return 0;
-+}
-+#else /* !CONFIG_UTRACE */
-+static int pfm_wait_task_stopped(struct task_struct *task, void **data)
-+{
-+	int ret;
-+
-+	*data = NULL;
-+
-+	/*
-+	 * returns 0 if cannot attach
-+	 */
-+	ret = ptrace_may_access(task, PTRACE_MODE_ATTACH);
-+	PFM_DBG("may_attach=%d", ret);
-+	if (!ret)
-+		return -EPERM;
-+
-+	ret = ptrace_check_attach(task, 0);
-+	PFM_DBG("check_attach=%d", ret);
-+	return ret;
-+}
-+void pfm_resume_task(struct task_struct *t, void *data)
-+{}
-+#endif
-+
-+struct pfm_syscall_cookie {
-+	struct file *filp;
-+	int fput_needed;
-+};
-+
-+/*
-+ * cannot attach if :
-+ * 	- kernel task
-+ * 	- task not owned by caller (checked by ptrace_may_attach())
-+ * 	- task is dead or zombie
-+ * 	- cannot use blocking notification when self-monitoring
-+ */
-+static int pfm_task_incompatible(struct pfm_context *ctx,
-+				 struct task_struct *task)
-+{
-+	/*
-+	 * cannot attach to a kernel thread
-+	 */
-+	if (!task->mm) {
-+		PFM_DBG("cannot attach to kernel thread [%d]", task->pid);
-+		return -EPERM;
-+	}
-+
-+	/*
-+	 * cannot use block on notification when
-+	 * self-monitoring.
-+	 */
-+	if (ctx->flags.block && task == current) {
-+		PFM_DBG("cannot use block on notification when self-monitoring"
-+			"[%d]", task->pid);
-+		return -EINVAL;
-+	}
-+	/*
-+	 * cannot attach to a zombie task
-+	 */
-+	if (task->exit_state == EXIT_ZOMBIE || task->exit_state == EXIT_DEAD) {
-+		PFM_DBG("cannot attach to zombie/dead task [%d]", task->pid);
-+		return -EBUSY;
-+	}
-+	return 0;
-+}
-+
-+/**
-+ * pfm_get_task -- check permission and acquire task to monitor
-+ * @ctx: perfmon context
-+ * @pid: identification of the task to check
-+ * @task: upon return, a pointer to the task to monitor
-+ *
-+ * This function  is used in per-thread mode only AND when not
-+ * self-monitoring. It finds the task to monitor and checks
-+ * that the caller has permissions to attach. It also checks
-+ * that the task is stopped via ptrace so that we can safely
-+ * modify its state.
-+ *
-+ * task refcount is incremented when succesful.
-+ */
-+static int pfm_get_task(struct pfm_context *ctx, pid_t pid,
-+			struct task_struct **task, void **data)
-+{
-+	struct task_struct *p;
-+	int ret = 0, ret1 = 0;
-+
-+	*data = NULL;
-+
-+	/*
-+	 * When attaching to another thread we must ensure
-+	 * that the thread is actually stopped. 
-+	 *
-+	 * As a consequence, only the ptracing parent can actually
-+	 * attach a context to a thread. Obviously, this constraint
-+	 * does not exist for self-monitoring threads.
-+	 *
-+	 * We use ptrace_may_attach() to check for permission.
-+	 */
-+	read_lock(&tasklist_lock);
-+
-+	p = find_task_by_vpid(pid);
-+	if (p)
-+		get_task_struct(p);
-+
-+	read_unlock(&tasklist_lock);
-+
-+	if (!p) {
-+		PFM_DBG("task not found %d", pid);
-+		return -ESRCH;
-+	}
-+
-+	ret = pfm_task_incompatible(ctx, p);
-+	if (ret)
-+		goto error;
-+
-+	ret = pfm_wait_task_stopped(p, data);
-+	if (ret)
-+		goto error;
-+
-+	*task = p;
-+
-+	return 0;
-+error:
-+	if (!(ret1 || ret))
-+		ret = -EPERM;
-+
-+	put_task_struct(p);
-+
-+	return ret;
-+}
-+
-+/*
-+ * context must be locked when calling this function
-+ */
-+int pfm_check_task_state(struct pfm_context *ctx, int check_mask,
-+			 unsigned long *flags, void **resume)
-+{
-+	struct task_struct *task;
-+	unsigned long local_flags, new_flags;
-+	int state, ret;
-+
-+	*resume = NULL;
-+
-+recheck:
-+	/*
-+	 * task is NULL for system-wide context
-+	 */
-+	task = ctx->task;
-+	state = ctx->state;
-+	local_flags = *flags;
-+
-+	PFM_DBG("state=%d check_mask=0x%x", state, check_mask);
-+	/*
-+	 * if the context is detached, then we do not touch
-+	 * hardware, therefore there is not restriction on when we can
-+	 * access it.
-+	 */
-+	if (state == PFM_CTX_UNLOADED)
-+		return 0;
-+	/*
-+	 * no command can operate on a zombie context.
-+	 * A context becomes zombie when the file that identifies
-+	 * it is closed while the context is still attached to the
-+	 * thread it monitors.
-+	 */
-+	if (state == PFM_CTX_ZOMBIE)
-+		return -EINVAL;
-+
-+	/*
-+	 * at this point, state is PFM_CTX_LOADED or PFM_CTX_MASKED
-+	 */
-+
-+	/*
-+	 * some commands require the context to be unloaded to operate
-+	 */
-+	if (check_mask & PFM_CMD_UNLOADED)  {
-+		PFM_DBG("state=%d, cmd needs context unloaded", state);
-+		return -EBUSY;
-+	}
-+
-+	/*
-+	 * self-monitoring always ok.
-+	 */
-+	if (task == current)
-+		return 0;
-+
-+	/*
-+	 * for syswide, the calling thread must be running on the cpu
-+	 * the context is bound to.
-+	 */
-+	if (ctx->flags.system) {
-+		if (ctx->cpu != smp_processor_id())
-+			return -EBUSY;
-+		return 0;
-+	}
-+
-+	/*
-+	 * at this point, monitoring another thread
-+	 */
-+
-+	/*
-+	 * the pfm_unload_context() command is allowed on masked context
-+	 */
-+	if (state == PFM_CTX_MASKED && !(check_mask & PFM_CMD_UNLOAD))
-+		return 0;
-+
-+	/*
-+	 * When we operate on another thread, we must wait for it to be
-+	 * stopped and completely off any CPU as we need to access the
-+	 * PMU state (or machine state).
-+	 *
-+	 * A thread can be put in the STOPPED state in various ways
-+	 * including PTRACE_ATTACH, or when it receives a SIGSTOP signal.
-+	 * We enforce that the thread must be ptraced, so it is stopped
-+	 * AND it CANNOT wake up while we operate on it because this
-+	 * would require an action from the ptracing parent which is the
-+	 * thread that is calling this function.
-+	 *
-+	 * The dependency on ptrace, imposes that only the ptracing
-+	 * parent can issue command on a thread. This is unfortunate
-+	 * but we do not know of a better way of doing this.
-+	 */
-+	if (check_mask & PFM_CMD_STOPPED) {
-+
-+		spin_unlock_irqrestore(&ctx->lock, local_flags);
-+
-+		/*
-+		 * check that the thread is ptraced AND STOPPED
-+		 */
-+		ret = pfm_wait_task_stopped(task, resume);
-+
-+		spin_lock_irqsave(&ctx->lock, new_flags);
-+
-+		/*
-+		 * flags may be different than when we released the lock
-+		 */
-+		*flags = new_flags;
-+
-+		if (ret)
-+			return ret;
-+		/*
-+		 * we must recheck to verify if state has changed
-+		 */
-+		if (unlikely(ctx->state != state)) {
-+			PFM_DBG("old_state=%d new_state=%d",
-+				state,
-+				ctx->state);
-+			goto recheck;
-+		}
-+	}
-+	return 0;
-+}
-+
-+/*
-+ * pfm_get_args - Function used to copy the syscall argument into kernel memory.
-+ * @ureq: user argument
-+ * @sz: user argument size
-+ * @lsz: size of stack buffer
-+ * @laddr: stack buffer address
-+ * @req: point to start of kernel copy of the argument
-+ * @ptr_free: address of kernel copy to free
-+ *
-+ * There are two options:
-+ * 	- use a stack buffer described by laddr (addresses) and lsz (size)
-+ * 	- allocate memory
-+ *
-+ * return:
-+ * 	< 0 : in case of error (ptr_free may not be updated)
-+ * 	  0 : success
-+ *      - req: points to base of kernel copy of arguments
-+ *	- ptr_free: address of buffer to free by caller on exit.
-+ *		    NULL if using the stack buffer
-+ *
-+ * when ptr_free is not NULL upon return, the caller must kfree()
-+ */
-+int pfm_get_args(void __user *ureq, size_t sz, size_t lsz, void *laddr,
-+		 void **req, void **ptr_free)
-+{
-+	void *addr;
-+
-+	/*
-+	 * check syadmin argument limit
-+	 */
-+	if (unlikely(sz > pfm_controls.arg_mem_max)) {
-+		PFM_DBG("argument too big %zu max=%zu",
-+			sz,
-+			pfm_controls.arg_mem_max);
-+		return -E2BIG;
-+	}
-+
-+	/*
-+	 * check if vector fits on stack buffer
-+	 */
-+	if (sz > lsz) {
-+		addr = kmalloc(sz, GFP_KERNEL);
-+		if (unlikely(addr == NULL))
-+			return -ENOMEM;
-+		*ptr_free = addr;
-+	} else {
-+		addr = laddr;
-+		*req = laddr;
-+		*ptr_free = NULL;
-+	}
-+
-+	/*
-+	 * bring the data in
-+	 */
-+	if (unlikely(copy_from_user(addr, ureq, sz))) {
-+		if (addr != laddr)
-+			kfree(addr);
-+		return -EFAULT;
-+	}
-+
-+	/*
-+	 * base address of kernel buffer
-+	 */
-+	*req = addr;
-+
-+	return 0;
-+}
-+
-+/**
-+ * pfm_acquire_ctx_from_fd -- get ctx from file descriptor
-+ * @fd: file descriptor
-+ * @ctx: pointer to pointer of context updated on return
-+ * @cookie: opaque structure to use for release
-+ *
-+ * This helper function extracts the ctx from the file descriptor.
-+ * It also increments the refcount of the file structure. Thus
-+ * it updates the cookie so the refcount can be decreased when
-+ * leaving the perfmon syscall via pfm_release_ctx_from_fd
-+ */
-+static int pfm_acquire_ctx_from_fd(int fd, struct pfm_context **ctx,
-+				   struct pfm_syscall_cookie *cookie)
-+{
-+	struct file *filp;
-+	int fput_needed;
-+
-+	filp = fget_light(fd, &fput_needed);
-+	if (unlikely(filp == NULL)) {
-+		PFM_DBG("invalid fd %d", fd);
-+		return -EBADF;
-+	}
-+
-+	*ctx = filp->private_data;
-+
-+	if (unlikely(!*ctx || filp->f_op != &pfm_file_ops)) {
-+		PFM_DBG("fd %d not related to perfmon", fd);
-+		return -EBADF;
-+	}
-+	cookie->filp = filp;
-+	cookie->fput_needed = fput_needed;
-+
-+	return 0;
-+}
-+
-+/**
-+ * pfm_release_ctx_from_fd -- decrease refcount of file associated with context
-+ * @cookie: the cookie structure initialized by pfm_acquire_ctx_from_fd
-+ */
-+static inline void pfm_release_ctx_from_fd(struct pfm_syscall_cookie *cookie)
-+{
-+	fput_light(cookie->filp, cookie->fput_needed);
-+}
-+
-+/*
-+ * unlike the other perfmon system calls, this one returns a file descriptor
-+ * or a value < 0 in case of error, very much like open() or socket()
-+ */
-+asmlinkage long sys_pfm_create_context(struct pfarg_ctx __user *ureq,
-+				       char __user *fmt_name,
-+				       void __user *fmt_uarg, size_t fmt_size)
-+{
-+	struct pfarg_ctx req;
-+	struct pfm_smpl_fmt *fmt = NULL;
-+	void *fmt_arg = NULL;
-+	int ret;
-+
-+	PFM_DBG("req=%p fmt=%p fmt_arg=%p size=%zu",
-+		ureq, fmt_name, fmt_uarg, fmt_size);
-+
-+	if (perfmon_disabled)
-+		return -ENOSYS;
-+
-+	if (copy_from_user(&req, ureq, sizeof(req)))
-+		return -EFAULT;
-+
-+	if (fmt_name) {
-+		ret = pfm_get_smpl_arg(fmt_name, fmt_uarg, fmt_size, &fmt_arg, &fmt);
-+		if (ret)
-+			goto abort;
-+	}
-+
-+	ret = __pfm_create_context(&req, fmt, fmt_arg, PFM_NORMAL, NULL);
-+
-+	kfree(fmt_arg);
-+abort:
-+	return ret;
-+}
-+
-+asmlinkage long sys_pfm_write_pmcs(int fd, struct pfarg_pmc __user *ureq, int count)
-+{
-+	struct pfm_context *ctx;
-+	struct task_struct *task;
-+	struct pfm_syscall_cookie cookie;
-+	struct pfarg_pmc pmcs[PFM_PMC_STK_ARG];
-+	struct pfarg_pmc *req;
-+	void *fptr, *resume;
-+	unsigned long flags;
-+	size_t sz;
-+	int ret;
-+
-+	PFM_DBG("fd=%d req=%p count=%d", fd, ureq, count);
-+
-+	if (count < 0 || count >= PFM_MAX_ARG_COUNT(ureq)) {
-+		PFM_DBG("invalid arg count %d", count);
-+		return -EINVAL;
-+	}
-+
-+	sz = count*sizeof(*ureq);
-+
-+	ret = pfm_acquire_ctx_from_fd(fd, &ctx, &cookie);
-+	if (ret)
-+		return ret;
-+
-+	ret = pfm_get_args(ureq, sz, sizeof(pmcs), pmcs, (void **)&req, &fptr);
-+	if (ret)
-+		goto error;
-+
-+	spin_lock_irqsave(&ctx->lock, flags);
-+
-+	task = ctx->task;
-+
-+	ret = pfm_check_task_state(ctx, PFM_CMD_STOPPED, &flags, &resume);
-+	if (!ret)
-+		ret = __pfm_write_pmcs(ctx, req, count);
-+
-+	spin_unlock_irqrestore(&ctx->lock, flags);
-+
-+	if (resume)
-+		pfm_resume_task(task, resume);
-+
-+	/*
-+	 * This function may be on the critical path.
-+	 * We want to avoid the branch if unecessary.
-+	 */
-+	if (fptr)
-+		kfree(fptr);
-+error:
-+	pfm_release_ctx_from_fd(&cookie);
-+	return ret;
-+}
-+
-+asmlinkage long sys_pfm_write_pmds(int fd, struct pfarg_pmd __user *ureq, int count)
-+{
-+	struct pfm_context *ctx;
-+	struct task_struct *task;
-+	struct pfm_syscall_cookie cookie;
-+	struct pfarg_pmd pmds[PFM_PMD_STK_ARG];
-+	struct pfarg_pmd *req;
-+	void *fptr, *resume;
-+	unsigned long flags;
-+	size_t sz;
-+	int ret;
-+
-+	PFM_DBG("fd=%d req=%p count=%d", fd, ureq, count);
-+
-+	if (count < 0 || count >= PFM_MAX_ARG_COUNT(ureq)) {
-+		PFM_DBG("invalid arg count %d", count);
-+		return -EINVAL;
-+	}
-+
-+	sz = count*sizeof(*ureq);
-+
-+	ret = pfm_acquire_ctx_from_fd(fd, &ctx, &cookie);
-+	if (ret)
-+		return ret;
-+
-+	ret = pfm_get_args(ureq, sz, sizeof(pmds), pmds, (void **)&req, &fptr);
-+	if (ret)
-+		goto error;
-+
-+	spin_lock_irqsave(&ctx->lock, flags);
-+
-+	task = ctx->task;
-+
-+	ret = pfm_check_task_state(ctx, PFM_CMD_STOPPED, &flags, &resume);
-+	if (!ret)
-+		ret = __pfm_write_pmds(ctx, req, count, 0);
-+
-+	spin_unlock_irqrestore(&ctx->lock, flags);
-+
-+	if (resume)
-+		pfm_resume_task(task, resume);
-+
-+	if (fptr)
-+		kfree(fptr);
-+error:
-+	pfm_release_ctx_from_fd(&cookie);
-+	return ret;
-+}
-+
-+asmlinkage long sys_pfm_read_pmds(int fd, struct pfarg_pmd __user *ureq, int count)
-+{
-+	struct pfm_context *ctx;
-+	struct task_struct *task;
-+	struct pfm_syscall_cookie cookie;
-+	struct pfarg_pmd pmds[PFM_PMD_STK_ARG];
-+	struct pfarg_pmd *req;
-+	void *fptr, *resume;
-+	unsigned long flags;
-+	size_t sz;
-+	int ret;
-+
-+	PFM_DBG("fd=%d req=%p count=%d", fd, ureq, count);
-+
-+	if (count < 0 || count >= PFM_MAX_ARG_COUNT(ureq))
-+		return -EINVAL;
-+
-+	sz = count*sizeof(*ureq);
-+
-+	ret = pfm_acquire_ctx_from_fd(fd, &ctx, &cookie);
-+	if (ret)
-+		return ret;
-+
-+	ret = pfm_get_args(ureq, sz, sizeof(pmds), pmds, (void **)&req, &fptr);
-+	if (ret)
-+		goto error;
-+
-+	spin_lock_irqsave(&ctx->lock, flags);
-+
-+	task = ctx->task;
-+
-+	ret = pfm_check_task_state(ctx, PFM_CMD_STOPPED, &flags, &resume);
-+	if (!ret)
-+		ret = __pfm_read_pmds(ctx, req, count);
-+
-+	spin_unlock_irqrestore(&ctx->lock, flags);
-+
-+	if (copy_to_user(ureq, req, sz))
-+		ret = -EFAULT;
-+
-+	if (resume)
-+		pfm_resume_task(task, resume);
-+
-+	if (fptr)
-+		kfree(fptr);
-+error:
-+	pfm_release_ctx_from_fd(&cookie);
-+	return ret;
-+}
-+
-+asmlinkage long sys_pfm_restart(int fd)
-+{
-+	struct pfm_context *ctx;
-+	struct task_struct *task;
-+	struct pfm_syscall_cookie cookie;
-+	void *resume;
-+	unsigned long flags;
-+	int ret, info;
-+
-+	PFM_DBG("fd=%d", fd);
-+
-+	ret = pfm_acquire_ctx_from_fd(fd, &ctx, &cookie);
-+	if (ret)
-+		return ret;
-+
-+	spin_lock_irqsave(&ctx->lock, flags);
-+
-+	task = ctx->task;
-+
-+	ret = pfm_check_task_state(ctx, 0, &flags, &resume);
-+	if (!ret)
-+		ret = __pfm_restart(ctx, &info);
-+
-+	spin_unlock_irqrestore(&ctx->lock, flags);
-+
-+	if (resume)
-+		pfm_resume_task(task, resume);
-+	/*
-+	 * In per-thread mode with blocking notification, i.e.
-+	 * ctx->flags.blocking=1, we need to defer issuing the
-+	 * complete to unblock the blocked monitored thread.
-+	 * Otherwise we have a potential deadlock due to a lock
-+	 * inversion between the context lock and the task_rq_lock()
-+	 * which can happen if one thread is in this call and the other
-+	 * (the monitored thread) is in the context switch code.
-+	 *
-+	 * It is safe to access the context outside the critical section
-+	 * because:
-+	 * 	- we are protected by the fget_light(), thus the context
-+	 * 	  cannot disappear
-+	 */
-+	if (ret == 0 && info == 1)
-+		complete(&ctx->restart_complete);
-+
-+	pfm_release_ctx_from_fd(&cookie);
-+	return ret;
-+}
-+
-+asmlinkage long sys_pfm_stop(int fd)
-+{
-+	struct pfm_context *ctx;
-+	struct task_struct *task;
-+	struct pfm_syscall_cookie cookie;
-+	void *resume;
-+	unsigned long flags;
-+	int ret;
-+	int release_info;
-+
-+	PFM_DBG("fd=%d", fd);
-+
-+	ret = pfm_acquire_ctx_from_fd(fd, &ctx, &cookie);
-+	if (ret)
-+		return ret;
-+
-+	spin_lock_irqsave(&ctx->lock, flags);
-+
-+	task = ctx->task;
-+
-+	ret = pfm_check_task_state(ctx, PFM_CMD_STOPPED, &flags, &resume);
-+	if (!ret)
-+		ret = __pfm_stop(ctx, &release_info);
-+
-+	spin_unlock_irqrestore(&ctx->lock, flags);
-+
-+	if (resume)
-+		pfm_resume_task(task, resume);
-+
-+	/*
-+	 * defer cancellation of timer to avoid race
-+	 * with pfm_handle_switch_timeout()
-+	 *
-+	 * applies only when self-monitoring
-+	 */
-+	if (release_info & 0x2)
-+		hrtimer_cancel(&__get_cpu_var(pfm_hrtimer));
-+
-+	pfm_release_ctx_from_fd(&cookie);
-+	return ret;
-+}
-+
-+asmlinkage long sys_pfm_start(int fd, struct pfarg_start __user *ureq)
-+{
-+	struct pfm_context *ctx;
-+	struct task_struct *task;
-+	struct pfm_syscall_cookie cookie;
-+	void *resume;
-+	struct pfarg_start req;
-+	unsigned long flags;
-+	int ret;
-+
-+	PFM_DBG("fd=%d req=%p", fd, ureq);
-+
-+	ret = pfm_acquire_ctx_from_fd(fd, &ctx, &cookie);
-+	if (ret)
-+		return ret;
-+
-+	/*
-+	 * the one argument is actually optional
-+	 */
-+	if (ureq && copy_from_user(&req, ureq, sizeof(req)))
-+		return -EFAULT;
-+
-+	spin_lock_irqsave(&ctx->lock, flags);
-+
-+	task = ctx->task;
-+
-+	ret = pfm_check_task_state(ctx, PFM_CMD_STOPPED, &flags, &resume);
-+	if (!ret)
-+		ret = __pfm_start(ctx, ureq ? &req : NULL);
-+
-+	spin_unlock_irqrestore(&ctx->lock, flags);
-+
-+	if (resume)
-+		pfm_resume_task(task, resume);
-+
-+	pfm_release_ctx_from_fd(&cookie);
-+	return ret;
-+}
-+
-+asmlinkage long sys_pfm_load_context(int fd, struct pfarg_load __user *ureq)
-+{
-+	struct pfm_context *ctx;
-+	struct task_struct *task;
-+	struct pfm_syscall_cookie cookie;
-+	void *resume, *dummy_resume;
-+	unsigned long flags;
-+	struct pfarg_load req;
-+	int ret;
-+
-+	PFM_DBG("fd=%d req=%p", fd, ureq);
-+
-+	if (copy_from_user(&req, ureq, sizeof(req)))
-+		return -EFAULT;
-+
-+	ret = pfm_acquire_ctx_from_fd(fd, &ctx, &cookie);
-+	if (ret)
-+		return ret;
-+
-+	task = current;
-+
-+	/*
-+	 * in per-thread mode (not self-monitoring), get a reference
-+	 * on task to monitor. This must be done with interrupts enabled
-+	 * Upon succesful return, refcount on task is increased.
-+	 *
-+	 * fget_light() is protecting the context.
-+	 */
-+	if (!ctx->flags.system && req.load_pid != current->pid) {
-+		ret = pfm_get_task(ctx, req.load_pid, &task, &resume);
-+		if (ret)
-+			goto error;
-+	}
-+
-+	/*
-+	 * irqsave is required to avoid race in case context is already
-+	 * loaded or with switch timeout in the case of self-monitoring
-+	 */
-+	spin_lock_irqsave(&ctx->lock, flags);
-+
-+	ret = pfm_check_task_state(ctx, PFM_CMD_UNLOADED, &flags, &dummy_resume);
-+	if (!ret)
-+		ret = __pfm_load_context(ctx, &req, task);
-+
-+	spin_unlock_irqrestore(&ctx->lock, flags);
-+
-+	if (resume)
-+		pfm_resume_task(task, resume);
-+
-+	/*
-+	 * in per-thread mode (not self-monitoring), we need
-+	 * to decrease refcount on task to monitor:
-+	 *   - load successful: we have a reference to the task in ctx->task
-+	 *   - load failed    : undo the effect of pfm_get_task()
-+	 */
-+	if (task != current)
-+		put_task_struct(task);
-+error:
-+	pfm_release_ctx_from_fd(&cookie);
-+	return ret;
-+}
-+
-+asmlinkage long sys_pfm_unload_context(int fd)
-+{
-+	struct pfm_context *ctx;
-+	struct task_struct *task;
-+	struct pfm_syscall_cookie cookie;
-+	void *resume;
-+	unsigned long flags;
-+	int ret;
-+	int is_system, release_info = 0;
-+	u32 cpu;
-+
-+	PFM_DBG("fd=%d", fd);
-+
-+	ret = pfm_acquire_ctx_from_fd(fd, &ctx, &cookie);
-+	if (ret)
-+		return ret;
-+
-+	is_system = ctx->flags.system;
-+
-+	spin_lock_irqsave(&ctx->lock, flags);
-+
-+	cpu = ctx->cpu;
-+	task = ctx->task;
-+
-+	ret = pfm_check_task_state(ctx, PFM_CMD_STOPPED|PFM_CMD_UNLOAD,
-+				   &flags, &resume);
-+	if (!ret)
-+		ret = __pfm_unload_context(ctx, &release_info);
-+
-+	spin_unlock_irqrestore(&ctx->lock, flags);
-+
-+	if (resume)
-+		pfm_resume_task(task, resume);
-+
-+	/*
-+	 * cancel time now that context is unlocked
-+	 * avoid race with pfm_handle_switch_timeout()
-+	 */
-+	if (release_info & 0x2) {
-+		int r;
-+		r = hrtimer_cancel(&__get_cpu_var(pfm_hrtimer));
-+		PFM_DBG("timeout cancel=%d", r);
-+	}
-+
-+	if (release_info & 0x1)
-+		pfm_session_release(is_system, cpu);
-+
-+	pfm_release_ctx_from_fd(&cookie);
-+	return ret;
-+}
-+
-+asmlinkage long sys_pfm_create_evtsets(int fd, struct pfarg_setdesc __user *ureq, int count)
-+{
-+	struct pfm_context *ctx;
-+	struct pfm_syscall_cookie cookie;
-+	struct pfarg_setdesc *req;
-+	void *fptr, *resume;
-+	unsigned long flags;
-+	size_t sz;
-+	int ret;
-+
-+	PFM_DBG("fd=%d req=%p count=%d", fd, ureq, count);
-+
-+	if (count < 0 || count >= PFM_MAX_ARG_COUNT(ureq))
-+		return -EINVAL;
-+
-+	sz = count*sizeof(*ureq);
-+
-+	ret = pfm_acquire_ctx_from_fd(fd, &ctx, &cookie);
-+	if (ret)
-+		return ret;
-+
-+	ret = pfm_get_args(ureq, sz, 0, NULL, (void **)&req, &fptr);
-+	if (ret)
-+		goto error;
-+
-+	/*
-+	 * must mask interrupts because we do not know the state of context,
-+	 * could be attached and we could be getting PMU interrupts. So
-+	 * we mask and lock context and we check and possibly relax masking
-+	 */
-+	spin_lock_irqsave(&ctx->lock, flags);
-+
-+	ret = pfm_check_task_state(ctx, PFM_CMD_UNLOADED, &flags, &resume);
-+	if (!ret)
-+		ret = __pfm_create_evtsets(ctx, req, count);
-+
-+	spin_unlock_irqrestore(&ctx->lock, flags);
-+	/*
-+	 * context must be unloaded for this command. The resume pointer
-+	 * is necessarily NULL, thus no need to call pfm_resume_task()
-+	 */
-+	kfree(fptr);
-+
-+error:
-+	pfm_release_ctx_from_fd(&cookie);
-+	return ret;
-+}
-+
-+asmlinkage long  sys_pfm_getinfo_evtsets(int fd, struct pfarg_setinfo __user *ureq, int count)
-+{
-+	struct pfm_context *ctx;
-+	struct task_struct *task;
-+	struct pfm_syscall_cookie cookie;
-+	struct pfarg_setinfo *req;
-+	void *fptr, *resume;
-+	unsigned long flags;
-+	size_t sz;
-+	int ret;
-+
-+	PFM_DBG("fd=%d req=%p count=%d", fd, ureq, count);
-+
-+	if (count < 0 || count >= PFM_MAX_ARG_COUNT(ureq))
-+		return -EINVAL;
-+
-+	sz = count*sizeof(*ureq);
-+
-+	ret = pfm_acquire_ctx_from_fd(fd, &ctx, &cookie);
-+	if (ret)
-+		return ret;
-+
-+	ret = pfm_get_args(ureq, sz, 0, NULL, (void **)&req, &fptr);
-+	if (ret)
-+		goto error;
-+
-+	/*
-+	 * this command operates even when context is loaded, so we need
-+	 * to keep interrupts masked to avoid a race with PMU interrupt
-+	 * which may switch the active set
-+	 */
-+	spin_lock_irqsave(&ctx->lock, flags);
-+
-+	task = ctx->task;
-+
-+	ret = pfm_check_task_state(ctx, 0, &flags, &resume);
-+	if (!ret)
-+		ret = __pfm_getinfo_evtsets(ctx, req, count);
-+
-+	spin_unlock_irqrestore(&ctx->lock, flags);
-+
-+	if (resume)
-+		pfm_resume_task(task, resume);
-+
-+	if (copy_to_user(ureq, req, sz))
-+		ret = -EFAULT;
-+
-+	kfree(fptr);
-+error:
-+	pfm_release_ctx_from_fd(&cookie);
-+	return ret;
-+}
-+
-+asmlinkage long sys_pfm_delete_evtsets(int fd, struct pfarg_setinfo __user *ureq, int count)
-+{
-+	struct pfm_context *ctx;
-+	struct pfm_syscall_cookie cookie;
-+	struct pfarg_setinfo *req;
-+	void *fptr, *resume;
-+	unsigned long flags;
-+	size_t sz;
-+	int ret;
-+
-+	PFM_DBG("fd=%d req=%p count=%d", fd, ureq, count);
-+
-+	if (count < 0 || count >= PFM_MAX_ARG_COUNT(ureq))
-+		return -EINVAL;
-+
-+	sz = count*sizeof(*ureq);
-+
-+	ret = pfm_acquire_ctx_from_fd(fd, &ctx, &cookie);
-+	if (ret)
-+		return ret;
-+
-+	ret = pfm_get_args(ureq, sz, 0, NULL, (void **)&req, &fptr);
-+	if (ret)
-+		goto error;
-+
-+	/*
-+	 * must mask interrupts because we do not know the state of context,
-+	 * could be attached and we could be getting PMU interrupts
-+	 */
-+	spin_lock_irqsave(&ctx->lock, flags);
-+
-+	ret = pfm_check_task_state(ctx, PFM_CMD_UNLOADED, &flags, &resume);
-+	if (!ret)
-+		ret = __pfm_delete_evtsets(ctx, req, count);
-+
-+	spin_unlock_irqrestore(&ctx->lock, flags);
-+	/*
-+	 * context must be unloaded for this command. The resume pointer
-+	 * is necessarily NULL, thus no need to call pfm_resume_task()
-+	 */
-+	kfree(fptr);
-+
-+error:
-+	pfm_release_ctx_from_fd(&cookie);
-+	return ret;
-+}
-diff --git a/perfmon/perfmon_sysfs.c b/perfmon/perfmon_sysfs.c
-new file mode 100644
-index 0000000..7353c3b
---- /dev/null
-+++ b/perfmon/perfmon_sysfs.c
-@@ -0,0 +1,525 @@
-+/*
-+ * perfmon_sysfs.c: perfmon2 sysfs interface
-+ *
-+ * This file implements the perfmon2 interface which
-+ * provides access to the hardware performance counters
-+ * of the host processor.
-+ *
-+ * The initial version of perfmon.c was written by
-+ * Ganesh Venkitachalam, IBM Corp.
-+ *
-+ * Then it was modified for perfmon-1.x by Stephane Eranian and
-+ * David Mosberger, Hewlett Packard Co.
-+ *
-+ * Version Perfmon-2.x is a complete rewrite of perfmon-1.x
-+ * by Stephane Eranian, Hewlett Packard Co.
-+ *
-+ * Copyright (c) 1999-2006 Hewlett-Packard Development Company, L.P.
-+ * Contributed by Stephane Eranian <eranian@hpl.hp.com>
-+ *                David Mosberger-Tang <davidm@hpl.hp.com>
-+ *
-+ * More information about perfmon available at:
-+ * 	http://perfmon2.sf.net
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of version 2 of the GNU General Public
-+ * License as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ * 02111-1307 USA
-+ */
-+#include <linux/kernel.h>
-+#include <linux/module.h> /* for EXPORT_SYMBOL */
-+#include <linux/perfmon_kern.h>
-+#include "perfmon_priv.h"
-+
-+struct pfm_attribute {
-+	struct attribute attr;
-+	ssize_t (*show)(void *, struct pfm_attribute *attr, char *);
-+	ssize_t (*store)(void *, const char *, size_t);
-+};
-+#define to_attr(n) container_of(n, struct pfm_attribute, attr);
-+
-+#define PFM_RO_ATTR(_name, _show) \
-+	struct kobj_attribute attr_##_name = __ATTR(_name, 0444, _show, NULL)
-+
-+#define PFM_RW_ATTR(_name, _show, _store) 			\
-+	struct kobj_attribute attr_##_name = __ATTR(_name, 0644, _show, _store)
-+
-+#define PFM_ROS_ATTR(_name, _show) \
-+	struct pfm_attribute attr_##_name = __ATTR(_name, 0444, _show, NULL)
-+
-+#define is_attr_name(a, n) (!strcmp((a)->attr.name, n))
-+int pfm_sysfs_add_pmu(struct pfm_pmu_config *pmu);
-+
-+static struct kobject *pfm_kernel_kobj, *pfm_fmt_kobj;
-+static struct kobject *pfm_pmu_kobj;
-+
-+static ssize_t pfm_regs_attr_show(struct kobject *kobj,
-+		struct attribute *attr, char *buf)
-+{
-+	struct pfm_regmap_desc *reg = to_reg(kobj);
-+	struct pfm_attribute *attribute = to_attr(attr);
-+	return attribute->show ? attribute->show(reg, attribute, buf) : -EIO;
-+}
-+
-+static ssize_t pfm_fmt_attr_show(struct kobject *kobj,
-+		struct attribute *attr, char *buf)
-+{
-+	struct pfm_smpl_fmt *fmt = to_smpl_fmt(kobj);
-+	struct pfm_attribute *attribute = to_attr(attr);
-+	return attribute->show ? attribute->show(fmt, attribute, buf) : -EIO;
-+}
-+
-+static struct sysfs_ops pfm_regs_sysfs_ops = {
-+	.show  = pfm_regs_attr_show
-+};
-+
-+static struct sysfs_ops pfm_fmt_sysfs_ops = {
-+	.show = pfm_fmt_attr_show
-+};
-+
-+static struct kobj_type pfm_regs_ktype = {
-+	.sysfs_ops = &pfm_regs_sysfs_ops,
-+};
-+
-+static struct kobj_type pfm_fmt_ktype = {
-+	.sysfs_ops = &pfm_fmt_sysfs_ops,
-+};
-+
-+static ssize_t pfm_controls_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
-+{
-+	int base;
-+
-+	if (is_attr_name(attr, "version"))
-+		return snprintf(buf, PAGE_SIZE, "%u.%u\n",  PFM_VERSION_MAJ, PFM_VERSION_MIN);
-+
-+	if (is_attr_name(attr, "task_sessions_count"))
-+		return pfm_sysfs_res_show(buf, PAGE_SIZE, 0);
-+
-+	if (is_attr_name(attr, "debug"))
-+		return snprintf(buf, PAGE_SIZE, "%d\n", pfm_controls.debug);
-+
-+	if (is_attr_name(attr, "task_group"))
-+		return snprintf(buf, PAGE_SIZE, "%d\n", pfm_controls.task_group);
-+
-+	if (is_attr_name(attr, "mode"))
-+		return snprintf(buf, PAGE_SIZE, "%d\n", pfm_controls.flags);
-+
-+	if (is_attr_name(attr, "arg_mem_max"))
-+		return snprintf(buf, PAGE_SIZE, "%zu\n", pfm_controls.arg_mem_max);
-+
-+	if (is_attr_name(attr, "syscall")) {
-+		base = pfm_arch_get_base_syscall();
-+		return snprintf(buf, PAGE_SIZE, "%d\n",  base);
-+	}
-+
-+	if (is_attr_name(attr, "sys_sessions_count"))
-+		return pfm_sysfs_res_show(buf, PAGE_SIZE, 1);
-+
-+	if (is_attr_name(attr, "smpl_buffer_mem_max"))
-+		return snprintf(buf, PAGE_SIZE, "%zu\n", pfm_controls.smpl_buffer_mem_max);
-+
-+	if (is_attr_name(attr, "smpl_buffer_mem_cur"))
-+		return pfm_sysfs_res_show(buf, PAGE_SIZE, 2);
-+
-+	if (is_attr_name(attr, "sys_group"))
-+		return snprintf(buf, PAGE_SIZE, "%d\n", pfm_controls.sys_group);
-+
-+	/* XXX: could be set to write-only */
-+	if (is_attr_name(attr, "reset_stats")) {
-+		buf[0] = '0';
-+		buf[1] = '\0';
-+		return strnlen(buf, PAGE_SIZE);
-+	}
-+	return 0;
-+}
-+
-+static ssize_t pfm_controls_store(struct kobject *kobj, struct kobj_attribute *attr,
-+				  const char *buf, size_t count)
-+{
-+	int i;
-+	size_t d;
-+
-+	if (sscanf(buf, "%zu", &d) != 1)
-+		goto skip;
-+
-+	if (is_attr_name(attr, "debug"))
-+		pfm_controls.debug = d;
-+
-+	if (is_attr_name(attr, "task_group"))
-+		pfm_controls.task_group = d;
-+
-+	if (is_attr_name(attr, "sys_group"))
-+		pfm_controls.sys_group = d;
-+
-+	if (is_attr_name(attr, "mode"))
-+                pfm_controls.flags = d ? PFM_CTRL_FL_RW_EXPERT : 0;
-+
-+	if (is_attr_name(attr, "arg_mem_max")) {
-+		/*
-+		 * we impose a page as the minimum.
-+		 *
-+		 * This limit may be smaller than the stack buffer
-+		 * available and that is fine.
-+		 */
-+		if (d >= PAGE_SIZE)
-+			pfm_controls.arg_mem_max = d;
-+	}
-+	if (is_attr_name(attr, "reset_stats")) {
-+		for_each_online_cpu(i) {
-+			pfm_reset_stats(i);
-+		}
-+	}
-+
-+	if (is_attr_name(attr, "smpl_buffer_mem_max")) {
-+		if (d >= PAGE_SIZE)
-+			pfm_controls.smpl_buffer_mem_max = d;
-+	}
-+skip:
-+	return count;
-+}
-+
-+/*
-+ * /sys/kernel/perfmon attributes
-+ */
-+static PFM_RO_ATTR(version, pfm_controls_show);
-+static PFM_RO_ATTR(task_sessions_count, pfm_controls_show);
-+static PFM_RO_ATTR(syscall, pfm_controls_show);
-+static PFM_RO_ATTR(sys_sessions_count, pfm_controls_show);
-+static PFM_RO_ATTR(smpl_buffer_mem_cur, pfm_controls_show);
-+
-+static PFM_RW_ATTR(debug, pfm_controls_show, pfm_controls_store);
-+static PFM_RW_ATTR(task_group, pfm_controls_show, pfm_controls_store);
-+static PFM_RW_ATTR(mode, pfm_controls_show, pfm_controls_store);
-+static PFM_RW_ATTR(sys_group, pfm_controls_show, pfm_controls_store);
-+static PFM_RW_ATTR(arg_mem_max, pfm_controls_show, pfm_controls_store);
-+static PFM_RW_ATTR(smpl_buffer_mem_max, pfm_controls_show, pfm_controls_store);
-+static PFM_RW_ATTR(reset_stats, pfm_controls_show, pfm_controls_store);
-+
-+static struct attribute *pfm_kernel_attrs[] = {
-+	&attr_version.attr,
-+	&attr_syscall.attr,
-+	&attr_task_sessions_count.attr,
-+	&attr_sys_sessions_count.attr,
-+	&attr_smpl_buffer_mem_cur.attr,
-+	&attr_debug.attr,
-+	&attr_reset_stats.attr,
-+	&attr_sys_group.attr,
-+	&attr_task_group.attr,
-+        &attr_mode.attr,
-+	&attr_smpl_buffer_mem_max.attr,
-+	&attr_arg_mem_max.attr,
-+	NULL
-+};
-+
-+static struct attribute_group pfm_kernel_attr_group = {
-+	.attrs = pfm_kernel_attrs,
-+};
-+
-+/*
-+ * per-reg attributes
-+ */
-+static ssize_t pfm_reg_show(void *data, struct pfm_attribute *attr, char *buf)
-+{
-+	struct pfm_regmap_desc *reg;
-+	int w;
-+
-+	reg = data;
-+
-+	if (is_attr_name(attr, "name"))
-+		return snprintf(buf, PAGE_SIZE, "%s\n", reg->desc);
-+
-+	if (is_attr_name(attr, "dfl_val"))
-+		return snprintf(buf, PAGE_SIZE, "0x%llx\n",
-+				(unsigned long long)reg->dfl_val);
-+
-+	if (is_attr_name(attr, "width")) {
-+		w = (reg->type & PFM_REG_C64) ?
-+		    pfm_pmu_conf->counter_width : 64;
-+		return snprintf(buf, PAGE_SIZE, "%d\n", w);
-+	}
-+
-+	if (is_attr_name(attr, "rsvd_msk"))
-+		return snprintf(buf, PAGE_SIZE, "0x%llx\n",
-+				(unsigned long long)reg->rsvd_msk);
-+
-+	if (is_attr_name(attr, "addr"))
-+		return snprintf(buf, PAGE_SIZE, "0x%lx\n", reg->hw_addr);
-+
-+	return 0;
-+}
-+
-+static PFM_ROS_ATTR(name, pfm_reg_show);
-+static PFM_ROS_ATTR(dfl_val, pfm_reg_show);
-+static PFM_ROS_ATTR(rsvd_msk, pfm_reg_show);
-+static PFM_ROS_ATTR(width, pfm_reg_show);
-+static PFM_ROS_ATTR(addr, pfm_reg_show);
-+
-+static struct attribute *pfm_reg_attrs[] = {
-+	&attr_name.attr,
-+	&attr_dfl_val.attr,
-+	&attr_rsvd_msk.attr,
-+	&attr_width.attr,
-+	&attr_addr.attr,
-+	NULL
-+};
-+
-+static struct attribute_group pfm_reg_attr_group = {
-+	.attrs = pfm_reg_attrs,
-+};
-+
-+static ssize_t pfm_pmu_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
-+{
-+	if (is_attr_name(attr, "model"))
-+		return snprintf(buf, PAGE_SIZE, "%s\n", pfm_pmu_conf->pmu_name);
-+	return 0;
-+}
-+static PFM_RO_ATTR(model, pfm_pmu_show);
-+
-+static struct attribute *pfm_pmu_desc_attrs[] = {
-+	&attr_model.attr,
-+	NULL
-+};
-+
-+static struct attribute_group pfm_pmu_desc_attr_group = {
-+	.attrs = pfm_pmu_desc_attrs,
-+};
-+
-+static int pfm_sysfs_add_pmu_regs(struct pfm_pmu_config *pmu)
-+{
-+	struct pfm_regmap_desc *reg;
-+	unsigned int i, k;
-+	int ret;
-+
-+	reg = pmu->pmc_desc;
-+	for (i = 0; i < pmu->num_pmc_entries; i++, reg++) {
-+
-+		if (!(reg->type & PFM_REG_I))
-+			continue;
-+
-+		ret = kobject_init_and_add(&reg->kobj, &pfm_regs_ktype,
-+					   pfm_pmu_kobj, "pmc%u", i);
-+		if (ret)
-+			goto undo_pmcs;
-+
-+		ret = sysfs_create_group(&reg->kobj, &pfm_reg_attr_group);
-+		if (ret) {
-+			kobject_del(&reg->kobj);
-+			goto undo_pmcs;
-+		}
-+	}
-+
-+	reg = pmu->pmd_desc;
-+	for (i = 0; i < pmu->num_pmd_entries; i++, reg++) {
-+
-+		if (!(reg->type & PFM_REG_I))
-+			continue;
-+
-+		ret = kobject_init_and_add(&reg->kobj, &pfm_regs_ktype,
-+					   pfm_pmu_kobj, "pmd%u", i);
-+		if (ret)
-+			goto undo_pmds;
-+
-+		ret = sysfs_create_group(&reg->kobj, &pfm_reg_attr_group);
-+		if (ret) {
-+			kobject_del(&reg->kobj);
-+			goto undo_pmds;
-+		}
-+	}
-+	return 0;
-+undo_pmds:
-+	reg = pmu->pmd_desc;
-+	for (k = 0; k < i; k++, reg++) {
-+		if (!(reg->type & PFM_REG_I))
-+			continue;
-+		sysfs_remove_group(&reg->kobj, &pfm_reg_attr_group);
-+		kobject_del(&reg->kobj);
-+	}
-+	i = pmu->num_pmc_entries;
-+	/* fall through */
-+undo_pmcs:
-+	reg = pmu->pmc_desc;
-+	for (k = 0; k < i; k++, reg++) {
-+		if (!(reg->type & PFM_REG_I))
-+			continue;
-+		sysfs_remove_group(&reg->kobj, &pfm_reg_attr_group);
-+		kobject_del(&reg->kobj);
-+	}
-+	return ret;
-+}
-+
-+static int pfm_sysfs_del_pmu_regs(struct pfm_pmu_config *pmu)
-+{
-+	struct pfm_regmap_desc *reg;
-+	unsigned int i;
-+
-+	reg = pmu->pmc_desc;
-+	for (i = 0; i < pmu->num_pmc_entries; i++, reg++) {
-+
-+		if (!(reg->type & PFM_REG_I))
-+			continue;
-+
-+		sysfs_remove_group(&reg->kobj, &pfm_reg_attr_group);
-+		kobject_del(&reg->kobj);
-+	}
-+
-+	reg = pmu->pmd_desc;
-+	for (i = 0; i < pmu->num_pmd_entries; i++, reg++) {
-+
-+		if (!(reg->type & PFM_REG_I))
-+			continue;
-+
-+		sysfs_remove_group(&reg->kobj, &pfm_reg_attr_group);
-+		kobject_del(&reg->kobj);
-+	}
-+	return 0;
-+}
-+
-+/*
-+ * when a PMU description module is inserted, we create
-+ * a pmu_desc subdir in sysfs and we populate it with
-+ * PMU specific information, such as register mappings
-+ */
-+int pfm_sysfs_add_pmu(struct pfm_pmu_config *pmu)
-+{
-+	int ret;
-+
-+	pfm_pmu_kobj = kobject_create_and_add("pmu_desc", pfm_kernel_kobj);
-+	if (!pfm_pmu_kobj)
-+		return -ENOMEM;
-+
-+	ret = sysfs_create_group(pfm_pmu_kobj, &pfm_pmu_desc_attr_group);
-+	if (ret) {
-+		/* will release pfm_pmu_kobj */
-+		kobject_put(pfm_pmu_kobj);
-+		return ret;
-+	}
-+
-+	ret = pfm_sysfs_add_pmu_regs(pmu);
-+	if (ret) {
-+		sysfs_remove_group(pfm_pmu_kobj, &pfm_pmu_desc_attr_group);
-+		/* will release pfm_pmu_kobj */
-+		kobject_put(pfm_pmu_kobj);
-+	} else
-+		kobject_uevent(pfm_pmu_kobj, KOBJ_ADD);
-+
-+	return ret;
-+}
-+
-+/*
-+ * when a PMU description module is removed, we also remove
-+ * all its information from sysfs, i.e., the pmu_desc subdir
-+ * disappears
-+ */
-+int pfm_sysfs_remove_pmu(struct pfm_pmu_config *pmu)
-+{
-+	pfm_sysfs_del_pmu_regs(pmu);
-+	sysfs_remove_group(pfm_pmu_kobj, &pfm_pmu_desc_attr_group);
-+	kobject_uevent(pfm_pmu_kobj, KOBJ_REMOVE);
-+	kobject_put(pfm_pmu_kobj);
-+	pfm_pmu_kobj = NULL;
-+	return 0;
-+}
-+
-+static ssize_t pfm_fmt_show(void *data, struct pfm_attribute *attr, char *buf)
-+{
-+	struct pfm_smpl_fmt *fmt = data;
-+
-+	if (is_attr_name(attr, "version"))
-+		return snprintf(buf, PAGE_SIZE, "%u.%u\n",
-+			fmt->fmt_version >> 16 & 0xffff,
-+			fmt->fmt_version & 0xffff);
-+	return 0;
-+}
-+
-+/*
-+ * do not use predefined macros because of name conflict
-+ * with /sys/kernel/perfmon/version
-+ */
-+struct pfm_attribute attr_fmt_version = {
-+	.attr	= { .name = "version", .mode = 0444 },
-+	.show	= pfm_fmt_show,
-+};
-+
-+static struct attribute *pfm_fmt_attrs[] = {
-+	&attr_fmt_version.attr,
-+	NULL
-+};
-+
-+static struct attribute_group pfm_fmt_attr_group = {
-+	.attrs = pfm_fmt_attrs,
-+};
-+
-+/*
-+ * when a sampling format module is inserted, we populate
-+ * sysfs with some information
-+ */
-+int pfm_sysfs_add_fmt(struct pfm_smpl_fmt *fmt)
-+{
-+	int ret;
-+
-+	ret = kobject_init_and_add(&fmt->kobj, &pfm_fmt_ktype,
-+				   pfm_fmt_kobj, fmt->fmt_name);
-+	if (ret)
-+		return ret;
-+
-+	ret = sysfs_create_group(&fmt->kobj, &pfm_fmt_attr_group);
-+	if (ret)
-+		kobject_del(&fmt->kobj);
-+	else
-+		kobject_uevent(&fmt->kobj, KOBJ_ADD);
-+
-+	return ret;
-+}
-+
-+/*
-+ * when a sampling format module is removed, its information
-+ * must also be removed from sysfs
-+ */
-+void pfm_sysfs_remove_fmt(struct pfm_smpl_fmt *fmt)
-+{
-+	sysfs_remove_group(&fmt->kobj, &pfm_fmt_attr_group);
-+	kobject_uevent(&fmt->kobj, KOBJ_REMOVE);
-+	kobject_del(&fmt->kobj);
-+}
-+
-+int __init pfm_init_sysfs(void)
-+{
-+	int ret;
-+
-+	pfm_kernel_kobj = kobject_create_and_add("perfmon", kernel_kobj);
-+	if (!pfm_kernel_kobj) {
-+		PFM_ERR("cannot add kernel object: /sys/kernel/perfmon");
-+		return -ENOMEM;
-+	}
-+
-+	ret = sysfs_create_group(pfm_kernel_kobj, &pfm_kernel_attr_group);
-+	if (ret) {
-+		kobject_put(pfm_kernel_kobj);
-+		return ret;
-+	}
-+
-+	pfm_fmt_kobj = kobject_create_and_add("formats", pfm_kernel_kobj);
-+	if (ret) {
-+		PFM_ERR("cannot add fmt object: %d", ret);
-+		goto error_fmt;
-+	}
-+	if (pfm_pmu_conf)
-+		pfm_sysfs_add_pmu(pfm_pmu_conf);
-+
-+	pfm_sysfs_builtin_fmt_add();
-+
-+	return 0;
-+
-+error_fmt:
-+	kobject_del(pfm_kernel_kobj);
-+	return ret;
-+}