highmem.c 11.7 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
Linus Torvalds's avatar
Linus Torvalds committed
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/*
 * High memory handling common code and variables.
 *
 * (C) 1999 Andrea Arcangeli, SuSE GmbH, andrea@suse.de
 *          Gerhard Wichert, Siemens AG, Gerhard.Wichert@pdb.siemens.de
 *
 *
 * Redesigned the x86 32-bit VM architecture to deal with
 * 64-bit physical space. With current x86 CPUs this
 * means up to 64 Gigabytes physical RAM.
 *
 * Rewrote high memory support to move the page cache into
 * high memory. Implemented permanent (schedulable) kmaps
 * based on Linus' idea.
 *
 * Copyright (C) 1999 Ingo Molnar <mingo@redhat.com>
 */

#include <linux/mm.h>
21
#include <linux/export.h>
Linus Torvalds's avatar
Linus Torvalds committed
22 23 24 25 26 27 28 29
#include <linux/swap.h>
#include <linux/bio.h>
#include <linux/pagemap.h>
#include <linux/mempool.h>
#include <linux/blkdev.h>
#include <linux/init.h>
#include <linux/hash.h>
#include <linux/highmem.h>
30
#include <linux/kgdb.h>
Linus Torvalds's avatar
Linus Torvalds committed
31 32
#include <asm/tlbflush.h>

33 34 35 36 37

#if defined(CONFIG_HIGHMEM) || defined(CONFIG_X86_32)
DEFINE_PER_CPU(int, __kmap_atomic_idx);
#endif

Linus Torvalds's avatar
Linus Torvalds committed
38 39 40 41 42 43 44 45 46
/*
 * Virtual_count is not a pure "count".
 *  0 means that it is not mapped, and has not been mapped
 *    since a TLB flush - it is usable.
 *  1 means that there are no users, but it has been mapped
 *    since the last TLB flush - so we can't use it.
 *  n means that there are (n-1) current users of it.
 */
#ifdef CONFIG_HIGHMEM
Al Viro's avatar
Al Viro committed
47

48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107
/*
 * Architecture with aliasing data cache may define the following family of
 * helper functions in its asm/highmem.h to control cache color of virtual
 * addresses where physical memory pages are mapped by kmap.
 */
#ifndef get_pkmap_color

/*
 * Determine color of virtual address where the page should be mapped.
 */
static inline unsigned int get_pkmap_color(struct page *page)
{
	return 0;
}
#define get_pkmap_color get_pkmap_color

/*
 * Get next index for mapping inside PKMAP region for page with given color.
 */
static inline unsigned int get_next_pkmap_nr(unsigned int color)
{
	static unsigned int last_pkmap_nr;

	last_pkmap_nr = (last_pkmap_nr + 1) & LAST_PKMAP_MASK;
	return last_pkmap_nr;
}

/*
 * Determine if page index inside PKMAP region (pkmap_nr) of given color
 * has wrapped around PKMAP region end. When this happens an attempt to
 * flush all unused PKMAP slots is made.
 */
static inline int no_more_pkmaps(unsigned int pkmap_nr, unsigned int color)
{
	return pkmap_nr == 0;
}

/*
 * Get the number of PKMAP entries of the given color. If no free slot is
 * found after checking that many entries, kmap will sleep waiting for
 * someone to call kunmap and free PKMAP slot.
 */
static inline int get_pkmap_entries_count(unsigned int color)
{
	return LAST_PKMAP;
}

/*
 * Get head of a wait queue for PKMAP entries of the given color.
 * Wait queues for different mapping colors should be independent to avoid
 * unnecessary wakeups caused by freeing of slots of other colors.
 */
static inline wait_queue_head_t *get_pkmap_wait_queue_head(unsigned int color)
{
	static DECLARE_WAIT_QUEUE_HEAD(pkmap_map_wait);

	return &pkmap_map_wait;
}
#endif

108
unsigned long totalhigh_pages __read_mostly;
109
EXPORT_SYMBOL(totalhigh_pages);
110

Peter Zijlstra's avatar
Peter Zijlstra committed
111 112 113

EXPORT_PER_CPU_SYMBOL(__kmap_atomic_idx);

114 115
unsigned int nr_free_highpages (void)
{
116
	struct zone *zone;
117 118
	unsigned int pages = 0;

119 120 121
	for_each_populated_zone(zone) {
		if (is_highmem(zone))
			pages += zone_page_state(zone, NR_FREE_PAGES);
Mel Gorman's avatar
Mel Gorman committed
122
	}
123 124 125 126

	return pages;
}

Linus Torvalds's avatar
Linus Torvalds committed
127 128 129 130 131
static int pkmap_count[LAST_PKMAP];
static  __cacheline_aligned_in_smp DEFINE_SPINLOCK(kmap_lock);

pte_t * pkmap_page_table;

132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150
/*
 * Most architectures have no use for kmap_high_get(), so let's abstract
 * the disabling of IRQ out of the locking in that case to save on a
 * potential useless overhead.
 */
#ifdef ARCH_NEEDS_KMAP_HIGH_GET
#define lock_kmap()             spin_lock_irq(&kmap_lock)
#define unlock_kmap()           spin_unlock_irq(&kmap_lock)
#define lock_kmap_any(flags)    spin_lock_irqsave(&kmap_lock, flags)
#define unlock_kmap_any(flags)  spin_unlock_irqrestore(&kmap_lock, flags)
#else
#define lock_kmap()             spin_lock(&kmap_lock)
#define unlock_kmap()           spin_unlock(&kmap_lock)
#define lock_kmap_any(flags)    \
		do { spin_lock(&kmap_lock); (void)(flags); } while (0)
#define unlock_kmap_any(flags)  \
		do { spin_unlock(&kmap_lock); (void)(flags); } while (0)
#endif

151 152 153 154
struct page *kmap_to_page(void *vaddr)
{
	unsigned long addr = (unsigned long)vaddr;

155
	if (addr >= PKMAP_ADDR(0) && addr < PKMAP_ADDR(LAST_PKMAP)) {
156
		int i = PKMAP_NR(addr);
157 158 159 160 161
		return pte_page(pkmap_page_table[i]);
	}

	return virt_to_page(addr);
}
162
EXPORT_SYMBOL(kmap_to_page);
163

Linus Torvalds's avatar
Linus Torvalds committed
164 165 166
static void flush_all_zero_pkmaps(void)
{
	int i;
167
	int need_flush = 0;
Linus Torvalds's avatar
Linus Torvalds committed
168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184

	flush_cache_kmaps();

	for (i = 0; i < LAST_PKMAP; i++) {
		struct page *page;

		/*
		 * zero means we don't have anything to do,
		 * >1 means that it is still in use. Only
		 * a count of 1 means that it is free but
		 * needs to be unmapped
		 */
		if (pkmap_count[i] != 1)
			continue;
		pkmap_count[i] = 0;

		/* sanity check */
185
		BUG_ON(pte_none(pkmap_page_table[i]));
Linus Torvalds's avatar
Linus Torvalds committed
186 187 188 189 190 191 192 193 194

		/*
		 * Don't need an atomic fetch-and-clear op here;
		 * no-one has the page mapped, and cannot get at
		 * its virtual address (and hence PTE) without first
		 * getting the kmap_lock (which is held here).
		 * So no dangers, even with speculative execution.
		 */
		page = pte_page(pkmap_page_table[i]);
195
		pte_clear(&init_mm, PKMAP_ADDR(i), &pkmap_page_table[i]);
Linus Torvalds's avatar
Linus Torvalds committed
196 197

		set_page_address(page, NULL);
198
		need_flush = 1;
Linus Torvalds's avatar
Linus Torvalds committed
199
	}
200 201
	if (need_flush)
		flush_tlb_kernel_range(PKMAP_ADDR(0), PKMAP_ADDR(LAST_PKMAP));
Linus Torvalds's avatar
Linus Torvalds committed
202 203
}

204 205 206
/**
 * kmap_flush_unused - flush all unused kmap mappings in order to remove stray mappings
 */
207 208
void kmap_flush_unused(void)
{
209
	lock_kmap();
210
	flush_all_zero_pkmaps();
211
	unlock_kmap();
212 213
}

Linus Torvalds's avatar
Linus Torvalds committed
214 215 216 217
static inline unsigned long map_new_virtual(struct page *page)
{
	unsigned long vaddr;
	int count;
218 219
	unsigned int last_pkmap_nr;
	unsigned int color = get_pkmap_color(page);
Linus Torvalds's avatar
Linus Torvalds committed
220 221

start:
222
	count = get_pkmap_entries_count(color);
Linus Torvalds's avatar
Linus Torvalds committed
223 224
	/* Find an empty entry */
	for (;;) {
225 226
		last_pkmap_nr = get_next_pkmap_nr(color);
		if (no_more_pkmaps(last_pkmap_nr, color)) {
Linus Torvalds's avatar
Linus Torvalds committed
227
			flush_all_zero_pkmaps();
228
			count = get_pkmap_entries_count(color);
Linus Torvalds's avatar
Linus Torvalds committed
229 230 231 232 233 234 235 236 237 238 239
		}
		if (!pkmap_count[last_pkmap_nr])
			break;	/* Found a usable entry */
		if (--count)
			continue;

		/*
		 * Sleep for somebody else to unmap their entries
		 */
		{
			DECLARE_WAITQUEUE(wait, current);
240 241
			wait_queue_head_t *pkmap_map_wait =
				get_pkmap_wait_queue_head(color);
Linus Torvalds's avatar
Linus Torvalds committed
242 243

			__set_current_state(TASK_UNINTERRUPTIBLE);
244
			add_wait_queue(pkmap_map_wait, &wait);
245
			unlock_kmap();
Linus Torvalds's avatar
Linus Torvalds committed
246
			schedule();
247
			remove_wait_queue(pkmap_map_wait, &wait);
248
			lock_kmap();
Linus Torvalds's avatar
Linus Torvalds committed
249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267

			/* Somebody else might have mapped it while we slept */
			if (page_address(page))
				return (unsigned long)page_address(page);

			/* Re-start */
			goto start;
		}
	}
	vaddr = PKMAP_ADDR(last_pkmap_nr);
	set_pte_at(&init_mm, vaddr,
		   &(pkmap_page_table[last_pkmap_nr]), mk_pte(page, kmap_prot));

	pkmap_count[last_pkmap_nr] = 1;
	set_page_address(page, (void *)vaddr);

	return vaddr;
}

268 269 270 271 272 273 274 275
/**
 * kmap_high - map a highmem page into memory
 * @page: &struct page to map
 *
 * Returns the page's virtual memory address.
 *
 * We cannot call this from interrupts, as it may block.
 */
Harvey Harrison's avatar
Harvey Harrison committed
276
void *kmap_high(struct page *page)
Linus Torvalds's avatar
Linus Torvalds committed
277 278 279 280 281 282 283
{
	unsigned long vaddr;

	/*
	 * For highmem pages, we can't trust "virtual" until
	 * after we have the lock.
	 */
284
	lock_kmap();
Linus Torvalds's avatar
Linus Torvalds committed
285 286 287 288
	vaddr = (unsigned long)page_address(page);
	if (!vaddr)
		vaddr = map_new_virtual(page);
	pkmap_count[PKMAP_NR(vaddr)]++;
289
	BUG_ON(pkmap_count[PKMAP_NR(vaddr)] < 2);
290
	unlock_kmap();
Linus Torvalds's avatar
Linus Torvalds committed
291 292 293 294 295
	return (void*) vaddr;
}

EXPORT_SYMBOL(kmap_high);

296 297 298 299 300 301
#ifdef ARCH_NEEDS_KMAP_HIGH_GET
/**
 * kmap_high_get - pin a highmem page into memory
 * @page: &struct page to pin
 *
 * Returns the page's current virtual memory address, or NULL if no mapping
Uwe Kleine-König's avatar
Uwe Kleine-König committed
302
 * exists.  If and only if a non null address is returned then a
303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321
 * matching call to kunmap_high() is necessary.
 *
 * This can be called from any context.
 */
void *kmap_high_get(struct page *page)
{
	unsigned long vaddr, flags;

	lock_kmap_any(flags);
	vaddr = (unsigned long)page_address(page);
	if (vaddr) {
		BUG_ON(pkmap_count[PKMAP_NR(vaddr)] < 1);
		pkmap_count[PKMAP_NR(vaddr)]++;
	}
	unlock_kmap_any(flags);
	return (void*) vaddr;
}
#endif

322
/**
Li Haifeng's avatar
Li Haifeng committed
323
 * kunmap_high - unmap a highmem page into memory
324
 * @page: &struct page to unmap
325 326 327
 *
 * If ARCH_NEEDS_KMAP_HIGH_GET is not defined then this may be called
 * only from user context.
328
 */
Harvey Harrison's avatar
Harvey Harrison committed
329
void kunmap_high(struct page *page)
Linus Torvalds's avatar
Linus Torvalds committed
330 331 332
{
	unsigned long vaddr;
	unsigned long nr;
333
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
334
	int need_wakeup;
335 336
	unsigned int color = get_pkmap_color(page);
	wait_queue_head_t *pkmap_map_wait;
Linus Torvalds's avatar
Linus Torvalds committed
337

338
	lock_kmap_any(flags);
Linus Torvalds's avatar
Linus Torvalds committed
339
	vaddr = (unsigned long)page_address(page);
340
	BUG_ON(!vaddr);
Linus Torvalds's avatar
Linus Torvalds committed
341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361
	nr = PKMAP_NR(vaddr);

	/*
	 * A count must never go down to zero
	 * without a TLB flush!
	 */
	need_wakeup = 0;
	switch (--pkmap_count[nr]) {
	case 0:
		BUG();
	case 1:
		/*
		 * Avoid an unnecessary wake_up() function call.
		 * The common case is pkmap_count[] == 1, but
		 * no waiters.
		 * The tasks queued in the wait-queue are guarded
		 * by both the lock in the wait-queue-head and by
		 * the kmap_lock.  As the kmap_lock is held here,
		 * no need for the wait-queue-head's lock.  Simply
		 * test if the queue is empty.
		 */
362 363
		pkmap_map_wait = get_pkmap_wait_queue_head(color);
		need_wakeup = waitqueue_active(pkmap_map_wait);
Linus Torvalds's avatar
Linus Torvalds committed
364
	}
365
	unlock_kmap_any(flags);
Linus Torvalds's avatar
Linus Torvalds committed
366 367 368

	/* do wake-up, if needed, race-free outside of the spin lock */
	if (need_wakeup)
369
		wake_up(pkmap_map_wait);
Linus Torvalds's avatar
Linus Torvalds committed
370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387
}

EXPORT_SYMBOL(kunmap_high);
#endif

#if defined(HASHED_PAGE_VIRTUAL)

#define PA_HASH_ORDER	7

/*
 * Describes one page->virtual association
 */
struct page_address_map {
	struct page *page;
	void *virtual;
	struct list_head list;
};

388
static struct page_address_map page_address_maps[LAST_PKMAP];
Linus Torvalds's avatar
Linus Torvalds committed
389 390 391 392 393 394 395 396 397

/*
 * Hash table bucket
 */
static struct page_address_slot {
	struct list_head lh;			/* List of page_address_maps */
	spinlock_t lock;			/* Protect this bucket's list */
} ____cacheline_aligned_in_smp page_address_htable[1<<PA_HASH_ORDER];

398
static struct page_address_slot *page_slot(const struct page *page)
Linus Torvalds's avatar
Linus Torvalds committed
399 400 401 402
{
	return &page_address_htable[hash_ptr(page, PA_HASH_ORDER)];
}

403 404 405 406 407 408
/**
 * page_address - get the mapped virtual address of a page
 * @page: &struct page to get the virtual address of
 *
 * Returns the page's virtual address.
 */
409
void *page_address(const struct page *page)
Linus Torvalds's avatar
Linus Torvalds committed
410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437
{
	unsigned long flags;
	void *ret;
	struct page_address_slot *pas;

	if (!PageHighMem(page))
		return lowmem_page_address(page);

	pas = page_slot(page);
	ret = NULL;
	spin_lock_irqsave(&pas->lock, flags);
	if (!list_empty(&pas->lh)) {
		struct page_address_map *pam;

		list_for_each_entry(pam, &pas->lh, list) {
			if (pam->page == page) {
				ret = pam->virtual;
				goto done;
			}
		}
	}
done:
	spin_unlock_irqrestore(&pas->lock, flags);
	return ret;
}

EXPORT_SYMBOL(page_address);

438 439 440 441 442
/**
 * set_page_address - set a page's virtual address
 * @page: &struct page to set
 * @virtual: virtual address to use
 */
Linus Torvalds's avatar
Linus Torvalds committed
443 444 445 446 447 448 449 450 451 452
void set_page_address(struct page *page, void *virtual)
{
	unsigned long flags;
	struct page_address_slot *pas;
	struct page_address_map *pam;

	BUG_ON(!PageHighMem(page));

	pas = page_slot(page);
	if (virtual) {		/* Add */
453
		pam = &page_address_maps[PKMAP_NR((unsigned long)virtual)];
Linus Torvalds's avatar
Linus Torvalds committed
454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485
		pam->page = page;
		pam->virtual = virtual;

		spin_lock_irqsave(&pas->lock, flags);
		list_add_tail(&pam->list, &pas->lh);
		spin_unlock_irqrestore(&pas->lock, flags);
	} else {		/* Remove */
		spin_lock_irqsave(&pas->lock, flags);
		list_for_each_entry(pam, &pas->lh, list) {
			if (pam->page == page) {
				list_del(&pam->list);
				spin_unlock_irqrestore(&pas->lock, flags);
				goto done;
			}
		}
		spin_unlock_irqrestore(&pas->lock, flags);
	}
done:
	return;
}

void __init page_address_init(void)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(page_address_htable); i++) {
		INIT_LIST_HEAD(&page_address_htable[i].lh);
		spin_lock_init(&page_address_htable[i].lock);
	}
}

#endif	/* defined(CONFIG_HIGHMEM) && !defined(WANT_PAGE_VIRTUAL) */