Add io_map_atomic using fixmaps
Subsystems (5)
PATCH 1/1 Add io_map_atomic using fixmaps
This steals the code used for CONFIG_HIGHMEM memory mappings except that it's designed for dynamic io resource mapping. These fixmaps are available even with CONFIG_HIGHMEM turned off.
--- arch/x86/Kconfig | 4 ++ arch/x86/include/asm/fixmap.h | 4 ++ arch/x86/include/asm/fixmap_32.h | 4 -- arch/x86/include/asm/highmem.h | 5 +-- arch/x86/mm/Makefile | 2 +- arch/x86/mm/init_32.c | 3 +- arch/x86/mm/iomap_32.c | 59 ++++++++++++++++++++++++++++++++++++++ include/asm-x86/iomap.h | 30 +++++++++++++++++++ 8 files changed, 100 insertions(+), 11 deletions(-) create mode 100644 arch/x86/mm/iomap_32.c create mode 100644 include/asm-x86/iomap.h
arch/x86/Kconfig +4 -0
@@ -1890,6 +1890,10 @@ config SYSVIPC_COMPAT endmenu +config HAVE_ATOMIC_IOMAP + def_bool y + depends on X86_32 + source "net/Kconfig" source "drivers/Kconfig"
arch/x86/include/asm/fixmap.h +4 -0
@@ -9,6 +9,10 @@extern int fixmaps_set; +extern pte_t *kmap_pte; +extern pgprot_t kmap_prot; +extern pte_t *pkmap_page_table; +void __native_set_fixmap (enum fixed_addresses idx,pte_t pte);void native_set_fixmap (enum fixed_addresses idx,unsigned long phys,pgprot_t flags);
arch/x86/include/asm/fixmap_32.h +0 -4
@@ -28,10 +28,8 @@ extern unsigned long __FIXADDR_TOP;#include <asm/acpi.h> #include <asm/apicdef.h> #include <asm/page.h> -#ifdef CONFIG_HIGHMEM #include <linux/threads.h> #include <asm/kmap_types.h> -#endif /* * Here we define all the compile-time 'special' virtual
@@ -75,10 +73,8 @@ enum fixed_addresses {#ifdef CONFIG_X86_CYCLONE_TIMER FIX_CYCLONE_TIMER ,/*cyclone timer register*/ #endif -#ifdef CONFIG_HIGHMEM FIX_KMAP_BEGIN ,/* reserved pte's for temporary kernel mappings */ FIX_KMAP_END =FIX_KMAP_BEGIN +(KM_TYPE_NR *NR_CPUS )-1 , -#endif #ifdef CONFIG_PCI_MMCONFIG FIX_PCIE_MCFG, #endif
arch/x86/include/asm/highmem.h +1 -4
@@ -25,14 +25,11 @@#include <asm/kmap_types.h> #include <asm/tlbflush.h> #include <asm/paravirt.h> +#include <asm/fixmap.h> /* declarations for highmem.c */ extern unsigned long highstart_pfn, highend_pfn; -extern pte_t *kmap_pte; -extern pgprot_t kmap_prot; -extern pte_t *pkmap_page_table; -/* * Right now we initialize only a single pte table. It can be extended * easily, subsequent pte tables have to be allocated in one physical
arch/x86/mm/Makefile +1 -1
@@ -1,7 +1,7 @@ obj-y := init_$(BITS).o fault.o ioremap.o extable.o pageattr.o mmap.o \ pat.o pgtable.o gup.o -obj-$(CONFIG_X86_32) += pgtable_32.o +obj-$(CONFIG_X86_32) += pgtable_32.o iomap_32.o obj-$(CONFIG_HUGETLB_PAGE) += hugetlbpage.o obj-$(CONFIG_X86_PTDUMP) += dump_pagetables.o
arch/x86/mm/init_32.c +1 -2
@@ -334,7 +334,6 @@ int devmem_is_allowed(unsigned long pagenr)return 0 ; } -#ifdef CONFIG_HIGHMEM pte_t *kmap_pte;pgprot_t kmap_prot;
@@ -357,6 +356,7 @@ static void __init kmap_init(void) kmap_prot =PAGE_KERNEL ; } +#ifdef CONFIG_HIGHMEM static void __init permanent_kmaps_init (pgd_t *pgd_base) {unsigned long vaddr;
@@ -436,7 +436,6 @@ static void __init set_highmem_pages_init(void)#endif /* !CONFIG_NUMA */ #else -# define kmap_init () do { } while (0)# define permanent_kmaps_init (pgd_base) do { } while (0)# define set_highmem_pages_init () do { } while (0)#endif /* CONFIG_HIGHMEM */
arch/x86/mm/iomap_32.c new file +59 -0
59 lines not on this page · raw message
include/asm-x86/iomap.h new file +30 -0
@@ -0,0 +1,30 @@ +/* +* Copyright © 2008 Ingo Molnar +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation; either version 2 of the License, or +* (at your option) any later version. +* +* 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/fs.h> +#include <linux/mm.h> +#include <linux/uaccess.h> +#include <asm/cacheflush.h> +#include <asm/pgtable.h> +#include <asm/tlbflush.h> + +void * +iomap_atomic_prot_pfn (unsigned long pfn,enum km_type type,pgprot_t prot); + +void +iounmap_atomic (void *kvaddr,enum km_type type);
Signature · 1 line
1.5.6.5
PATCH 1/1 Add io-mapping functions to dynamically map large device apertures
Graphics devices have large PCI apertures which would consume a significant fraction of a 32-bit address space if mapped during driver initialization. Using ioremap at runtime is impractical as it is too slow. This new set of interfaces uses atomic mappings on 32-bit processors and a large static mapping on 64-bit processors to provide reasonable 32-bit performance and optimal 64-bit performance.
The current implementation sits atop the existing CONFIG_HIGHMEM kmap_atomic mechanism for 32-bit processors when present. When absent, it just uses ioremap, which remains horribly inefficient. Fixing non-HIGHMEM 32-bit kernels to provide per-CPU mappings ala HIGHMEM would resolve that performance issue.
This includes some editorial suggestions from Randy Dunlap for Documentation/io-mapping.txt
--- Documentation/io-mapping.txt | 82 +++++++++++++++++++++++++++ include/linux/io-mapping.h | 125 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 207 insertions(+), 0 deletions(-) create mode 100644 Documentation/io-mapping.txt create mode 100644 include/linux/io-mapping.h
Documentation/io-mapping.txt new file +82 -0
@@ -0,0 +1,82 @@ +The io_mapping functions in linux/io-mapping.h provide an abstraction for +efficiently mapping small regions of an I/O device to the CPU. The initial +usage is to support the large graphics aperture on 32-bit processors where +ioremap_wc cannot be used to statically map the entire aperture to the CPU +as it would consume too much of the kernel address space. + +A mapping object is created during driver initialization using + + struct io_mapping *io_mapping_create_wc(unsigned long base, + unsigned long size) + + 'base' is the bus address of the region to be made + mappable, while 'size' indicates how large a mapping region to + enable. Both are in bytes. + + This _wc variant provides a mapping which may only be used + with the io_mapping_map_atomic_wc or io_mapping_map_wc. + +With this mapping object, individual pages can be mapped either atomically +or not, depending on the necessary scheduling environment. Of course, atomic +maps are more efficient: + + void *io_mapping_map_atomic_wc(struct io_mapping *mapping, + unsigned long offset) + + 'offset' is the offset within the defined mapping region. + Accessing addresses beyond the region specified in the + creation function yields undefined results. Using an offset + which is not page aligned yields an undefined result. The + return value points to a single page in CPU address space. + + This _wc variant returns a write-combining map to the + page and may only be used with mappings created by + io_mapping_create_wc + + Note that the task may not sleep while holding this page + mapped. + + void io_mapping_unmap_atomic(void *vaddr) + + 'vaddr' must be the the value returned by the last + io_mapping_map_atomic_wc call. This unmaps the specified + page and allows the task to sleep once again. + +If you need to sleep while holding the lock, you can use the non-atomic +variant, although they may be significantly slower. + + void *io_mapping_map_wc(struct io_mapping *mapping, + unsigned long offset) + + This works like io_mapping_map_atomic_wc except it allows + the task to sleep while holding the page mapped. + + void io_mapping_unmap(void *vaddr) + + This works like io_mapping_unmap_atomic, except it is used + for pages mapped with io_mapping_map_wc. + +At driver close time, the io_mapping object must be freed: + + void io_mapping_free(struct io_mapping *mapping) + +Current Implementation: + +The initial implementation of these functions uses existing mapping +mechanisms and so provides only an abstraction layer and no new +functionality. + +On 64-bit processors, io_mapping_create_wc calls ioremap_wc for the whole +range, creating a permanent kernel-visible mapping to the resource. The +map_atomic and map functions add the requested offset to the base of the +virtual address returned by ioremap_wc. + +On 32-bit processors with HIGHMEM defined, io_mapping_map_atomic_wc uses +kmap_atomic_pfn to map the specified page in an atomic fashion; +kmap_atomic_pfn isn't really supposed to be used with device pages, but it +provides an efficient mapping for this usage. + +On 32-bit processors without HIGHMEM defined, io_mapping_map_atomic_wc and +io_mapping_map_wc both use ioremap_wc, a terribly inefficient function which +performs an IPI to inform all processors about the new mapping. This results +in a significant performance penalty.
include/linux/io-mapping.h new file +125 -0
125 lines not on this page · raw message
Signature · 1 line
1.5.6.5
PATCH 1/1 Use io-mapping interfaces instead of a variety of mapping kludges
Switch the i915 device aperture mapping to the io-mapping interface, taking advantage of the cleaner API to extend it across all of the mapping uses, including both pwrite and relocation updates.
This dramatically improves performance on 64-bit kernels which were using the same slow path as 32-bit non-HIGHMEM kernels prior to this patch.
--- drivers/gpu/drm/i915/i915_drv.h | 3 + drivers/gpu/drm/i915/i915_gem.c | 174 ++++++++++++++++++--------------------- 2 files changed, 83 insertions(+), 94 deletions(-)
drivers/gpu/drm/i915/i915_drv.h +3 -0
@@ -31,6 +31,7 @@#define _I915_DRV_H_#include "i915_reg.h" +#include <linux/io-mapping.h> /* General customization: */
@@ -246,6 +247,8 @@ typedef struct drm_i915_private {struct {struct drm_mm gtt_space; +struct io_mapping *gtt_mapping; +/** * List of objects currently involved in rendering from the * ringbuffer.
drivers/gpu/drm/i915/i915_gem.c +80 -94
252 lines not on this page · raw message
Signature · 1 line
1.5.6.5