Specifications

This is the Title of the Book, eMatter Edition

418

Chapter 15: Memory Mapping and DMA

defined in <linux/mm.h>. In most situations, you want to use a version of kmap

rather than page_address.

#include <linux/highmem.h>

void *kmap(struct page *page);

void kunmap(struct page *page);

kmap returns a kernel virtual address for any page in the system. For low-mem-

ory pages, it just returns the logical address of the page; for high-memory pages,

kmap creates a special mapping in a dedicated part of the kernel address space.

Mappings created with kmap should always be freed with kunmap; a limited

number of such mappings is available, so it is better not to hold on to them for

too long. kmap calls maintain a counter, so if two or more functions both call

kmap on the same page, the right thing happens. Note also that kmap can sleep

if no mappings are available.

#include <linux/highmem.h>

#include <asm/kmap_types.h>

void *kmap_atomic(struct page *page, enum km_type type);

void kunmap_atomic(void *addr, enum km_type type);

kmap_atomic is a high-performance form of kmap. Each architecture maintains a

small list of slots (dedicated page table entries) for atomic kmaps; a caller of

kmap_atomic must tell the system which of those slots to use in the

type argu-

ment. The only slots that make sense for drivers are

KM_USER0 and KM_USER1 (for

code running directly from a call from user space), and

KM_IRQ0 and KM_IRQ1 (for

interrupt handlers). Note that atomic kmaps must be handled atomically; your

code cannot sleep while holding one. Note also that nothing in the kernel keeps

two functions from trying to use the same slot and interfering with each other

(although there is a unique set of slots for each CPU). In practice, contention for

atomic kmap slots seems to not be a problem.

We see some uses of these functions when we get into the example code, later in this

chapter and in subsequent chapters.

Page Tables

On any modern system, the processor must have a mechanism for translating virtual

addresses into its corresponding physical addresses. This mechanism is called a page

table; it is essentially a multilevel tree-structured array containing virtual-to-physical

mappings and a few associated flags. The Linux kernel maintains a set of page tables

even on architectures that do not use such tables directly.

A number of operations commonly performed by device drivers can involve manipu-

lating page tables. Fortunately for the driver author, the 2.6 kernel has eliminated

any need to work with page tables directly. As a result, we do not describe them in

any detail; curious readers may want to have a look at Understanding The Linux Ker-

nel by Daniel P. Bovet and Marco Cesati (O’Reilly) for the full story.

,ch15.13676 Page 418 Friday, January 21, 2005 11:04 AM