License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 14:07:57 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2008-05-19 23:52:27 +00:00
|
|
|
/*
|
2005-04-16 22:20:36 +00:00
|
|
|
* arch/sparc64/mm/init.c
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 1996-1999 David S. Miller (davem@caip.rutgers.edu)
|
|
|
|
|
* Copyright (C) 1997-1999 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
|
|
|
|
|
*/
|
|
|
|
|
|
2016-09-19 21:36:29 +00:00
|
|
|
#include <linux/extable.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
|
#include <linux/sched.h>
|
|
|
|
|
#include <linux/string.h>
|
|
|
|
|
#include <linux/init.h>
|
2018-10-30 22:09:49 +00:00
|
|
|
#include <linux/memblock.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/mm.h>
|
|
|
|
|
#include <linux/hugetlb.h>
|
|
|
|
|
#include <linux/initrd.h>
|
|
|
|
|
#include <linux/swap.h>
|
|
|
|
|
#include <linux/pagemap.h>
|
2006-06-27 09:53:52 +00:00
|
|
|
#include <linux/poison.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/fs.h>
|
|
|
|
|
#include <linux/seq_file.h>
|
2005-09-06 22:19:30 +00:00
|
|
|
#include <linux/kprobes.h>
|
2005-09-22 04:49:32 +00:00
|
|
|
#include <linux/cache.h>
|
2005-09-30 00:58:26 +00:00
|
|
|
#include <linux/sort.h>
|
2014-03-03 16:54:42 +00:00
|
|
|
#include <linux/ioport.h>
|
2007-05-25 22:49:59 +00:00
|
|
|
#include <linux/percpu.h>
|
2008-04-23 12:40:25 +00:00
|
|
|
#include <linux/mmzone.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/gfp.h>
|
mm: memory_hotplug: factor out bootmem core functions to bootmem_info.c
Patch series "Free some vmemmap pages of HugeTLB page", v23.
This patch series will free some vmemmap pages(struct page structures)
associated with each HugeTLB page when preallocated to save memory.
In order to reduce the difficulty of the first version of code review. In
this version, we disable PMD/huge page mapping of vmemmap if this feature
was enabled. This acutely eliminates a bunch of the complex code doing
page table manipulation. When this patch series is solid, we cam add the
code of vmemmap page table manipulation in the future.
The struct page structures (page structs) are used to describe a physical
page frame. By default, there is an one-to-one mapping from a page frame
to it's corresponding page struct.
The HugeTLB pages consist of multiple base page size pages and is
supported by many architectures. See hugetlbpage.rst in the Documentation
directory for more details. On the x86 architecture, HugeTLB pages of
size 2MB and 1GB are currently supported. Since the base page size on x86
is 4KB, a 2MB HugeTLB page consists of 512 base pages and a 1GB HugeTLB
page consists of 4096 base pages. For each base page, there is a
corresponding page struct.
Within the HugeTLB subsystem, only the first 4 page structs are used to
contain unique information about a HugeTLB page. HUGETLB_CGROUP_MIN_ORDER
provides this upper limit. The only 'useful' information in the remaining
page structs is the compound_head field, and this field is the same for
all tail pages.
By removing redundant page structs for HugeTLB pages, memory can returned
to the buddy allocator for other uses.
When the system boot up, every 2M HugeTLB has 512 struct page structs which
size is 8 pages(sizeof(struct page) * 512 / PAGE_SIZE).
HugeTLB struct pages(8 pages) page frame(8 pages)
+-----------+ ---virt_to_page---> +-----------+ mapping to +-----------+
| | | 0 | -------------> | 0 |
| | +-----------+ +-----------+
| | | 1 | -------------> | 1 |
| | +-----------+ +-----------+
| | | 2 | -------------> | 2 |
| | +-----------+ +-----------+
| | | 3 | -------------> | 3 |
| | +-----------+ +-----------+
| | | 4 | -------------> | 4 |
| 2MB | +-----------+ +-----------+
| | | 5 | -------------> | 5 |
| | +-----------+ +-----------+
| | | 6 | -------------> | 6 |
| | +-----------+ +-----------+
| | | 7 | -------------> | 7 |
| | +-----------+ +-----------+
| |
| |
| |
+-----------+
The value of page->compound_head is the same for all tail pages. The
first page of page structs (page 0) associated with the HugeTLB page
contains the 4 page structs necessary to describe the HugeTLB. The only
use of the remaining pages of page structs (page 1 to page 7) is to point
to page->compound_head. Therefore, we can remap pages 2 to 7 to page 1.
Only 2 pages of page structs will be used for each HugeTLB page. This
will allow us to free the remaining 6 pages to the buddy allocator.
Here is how things look after remapping.
HugeTLB struct pages(8 pages) page frame(8 pages)
+-----------+ ---virt_to_page---> +-----------+ mapping to +-----------+
| | | 0 | -------------> | 0 |
| | +-----------+ +-----------+
| | | 1 | -------------> | 1 |
| | +-----------+ +-----------+
| | | 2 | ----------------^ ^ ^ ^ ^ ^
| | +-----------+ | | | | |
| | | 3 | ------------------+ | | | |
| | +-----------+ | | | |
| | | 4 | --------------------+ | | |
| 2MB | +-----------+ | | |
| | | 5 | ----------------------+ | |
| | +-----------+ | |
| | | 6 | ------------------------+ |
| | +-----------+ |
| | | 7 | --------------------------+
| | +-----------+
| |
| |
| |
+-----------+
When a HugeTLB is freed to the buddy system, we should allocate 6 pages
for vmemmap pages and restore the previous mapping relationship.
Apart from 2MB HugeTLB page, we also have 1GB HugeTLB page. It is similar
to the 2MB HugeTLB page. We also can use this approach to free the
vmemmap pages.
In this case, for the 1GB HugeTLB page, we can save 4094 pages. This is a
very substantial gain. On our server, run some SPDK/QEMU applications
which will use 1024GB HugeTLB page. With this feature enabled, we can
save ~16GB (1G hugepage)/~12GB (2MB hugepage) memory.
Because there are vmemmap page tables reconstruction on the
freeing/allocating path, it increases some overhead. Here are some
overhead analysis.
1) Allocating 10240 2MB HugeTLB pages.
a) With this patch series applied:
# time echo 10240 > /proc/sys/vm/nr_hugepages
real 0m0.166s
user 0m0.000s
sys 0m0.166s
# bpftrace -e 'kprobe:alloc_fresh_huge_page { @start[tid] = nsecs; }
kretprobe:alloc_fresh_huge_page /@start[tid]/ { @latency = hist(nsecs -
@start[tid]); delete(@start[tid]); }'
Attaching 2 probes...
@latency:
[8K, 16K) 5476 |@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@|
[16K, 32K) 4760 |@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ |
[32K, 64K) 4 | |
b) Without this patch series:
# time echo 10240 > /proc/sys/vm/nr_hugepages
real 0m0.067s
user 0m0.000s
sys 0m0.067s
# bpftrace -e 'kprobe:alloc_fresh_huge_page { @start[tid] = nsecs; }
kretprobe:alloc_fresh_huge_page /@start[tid]/ { @latency = hist(nsecs -
@start[tid]); delete(@start[tid]); }'
Attaching 2 probes...
@latency:
[4K, 8K) 10147 |@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@|
[8K, 16K) 93 | |
Summarize: this feature is about ~2x slower than before.
2) Freeing 10240 2MB HugeTLB pages.
a) With this patch series applied:
# time echo 0 > /proc/sys/vm/nr_hugepages
real 0m0.213s
user 0m0.000s
sys 0m0.213s
# bpftrace -e 'kprobe:free_pool_huge_page { @start[tid] = nsecs; }
kretprobe:free_pool_huge_page /@start[tid]/ { @latency = hist(nsecs -
@start[tid]); delete(@start[tid]); }'
Attaching 2 probes...
@latency:
[8K, 16K) 6 | |
[16K, 32K) 10227 |@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@|
[32K, 64K) 7 | |
b) Without this patch series:
# time echo 0 > /proc/sys/vm/nr_hugepages
real 0m0.081s
user 0m0.000s
sys 0m0.081s
# bpftrace -e 'kprobe:free_pool_huge_page { @start[tid] = nsecs; }
kretprobe:free_pool_huge_page /@start[tid]/ { @latency = hist(nsecs -
@start[tid]); delete(@start[tid]); }'
Attaching 2 probes...
@latency:
[4K, 8K) 6805 |@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@|
[8K, 16K) 3427 |@@@@@@@@@@@@@@@@@@@@@@@@@@ |
[16K, 32K) 8 | |
Summary: The overhead of __free_hugepage is about ~2-3x slower than before.
Although the overhead has increased, the overhead is not significant.
Like Mike said, "However, remember that the majority of use cases create
HugeTLB pages at or shortly after boot time and add them to the pool. So,
additional overhead is at pool creation time. There is no change to
'normal run time' operations of getting a page from or returning a page to
the pool (think page fault/unmap)".
Despite the overhead and in addition to the memory gains from this series.
The following data is obtained by Joao Martins. Very thanks to his
effort.
There's an additional benefit which is page (un)pinners will see an improvement
and Joao presumes because there are fewer memmap pages and thus the tail/head
pages are staying in cache more often.
Out of the box Joao saw (when comparing linux-next against linux-next +
this series) with gup_test and pinning a 16G HugeTLB file (with 1G pages):
get_user_pages(): ~32k -> ~9k
unpin_user_pages(): ~75k -> ~70k
Usually any tight loop fetching compound_head(), or reading tail pages
data (e.g. compound_head) benefit a lot. There's some unpinning
inefficiencies Joao was fixing[2], but with that in added it shows even
more:
unpin_user_pages(): ~27k -> ~3.8k
[1] https://lore.kernel.org/linux-mm/20210409205254.242291-1-mike.kravetz@oracle.com/
[2] https://lore.kernel.org/linux-mm/20210204202500.26474-1-joao.m.martins@oracle.com/
This patch (of 9):
Move bootmem info registration common API to individual bootmem_info.c.
And we will use {get,put}_page_bootmem() to initialize the page for the
vmemmap pages or free the vmemmap pages to buddy in the later patch. So
move them out of CONFIG_MEMORY_HOTPLUG_SPARSE. This is just code movement
without any functional change.
Link: https://lkml.kernel.org/r/20210510030027.56044-1-songmuchun@bytedance.com
Link: https://lkml.kernel.org/r/20210510030027.56044-2-songmuchun@bytedance.com
Signed-off-by: Muchun Song <songmuchun@bytedance.com>
Acked-by: Mike Kravetz <mike.kravetz@oracle.com>
Reviewed-by: Oscar Salvador <osalvador@suse.de>
Reviewed-by: David Hildenbrand <david@redhat.com>
Reviewed-by: Miaohe Lin <linmiaohe@huawei.com>
Tested-by: Chen Huang <chenhuang5@huawei.com>
Tested-by: Bodeddula Balasubramaniam <bodeddub@amazon.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: x86@kernel.org
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Dave Hansen <dave.hansen@linux.intel.com>
Cc: Andy Lutomirski <luto@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Alexander Viro <viro@zeniv.linux.org.uk>
Cc: Paul E. McKenney <paulmck@kernel.org>
Cc: Pawan Gupta <pawan.kumar.gupta@linux.intel.com>
Cc: Randy Dunlap <rdunlap@infradead.org>
Cc: Oliver Neukum <oneukum@suse.com>
Cc: Anshuman Khandual <anshuman.khandual@arm.com>
Cc: Joerg Roedel <jroedel@suse.de>
Cc: Mina Almasry <almasrymina@google.com>
Cc: David Rientjes <rientjes@google.com>
Cc: Matthew Wilcox <willy@infradead.org>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Barry Song <song.bao.hua@hisilicon.com>
Cc: HORIGUCHI NAOYA <naoya.horiguchi@nec.com>
Cc: Joao Martins <joao.m.martins@oracle.com>
Cc: Xiongchun Duan <duanxiongchun@bytedance.com>
Cc: Balbir Singh <bsingharora@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-07-01 01:47:00 +00:00
|
|
|
#include <linux/bootmem_info.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
#include <asm/head.h>
|
|
|
|
|
#include <asm/page.h>
|
|
|
|
|
#include <asm/pgalloc.h>
|
|
|
|
|
#include <asm/oplib.h>
|
|
|
|
|
#include <asm/iommu.h>
|
|
|
|
|
#include <asm/io.h>
|
2016-12-24 19:46:01 +00:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/mmu_context.h>
|
|
|
|
|
#include <asm/tlbflush.h>
|
|
|
|
|
#include <asm/dma.h>
|
|
|
|
|
#include <asm/starfire.h>
|
|
|
|
|
#include <asm/tlb.h>
|
|
|
|
|
#include <asm/spitfire.h>
|
|
|
|
|
#include <asm/sections.h>
|
2006-02-01 23:55:21 +00:00
|
|
|
#include <asm/tsb.h>
|
2006-02-08 05:51:08 +00:00
|
|
|
#include <asm/hypervisor.h>
|
2006-06-21 22:35:28 +00:00
|
|
|
#include <asm/prom.h>
|
2007-05-25 22:49:59 +00:00
|
|
|
#include <asm/mdesc.h>
|
2008-03-26 04:51:40 +00:00
|
|
|
#include <asm/cpudata.h>
|
2014-05-16 21:26:07 +00:00
|
|
|
#include <asm/setup.h>
|
2008-08-13 01:33:56 +00:00
|
|
|
#include <asm/irq.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-11-17 04:08:45 +00:00
|
|
|
#include "init_64.h"
|
2006-02-22 04:51:13 +00:00
|
|
|
|
2012-09-07 01:13:58 +00:00
|
|
|
unsigned long kern_linear_pte_xor[4] __read_mostly;
|
2015-05-27 16:00:46 +00:00
|
|
|
static unsigned long page_cache4v_flag;
|
2006-02-22 04:51:13 +00:00
|
|
|
|
2012-09-07 01:13:58 +00:00
|
|
|
/* A bitmap, two bits for every 256MB of physical memory. These two
|
|
|
|
|
* bits determine what page size we use for kernel linear
|
|
|
|
|
* translations. They form an index into kern_linear_pte_xor[]. The
|
|
|
|
|
* value in the indexed slot is XOR'd with the TLB miss virtual
|
|
|
|
|
* address to form the resulting TTE. The mapping is:
|
|
|
|
|
*
|
|
|
|
|
* 0 ==> 4MB
|
|
|
|
|
* 1 ==> 256MB
|
|
|
|
|
* 2 ==> 2GB
|
|
|
|
|
* 3 ==> 16GB
|
|
|
|
|
*
|
|
|
|
|
* All sun4v chips support 256MB pages. Only SPARC-T4 and later
|
|
|
|
|
* support 2GB pages, and hopefully future cpus will support the 16GB
|
|
|
|
|
* pages as well. For slots 2 and 3, we encode a 256MB TTE xor there
|
|
|
|
|
* if these larger page sizes are not supported by the cpu.
|
|
|
|
|
*
|
|
|
|
|
* It would be nice to determine this from the machine description
|
|
|
|
|
* 'cpu' properties, but we need to have this table setup before the
|
|
|
|
|
* MDESC is initialized.
|
2006-02-22 04:51:13 +00:00
|
|
|
*/
|
|
|
|
|
|
2007-03-17 00:20:28 +00:00
|
|
|
#ifndef CONFIG_DEBUG_PAGEALLOC
|
2012-09-07 01:13:58 +00:00
|
|
|
/* A special kernel TSB for 4MB, 256MB, 2GB and 16GB linear mappings.
|
|
|
|
|
* Space is allocated for this right after the trap table in
|
|
|
|
|
* arch/sparc64/kernel/head.S
|
2007-05-29 08:58:31 +00:00
|
|
|
*/
|
|
|
|
|
extern struct tsb swapper_4m_tsb[KERNEL_TSB4M_NENTRIES];
|
2007-03-17 00:20:28 +00:00
|
|
|
#endif
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
extern struct tsb swapper_tsb[KERNEL_TSB_NENTRIES];
|
2006-02-22 06:31:11 +00:00
|
|
|
|
2012-09-07 02:01:25 +00:00
|
|
|
static unsigned long cpu_pgsz_mask;
|
|
|
|
|
|
2014-09-28 04:30:57 +00:00
|
|
|
#define MAX_BANKS 1024
|
2005-09-30 00:58:26 +00:00
|
|
|
|
2012-12-21 22:03:26 +00:00
|
|
|
static struct linux_prom64_registers pavail[MAX_BANKS];
|
|
|
|
|
static int pavail_ents;
|
2005-09-30 00:58:26 +00:00
|
|
|
|
2015-11-02 21:30:24 +00:00
|
|
|
u64 numa_latency[MAX_NUMNODES][MAX_NUMNODES];
|
|
|
|
|
|
2005-09-30 00:58:26 +00:00
|
|
|
static int cmp_p64(const void *a, const void *b)
|
|
|
|
|
{
|
|
|
|
|
const struct linux_prom64_registers *x = a, *y = b;
|
|
|
|
|
|
|
|
|
|
if (x->phys_addr > y->phys_addr)
|
|
|
|
|
return 1;
|
|
|
|
|
if (x->phys_addr < y->phys_addr)
|
|
|
|
|
return -1;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void __init read_obp_memory(const char *property,
|
|
|
|
|
struct linux_prom64_registers *regs,
|
|
|
|
|
int *num_ents)
|
|
|
|
|
{
|
2010-10-08 21:18:11 +00:00
|
|
|
phandle node = prom_finddevice("/memory");
|
2005-09-30 00:58:26 +00:00
|
|
|
int prop_size = prom_getproplen(node, property);
|
|
|
|
|
int ents, ret, i;
|
|
|
|
|
|
|
|
|
|
ents = prop_size / sizeof(struct linux_prom64_registers);
|
|
|
|
|
if (ents > MAX_BANKS) {
|
|
|
|
|
prom_printf("The machine has more %s property entries than "
|
|
|
|
|
"this kernel can support (%d).\n",
|
|
|
|
|
property, MAX_BANKS);
|
|
|
|
|
prom_halt();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ret = prom_getproperty(node, property, (char *) regs, prop_size);
|
|
|
|
|
if (ret == -1) {
|
2012-09-29 03:14:49 +00:00
|
|
|
prom_printf("Couldn't get %s property from /memory.\n",
|
|
|
|
|
property);
|
2005-09-30 00:58:26 +00:00
|
|
|
prom_halt();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Sanitize what we got from the firmware, by page aligning
|
|
|
|
|
* everything.
|
|
|
|
|
*/
|
|
|
|
|
for (i = 0; i < ents; i++) {
|
|
|
|
|
unsigned long base, size;
|
|
|
|
|
|
|
|
|
|
base = regs[i].phys_addr;
|
|
|
|
|
size = regs[i].reg_size;
|
2005-09-29 04:46:43 +00:00
|
|
|
|
2005-09-30 00:58:26 +00:00
|
|
|
size &= PAGE_MASK;
|
|
|
|
|
if (base & ~PAGE_MASK) {
|
|
|
|
|
unsigned long new_base = PAGE_ALIGN(base);
|
|
|
|
|
|
|
|
|
|
size -= new_base - base;
|
|
|
|
|
if ((long) size < 0L)
|
|
|
|
|
size = 0UL;
|
|
|
|
|
base = new_base;
|
|
|
|
|
}
|
2007-03-15 07:06:34 +00:00
|
|
|
if (size == 0UL) {
|
|
|
|
|
/* If it is empty, simply get rid of it.
|
|
|
|
|
* This simplifies the logic of the other
|
|
|
|
|
* functions that process these arrays.
|
|
|
|
|
*/
|
|
|
|
|
memmove(®s[i], ®s[i + 1],
|
|
|
|
|
(ents - i - 1) * sizeof(regs[0]));
|
2006-06-22 07:00:00 +00:00
|
|
|
i--;
|
2007-03-15 07:06:34 +00:00
|
|
|
ents--;
|
|
|
|
|
continue;
|
2006-06-22 07:00:00 +00:00
|
|
|
}
|
2007-03-15 07:06:34 +00:00
|
|
|
regs[i].phys_addr = base;
|
|
|
|
|
regs[i].reg_size = size;
|
2006-06-22 07:00:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
*num_ents = ents;
|
|
|
|
|
|
2005-10-12 19:22:46 +00:00
|
|
|
sort(regs, ents, sizeof(struct linux_prom64_registers),
|
2005-09-30 00:58:26 +00:00
|
|
|
cmp_p64, NULL);
|
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-03-08 10:16:07 +00:00
|
|
|
/* Kernel physical address base and size in bytes. */
|
2005-09-22 04:49:32 +00:00
|
|
|
unsigned long kern_base __read_mostly;
|
|
|
|
|
unsigned long kern_size __read_mostly;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/* Initial ramdisk setup */
|
|
|
|
|
extern unsigned long sparc_ramdisk_image64;
|
|
|
|
|
extern unsigned int sparc_ramdisk_image;
|
|
|
|
|
extern unsigned int sparc_ramdisk_size;
|
|
|
|
|
|
2005-09-22 04:49:32 +00:00
|
|
|
struct page *mem_map_zero __read_mostly;
|
2008-04-29 12:11:12 +00:00
|
|
|
EXPORT_SYMBOL(mem_map_zero);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-10-04 22:23:20 +00:00
|
|
|
unsigned int sparc64_highest_unlocked_tlb_ent __read_mostly;
|
|
|
|
|
|
|
|
|
|
unsigned long sparc64_kern_pri_context __read_mostly;
|
|
|
|
|
unsigned long sparc64_kern_pri_nuc_bits __read_mostly;
|
|
|
|
|
unsigned long sparc64_kern_sec_context __read_mostly;
|
|
|
|
|
|
2008-03-22 00:01:38 +00:00
|
|
|
int num_kernel_image_mappings;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_DEBUG_DCFLUSH
|
|
|
|
|
atomic_t dcpage_flushes = ATOMIC_INIT(0);
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
atomic_t dcpage_flushes_xcall = ATOMIC_INIT(0);
|
|
|
|
|
#endif
|
|
|
|
|
#endif
|
|
|
|
|
|
2006-02-27 03:44:50 +00:00
|
|
|
inline void flush_dcache_page_impl(struct page *page)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-02-27 03:44:50 +00:00
|
|
|
BUG_ON(tlb_type == hypervisor);
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifdef CONFIG_DEBUG_DCFLUSH
|
|
|
|
|
atomic_inc(&dcpage_flushes);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef DCACHE_ALIASING_POSSIBLE
|
|
|
|
|
__flush_dcache_page(page_address(page),
|
|
|
|
|
((tlb_type == spitfire) &&
|
mm: fix races between swapoff and flush dcache
Thanks to commit 4b3ef9daa4fc ("mm/swap: split swap cache into 64MB
trunks"), after swapoff the address_space associated with the swap
device will be freed. So page_mapping() users which may touch the
address_space need some kind of mechanism to prevent the address_space
from being freed during accessing.
The dcache flushing functions (flush_dcache_page(), etc) in architecture
specific code may access the address_space of swap device for anonymous
pages in swap cache via page_mapping() function. But in some cases
there are no mechanisms to prevent the swap device from being swapoff,
for example,
CPU1 CPU2
__get_user_pages() swapoff()
flush_dcache_page()
mapping = page_mapping()
... exit_swap_address_space()
... kvfree(spaces)
mapping_mapped(mapping)
The address space may be accessed after being freed.
But from cachetlb.txt and Russell King, flush_dcache_page() only care
about file cache pages, for anonymous pages, flush_anon_page() should be
used. The implementation of flush_dcache_page() in all architectures
follows this too. They will check whether page_mapping() is NULL and
whether mapping_mapped() is true to determine whether to flush the
dcache immediately. And they will use interval tree (mapping->i_mmap)
to find all user space mappings. While mapping_mapped() and
mapping->i_mmap isn't used by anonymous pages in swap cache at all.
So, to fix the race between swapoff and flush dcache, __page_mapping()
is add to return the address_space for file cache pages and NULL
otherwise. All page_mapping() invoking in flush dcache functions are
replaced with page_mapping_file().
[akpm@linux-foundation.org: simplify page_mapping_file(), per Mike]
Link: http://lkml.kernel.org/r/20180305083634.15174-1-ying.huang@intel.com
Signed-off-by: "Huang, Ying" <ying.huang@intel.com>
Reviewed-by: Andrew Morton <akpm@linux-foundation.org>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Mel Gorman <mgorman@techsingularity.net>
Cc: Dave Hansen <dave.hansen@intel.com>
Cc: Chen Liqin <liqin.linux@gmail.com>
Cc: Russell King <linux@armlinux.org.uk>
Cc: Yoshinori Sato <ysato@users.sourceforge.jp>
Cc: "James E.J. Bottomley" <jejb@parisc-linux.org>
Cc: Guan Xuetao <gxt@mprc.pku.edu.cn>
Cc: "David S. Miller" <davem@davemloft.net>
Cc: Chris Zankel <chris@zankel.net>
Cc: Vineet Gupta <vgupta@synopsys.com>
Cc: Ley Foon Tan <lftan@altera.com>
Cc: Ralf Baechle <ralf@linux-mips.org>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Mike Rapoport <rppt@linux.vnet.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-05 23:24:39 +00:00
|
|
|
page_mapping_file(page) != NULL));
|
2005-04-16 22:20:36 +00:00
|
|
|
#else
|
mm: fix races between swapoff and flush dcache
Thanks to commit 4b3ef9daa4fc ("mm/swap: split swap cache into 64MB
trunks"), after swapoff the address_space associated with the swap
device will be freed. So page_mapping() users which may touch the
address_space need some kind of mechanism to prevent the address_space
from being freed during accessing.
The dcache flushing functions (flush_dcache_page(), etc) in architecture
specific code may access the address_space of swap device for anonymous
pages in swap cache via page_mapping() function. But in some cases
there are no mechanisms to prevent the swap device from being swapoff,
for example,
CPU1 CPU2
__get_user_pages() swapoff()
flush_dcache_page()
mapping = page_mapping()
... exit_swap_address_space()
... kvfree(spaces)
mapping_mapped(mapping)
The address space may be accessed after being freed.
But from cachetlb.txt and Russell King, flush_dcache_page() only care
about file cache pages, for anonymous pages, flush_anon_page() should be
used. The implementation of flush_dcache_page() in all architectures
follows this too. They will check whether page_mapping() is NULL and
whether mapping_mapped() is true to determine whether to flush the
dcache immediately. And they will use interval tree (mapping->i_mmap)
to find all user space mappings. While mapping_mapped() and
mapping->i_mmap isn't used by anonymous pages in swap cache at all.
So, to fix the race between swapoff and flush dcache, __page_mapping()
is add to return the address_space for file cache pages and NULL
otherwise. All page_mapping() invoking in flush dcache functions are
replaced with page_mapping_file().
[akpm@linux-foundation.org: simplify page_mapping_file(), per Mike]
Link: http://lkml.kernel.org/r/20180305083634.15174-1-ying.huang@intel.com
Signed-off-by: "Huang, Ying" <ying.huang@intel.com>
Reviewed-by: Andrew Morton <akpm@linux-foundation.org>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Mel Gorman <mgorman@techsingularity.net>
Cc: Dave Hansen <dave.hansen@intel.com>
Cc: Chen Liqin <liqin.linux@gmail.com>
Cc: Russell King <linux@armlinux.org.uk>
Cc: Yoshinori Sato <ysato@users.sourceforge.jp>
Cc: "James E.J. Bottomley" <jejb@parisc-linux.org>
Cc: Guan Xuetao <gxt@mprc.pku.edu.cn>
Cc: "David S. Miller" <davem@davemloft.net>
Cc: Chris Zankel <chris@zankel.net>
Cc: Vineet Gupta <vgupta@synopsys.com>
Cc: Ley Foon Tan <lftan@altera.com>
Cc: Ralf Baechle <ralf@linux-mips.org>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Mike Rapoport <rppt@linux.vnet.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-05 23:24:39 +00:00
|
|
|
if (page_mapping_file(page) != NULL &&
|
2005-04-16 22:20:36 +00:00
|
|
|
tlb_type == spitfire)
|
|
|
|
|
__flush_icache_page(__pa(page_address(page)));
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define PG_dcache_dirty PG_arch_1
|
2007-05-26 08:14:43 +00:00
|
|
|
#define PG_dcache_cpu_shift 32UL
|
|
|
|
|
#define PG_dcache_cpu_mask \
|
|
|
|
|
((1UL<<ilog2(roundup_pow_of_two(NR_CPUS)))-1UL)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
#define dcache_dirty_cpu(page) \
|
2005-07-27 23:08:44 +00:00
|
|
|
(((page)->flags >> PG_dcache_cpu_shift) & PG_dcache_cpu_mask)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-10-27 07:13:04 +00:00
|
|
|
static inline void set_dcache_dirty(struct page *page, int this_cpu)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
|
unsigned long mask = this_cpu;
|
2005-07-27 23:08:44 +00:00
|
|
|
unsigned long non_cpu_bits;
|
|
|
|
|
|
|
|
|
|
non_cpu_bits = ~(PG_dcache_cpu_mask << PG_dcache_cpu_shift);
|
|
|
|
|
mask = (mask << PG_dcache_cpu_shift) | (1UL << PG_dcache_dirty);
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
__asm__ __volatile__("1:\n\t"
|
|
|
|
|
"ldx [%2], %%g7\n\t"
|
|
|
|
|
"and %%g7, %1, %%g1\n\t"
|
|
|
|
|
"or %%g1, %0, %%g1\n\t"
|
|
|
|
|
"casx [%2], %%g7, %%g1\n\t"
|
|
|
|
|
"cmp %%g7, %%g1\n\t"
|
|
|
|
|
"bne,pn %%xcc, 1b\n\t"
|
[SPARC64]: Avoid membar instructions in delay slots.
In particular, avoid membar instructions in the delay
slot of a jmpl instruction.
UltraSPARC-I, II, IIi, and IIe have a bug, documented in
the UltraSPARC-IIi User's Manual, Appendix K, Erratum 51
The long and short of it is that if the IMU unit misses
on a branch or jmpl, and there is a store buffer synchronizing
membar in the delay slot, the chip can stop fetching instructions.
If interrupts are enabled or some other trap is enabled, the
chip will unwedge itself, but performance will suffer.
We already had a workaround for this bug in a few spots, but
it's better to have the entire tree sanitized for this rule.
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-27 22:42:04 +00:00
|
|
|
" nop"
|
2005-04-16 22:20:36 +00:00
|
|
|
: /* no outputs */
|
|
|
|
|
: "r" (mask), "r" (non_cpu_bits), "r" (&page->flags)
|
|
|
|
|
: "g1", "g7");
|
|
|
|
|
}
|
|
|
|
|
|
2007-10-27 07:13:04 +00:00
|
|
|
static inline void clear_dcache_dirty_cpu(struct page *page, unsigned long cpu)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
|
unsigned long mask = (1UL << PG_dcache_dirty);
|
|
|
|
|
|
|
|
|
|
__asm__ __volatile__("! test_and_clear_dcache_dirty\n"
|
|
|
|
|
"1:\n\t"
|
|
|
|
|
"ldx [%2], %%g7\n\t"
|
2005-07-27 23:08:44 +00:00
|
|
|
"srlx %%g7, %4, %%g1\n\t"
|
2005-04-16 22:20:36 +00:00
|
|
|
"and %%g1, %3, %%g1\n\t"
|
|
|
|
|
"cmp %%g1, %0\n\t"
|
|
|
|
|
"bne,pn %%icc, 2f\n\t"
|
|
|
|
|
" andn %%g7, %1, %%g1\n\t"
|
|
|
|
|
"casx [%2], %%g7, %%g1\n\t"
|
|
|
|
|
"cmp %%g7, %%g1\n\t"
|
|
|
|
|
"bne,pn %%xcc, 1b\n\t"
|
[SPARC64]: Avoid membar instructions in delay slots.
In particular, avoid membar instructions in the delay
slot of a jmpl instruction.
UltraSPARC-I, II, IIi, and IIe have a bug, documented in
the UltraSPARC-IIi User's Manual, Appendix K, Erratum 51
The long and short of it is that if the IMU unit misses
on a branch or jmpl, and there is a store buffer synchronizing
membar in the delay slot, the chip can stop fetching instructions.
If interrupts are enabled or some other trap is enabled, the
chip will unwedge itself, but performance will suffer.
We already had a workaround for this bug in a few spots, but
it's better to have the entire tree sanitized for this rule.
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-27 22:42:04 +00:00
|
|
|
" nop\n"
|
2005-04-16 22:20:36 +00:00
|
|
|
"2:"
|
|
|
|
|
: /* no outputs */
|
|
|
|
|
: "r" (cpu), "r" (mask), "r" (&page->flags),
|
2005-07-27 23:08:44 +00:00
|
|
|
"i" (PG_dcache_cpu_mask),
|
|
|
|
|
"i" (PG_dcache_cpu_shift)
|
2005-04-16 22:20:36 +00:00
|
|
|
: "g1", "g7");
|
|
|
|
|
}
|
|
|
|
|
|
2006-02-01 23:55:21 +00:00
|
|
|
static inline void tsb_insert(struct tsb *ent, unsigned long tag, unsigned long pte)
|
|
|
|
|
{
|
|
|
|
|
unsigned long tsb_addr = (unsigned long) ent;
|
|
|
|
|
|
2006-02-17 17:54:42 +00:00
|
|
|
if (tlb_type == cheetah_plus || tlb_type == hypervisor)
|
2006-02-01 23:55:21 +00:00
|
|
|
tsb_addr = __pa(tsb_addr);
|
|
|
|
|
|
|
|
|
|
__tsb_insert(tsb_addr, tag, pte);
|
|
|
|
|
}
|
|
|
|
|
|
2006-02-12 05:57:54 +00:00
|
|
|
unsigned long _PAGE_ALL_SZ_BITS __read_mostly;
|
|
|
|
|
|
2009-01-06 20:51:26 +00:00
|
|
|
static void flush_dcache(unsigned long pfn)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-01-06 20:51:26 +00:00
|
|
|
struct page *page;
|
2006-02-27 03:44:50 +00:00
|
|
|
|
2009-01-06 20:51:26 +00:00
|
|
|
page = pfn_to_page(pfn);
|
2009-10-12 10:20:57 +00:00
|
|
|
if (page) {
|
2006-02-27 03:44:50 +00:00
|
|
|
unsigned long pg_flags;
|
|
|
|
|
|
2009-01-06 20:51:26 +00:00
|
|
|
pg_flags = page->flags;
|
|
|
|
|
if (pg_flags & (1UL << PG_dcache_dirty)) {
|
2006-02-27 03:44:50 +00:00
|
|
|
int cpu = ((pg_flags >> PG_dcache_cpu_shift) &
|
|
|
|
|
PG_dcache_cpu_mask);
|
|
|
|
|
int this_cpu = get_cpu();
|
|
|
|
|
|
|
|
|
|
/* This is just to optimize away some function calls
|
|
|
|
|
* in the SMP case.
|
|
|
|
|
*/
|
|
|
|
|
if (cpu == this_cpu)
|
|
|
|
|
flush_dcache_page_impl(page);
|
|
|
|
|
else
|
|
|
|
|
smp_flush_dcache_page_impl(page, cpu);
|
|
|
|
|
|
|
|
|
|
clear_dcache_dirty_cpu(page, cpu);
|
|
|
|
|
|
|
|
|
|
put_cpu();
|
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2009-01-06 20:51:26 +00:00
|
|
|
}
|
|
|
|
|
|
2012-10-08 23:34:29 +00:00
|
|
|
/* mm->context.lock must be held */
|
|
|
|
|
static void __update_mmu_tsb_insert(struct mm_struct *mm, unsigned long tsb_index,
|
|
|
|
|
unsigned long tsb_hash_shift, unsigned long address,
|
|
|
|
|
unsigned long tte)
|
|
|
|
|
{
|
|
|
|
|
struct tsb *tsb = mm->context.tsb_block[tsb_index].tsb;
|
|
|
|
|
unsigned long tag;
|
|
|
|
|
|
2013-02-19 21:20:08 +00:00
|
|
|
if (unlikely(!tsb))
|
|
|
|
|
return;
|
|
|
|
|
|
2012-10-08 23:34:29 +00:00
|
|
|
tsb += ((address >> tsb_hash_shift) &
|
|
|
|
|
(mm->context.tsb_block[tsb_index].tsb_nentries - 1UL));
|
|
|
|
|
tag = (address >> 22UL);
|
|
|
|
|
tsb_insert(tsb, tag, tte);
|
|
|
|
|
}
|
|
|
|
|
|
2017-02-02 00:16:36 +00:00
|
|
|
#ifdef CONFIG_HUGETLB_PAGE
|
2017-07-20 00:12:54 +00:00
|
|
|
static int __init hugetlbpage_init(void)
|
|
|
|
|
{
|
2020-06-03 23:00:42 +00:00
|
|
|
hugetlb_add_hstate(HPAGE_64K_SHIFT - PAGE_SHIFT);
|
|
|
|
|
hugetlb_add_hstate(HPAGE_SHIFT - PAGE_SHIFT);
|
|
|
|
|
hugetlb_add_hstate(HPAGE_256MB_SHIFT - PAGE_SHIFT);
|
|
|
|
|
hugetlb_add_hstate(HPAGE_2GB_SHIFT - PAGE_SHIFT);
|
2017-07-20 00:12:54 +00:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
arch_initcall(hugetlbpage_init);
|
|
|
|
|
|
2017-08-11 23:46:50 +00:00
|
|
|
static void __init pud_huge_patch(void)
|
|
|
|
|
{
|
|
|
|
|
struct pud_huge_patch_entry *p;
|
|
|
|
|
unsigned long addr;
|
|
|
|
|
|
|
|
|
|
p = &__pud_huge_patch;
|
|
|
|
|
addr = p->addr;
|
|
|
|
|
*(unsigned int *)addr = p->insn;
|
|
|
|
|
|
|
|
|
|
__asm__ __volatile__("flush %0" : : "r" (addr));
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-03 23:00:34 +00:00
|
|
|
bool __init arch_hugetlb_valid_size(unsigned long size)
|
2017-02-02 00:16:36 +00:00
|
|
|
{
|
2020-06-03 23:00:34 +00:00
|
|
|
unsigned int hugepage_shift = ilog2(size);
|
2017-02-02 00:16:36 +00:00
|
|
|
unsigned short hv_pgsz_idx;
|
|
|
|
|
unsigned int hv_pgsz_mask;
|
|
|
|
|
|
|
|
|
|
switch (hugepage_shift) {
|
2017-08-11 23:46:50 +00:00
|
|
|
case HPAGE_16GB_SHIFT:
|
|
|
|
|
hv_pgsz_mask = HV_PGSZ_MASK_16GB;
|
|
|
|
|
hv_pgsz_idx = HV_PGSZ_IDX_16GB;
|
|
|
|
|
pud_huge_patch();
|
|
|
|
|
break;
|
2017-03-09 22:22:23 +00:00
|
|
|
case HPAGE_2GB_SHIFT:
|
|
|
|
|
hv_pgsz_mask = HV_PGSZ_MASK_2GB;
|
|
|
|
|
hv_pgsz_idx = HV_PGSZ_IDX_2GB;
|
|
|
|
|
break;
|
2017-02-02 00:16:36 +00:00
|
|
|
case HPAGE_256MB_SHIFT:
|
|
|
|
|
hv_pgsz_mask = HV_PGSZ_MASK_256MB;
|
|
|
|
|
hv_pgsz_idx = HV_PGSZ_IDX_256MB;
|
|
|
|
|
break;
|
|
|
|
|
case HPAGE_SHIFT:
|
|
|
|
|
hv_pgsz_mask = HV_PGSZ_MASK_4MB;
|
|
|
|
|
hv_pgsz_idx = HV_PGSZ_IDX_4MB;
|
|
|
|
|
break;
|
2017-02-06 20:33:26 +00:00
|
|
|
case HPAGE_64K_SHIFT:
|
|
|
|
|
hv_pgsz_mask = HV_PGSZ_MASK_64K;
|
|
|
|
|
hv_pgsz_idx = HV_PGSZ_IDX_64K;
|
|
|
|
|
break;
|
2017-02-02 00:16:36 +00:00
|
|
|
default:
|
|
|
|
|
hv_pgsz_mask = 0;
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-03 23:00:34 +00:00
|
|
|
if ((hv_pgsz_mask & cpu_pgsz_mask) == 0U)
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
2017-02-02 00:16:36 +00:00
|
|
|
#endif /* CONFIG_HUGETLB_PAGE */
|
|
|
|
|
|
MM: Pass a PTE pointer to update_mmu_cache() rather than the PTE itself
On VIVT ARM, when we have multiple shared mappings of the same file
in the same MM, we need to ensure that we have coherency across all
copies. We do this via make_coherent() by making the pages
uncacheable.
This used to work fine, until we allowed highmem with highpte - we
now have a page table which is mapped as required, and is not available
for modification via update_mmu_cache().
Ralf Beache suggested getting rid of the PTE value passed to
update_mmu_cache():
On MIPS update_mmu_cache() calls __update_tlb() which walks pagetables
to construct a pointer to the pte again. Passing a pte_t * is much
more elegant. Maybe we might even replace the pte argument with the
pte_t?
Ben Herrenschmidt would also like the pte pointer for PowerPC:
Passing the ptep in there is exactly what I want. I want that
-instead- of the PTE value, because I have issue on some ppc cases,
for I$/D$ coherency, where set_pte_at() may decide to mask out the
_PAGE_EXEC.
So, pass in the mapped page table pointer into update_mmu_cache(), and
remove the PTE value, updating all implementations and call sites to
suit.
Includes a fix from Stephen Rothwell:
sparc: fix fallout from update_mmu_cache API change
Signed-off-by: Stephen Rothwell <sfr@canb.auug.org.au>
Acked-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2009-12-18 16:40:18 +00:00
|
|
|
void update_mmu_cache(struct vm_area_struct *vma, unsigned long address, pte_t *ptep)
|
2009-01-06 20:51:26 +00:00
|
|
|
{
|
|
|
|
|
struct mm_struct *mm;
|
2013-02-19 21:20:08 +00:00
|
|
|
unsigned long flags;
|
2017-08-11 23:46:50 +00:00
|
|
|
bool is_huge_tsb;
|
MM: Pass a PTE pointer to update_mmu_cache() rather than the PTE itself
On VIVT ARM, when we have multiple shared mappings of the same file
in the same MM, we need to ensure that we have coherency across all
copies. We do this via make_coherent() by making the pages
uncacheable.
This used to work fine, until we allowed highmem with highpte - we
now have a page table which is mapped as required, and is not available
for modification via update_mmu_cache().
Ralf Beache suggested getting rid of the PTE value passed to
update_mmu_cache():
On MIPS update_mmu_cache() calls __update_tlb() which walks pagetables
to construct a pointer to the pte again. Passing a pte_t * is much
more elegant. Maybe we might even replace the pte argument with the
pte_t?
Ben Herrenschmidt would also like the pte pointer for PowerPC:
Passing the ptep in there is exactly what I want. I want that
-instead- of the PTE value, because I have issue on some ppc cases,
for I$/D$ coherency, where set_pte_at() may decide to mask out the
_PAGE_EXEC.
So, pass in the mapped page table pointer into update_mmu_cache(), and
remove the PTE value, updating all implementations and call sites to
suit.
Includes a fix from Stephen Rothwell:
sparc: fix fallout from update_mmu_cache API change
Signed-off-by: Stephen Rothwell <sfr@canb.auug.org.au>
Acked-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2009-12-18 16:40:18 +00:00
|
|
|
pte_t pte = *ptep;
|
2009-01-06 20:51:26 +00:00
|
|
|
|
|
|
|
|
if (tlb_type != hypervisor) {
|
|
|
|
|
unsigned long pfn = pte_pfn(pte);
|
|
|
|
|
|
|
|
|
|
if (pfn_valid(pfn))
|
|
|
|
|
flush_dcache(pfn);
|
|
|
|
|
}
|
2006-02-01 02:31:38 +00:00
|
|
|
|
|
|
|
|
mm = vma->vm_mm;
|
[SPARC64]: Fix and re-enable dynamic TSB sizing.
This is good for up to %50 performance improvement of some test cases.
The problem has been the race conditions, and hopefully I've plugged
them all up here.
1) There was a serious race in switch_mm() wrt. lazy TLB
switching to and from kernel threads.
We could erroneously skip a tsb_context_switch() and thus
use a stale TSB across a TSB grow event.
There is a big comment now in that function describing
exactly how it can happen.
2) All code paths that do something with the TSB need to be
guarded with the mm->context.lock spinlock. This makes
page table flushing paths properly synchronize with both
TSB growing and TLB context changes.
3) TSB growing events are moved to the end of successful fault
processing. Previously it was in update_mmu_cache() but
that is deadlock prone. At the end of do_sparc64_fault()
we hold no spinlocks that could deadlock the TSB grow
sequence. We also have dropped the address space semaphore.
While we're here, add prefetching to the copy_tsb() routine
and put it in assembler into the tsb.S file. This piece of
code is quite time critical.
There are some small negative side effects to this code which
can be improved upon. In particular we grab the mm->context.lock
even for the tsb insert done by update_mmu_cache() now and that's
a bit excessive. We can get rid of that locking, and the same
lock taking in flush_tsb_user(), by disabling PSTATE_IE around
the whole operation including the capturing of the tsb pointer
and tsb_nentries value. That would work because anyone growing
the TSB won't free up the old TSB until all cpus respond to the
TSB change cross call.
I'm not quite so confident in that optimization to put it in
right now, but eventually we might be able to and the description
is here for reference.
This code seems very solid now. It passes several parallel GCC
bootstrap builds, and our favorite "nut cruncher" stress test which is
a full "make -j8192" build of a "make allmodconfig" kernel. That puts
about 256 processes on each cpu's run queue, makes lots of process cpu
migrations occur, causes lots of page table and TLB flushing activity,
incurs many context version number changes, and it swaps the machine
real far out to disk even though there is 16GB of ram on this test
system. :-)
Signed-off-by: David S. Miller <davem@davemloft.net>
2006-03-16 10:02:32 +00:00
|
|
|
|
2014-08-04 23:34:01 +00:00
|
|
|
/* Don't insert a non-valid PTE into the TSB, we'll deadlock. */
|
|
|
|
|
if (!pte_accessible(mm, pte))
|
|
|
|
|
return;
|
|
|
|
|
|
[SPARC64]: Fix and re-enable dynamic TSB sizing.
This is good for up to %50 performance improvement of some test cases.
The problem has been the race conditions, and hopefully I've plugged
them all up here.
1) There was a serious race in switch_mm() wrt. lazy TLB
switching to and from kernel threads.
We could erroneously skip a tsb_context_switch() and thus
use a stale TSB across a TSB grow event.
There is a big comment now in that function describing
exactly how it can happen.
2) All code paths that do something with the TSB need to be
guarded with the mm->context.lock spinlock. This makes
page table flushing paths properly synchronize with both
TSB growing and TLB context changes.
3) TSB growing events are moved to the end of successful fault
processing. Previously it was in update_mmu_cache() but
that is deadlock prone. At the end of do_sparc64_fault()
we hold no spinlocks that could deadlock the TSB grow
sequence. We also have dropped the address space semaphore.
While we're here, add prefetching to the copy_tsb() routine
and put it in assembler into the tsb.S file. This piece of
code is quite time critical.
There are some small negative side effects to this code which
can be improved upon. In particular we grab the mm->context.lock
even for the tsb insert done by update_mmu_cache() now and that's
a bit excessive. We can get rid of that locking, and the same
lock taking in flush_tsb_user(), by disabling PSTATE_IE around
the whole operation including the capturing of the tsb pointer
and tsb_nentries value. That would work because anyone growing
the TSB won't free up the old TSB until all cpus respond to the
TSB change cross call.
I'm not quite so confident in that optimization to put it in
right now, but eventually we might be able to and the description
is here for reference.
This code seems very solid now. It passes several parallel GCC
bootstrap builds, and our favorite "nut cruncher" stress test which is
a full "make -j8192" build of a "make allmodconfig" kernel. That puts
about 256 processes on each cpu's run queue, makes lots of process cpu
migrations occur, causes lots of page table and TLB flushing activity,
incurs many context version number changes, and it swaps the machine
real far out to disk even though there is 16GB of ram on this test
system. :-)
Signed-off-by: David S. Miller <davem@davemloft.net>
2006-03-16 10:02:32 +00:00
|
|
|
spin_lock_irqsave(&mm->context.lock, flags);
|
|
|
|
|
|
2017-08-11 23:46:50 +00:00
|
|
|
is_huge_tsb = false;
|
2012-10-08 23:34:29 +00:00
|
|
|
#if defined(CONFIG_HUGETLB_PAGE) || defined(CONFIG_TRANSPARENT_HUGEPAGE)
|
2017-08-11 23:46:50 +00:00
|
|
|
if (mm->context.hugetlb_pte_count || mm->context.thp_pte_count) {
|
|
|
|
|
unsigned long hugepage_size = PAGE_SIZE;
|
|
|
|
|
|
|
|
|
|
if (is_vm_hugetlb_page(vma))
|
|
|
|
|
hugepage_size = huge_page_size(hstate_vma(vma));
|
|
|
|
|
|
|
|
|
|
if (hugepage_size >= PUD_SIZE) {
|
|
|
|
|
unsigned long mask = 0x1ffc00000UL;
|
|
|
|
|
|
|
|
|
|
/* Transfer bits [32:22] from address to resolve
|
|
|
|
|
* at 4M granularity.
|
|
|
|
|
*/
|
|
|
|
|
pte_val(pte) &= ~mask;
|
|
|
|
|
pte_val(pte) |= (address & mask);
|
|
|
|
|
} else if (hugepage_size >= PMD_SIZE) {
|
|
|
|
|
/* We are fabricating 8MB pages using 4MB
|
|
|
|
|
* real hw pages.
|
|
|
|
|
*/
|
|
|
|
|
pte_val(pte) |= (address & (1UL << REAL_HPAGE_SHIFT));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (hugepage_size >= PMD_SIZE) {
|
|
|
|
|
__update_mmu_tsb_insert(mm, MM_TSB_HUGE,
|
|
|
|
|
REAL_HPAGE_SHIFT, address, pte_val(pte));
|
|
|
|
|
is_huge_tsb = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
2006-03-22 08:49:59 +00:00
|
|
|
#endif
|
2017-08-11 23:46:50 +00:00
|
|
|
if (!is_huge_tsb)
|
2013-02-19 21:20:08 +00:00
|
|
|
__update_mmu_tsb_insert(mm, MM_TSB_BASE, PAGE_SHIFT,
|
|
|
|
|
address, pte_val(pte));
|
[SPARC64]: Fix and re-enable dynamic TSB sizing.
This is good for up to %50 performance improvement of some test cases.
The problem has been the race conditions, and hopefully I've plugged
them all up here.
1) There was a serious race in switch_mm() wrt. lazy TLB
switching to and from kernel threads.
We could erroneously skip a tsb_context_switch() and thus
use a stale TSB across a TSB grow event.
There is a big comment now in that function describing
exactly how it can happen.
2) All code paths that do something with the TSB need to be
guarded with the mm->context.lock spinlock. This makes
page table flushing paths properly synchronize with both
TSB growing and TLB context changes.
3) TSB growing events are moved to the end of successful fault
processing. Previously it was in update_mmu_cache() but
that is deadlock prone. At the end of do_sparc64_fault()
we hold no spinlocks that could deadlock the TSB grow
sequence. We also have dropped the address space semaphore.
While we're here, add prefetching to the copy_tsb() routine
and put it in assembler into the tsb.S file. This piece of
code is quite time critical.
There are some small negative side effects to this code which
can be improved upon. In particular we grab the mm->context.lock
even for the tsb insert done by update_mmu_cache() now and that's
a bit excessive. We can get rid of that locking, and the same
lock taking in flush_tsb_user(), by disabling PSTATE_IE around
the whole operation including the capturing of the tsb pointer
and tsb_nentries value. That would work because anyone growing
the TSB won't free up the old TSB until all cpus respond to the
TSB change cross call.
I'm not quite so confident in that optimization to put it in
right now, but eventually we might be able to and the description
is here for reference.
This code seems very solid now. It passes several parallel GCC
bootstrap builds, and our favorite "nut cruncher" stress test which is
a full "make -j8192" build of a "make allmodconfig" kernel. That puts
about 256 processes on each cpu's run queue, makes lots of process cpu
migrations occur, causes lots of page table and TLB flushing activity,
incurs many context version number changes, and it swaps the machine
real far out to disk even though there is 16GB of ram on this test
system. :-)
Signed-off-by: David S. Miller <davem@davemloft.net>
2006-03-16 10:02:32 +00:00
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&mm->context.lock, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void flush_dcache_page(struct page *page)
|
|
|
|
|
{
|
2005-04-18 01:03:09 +00:00
|
|
|
struct address_space *mapping;
|
|
|
|
|
int this_cpu;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-02-27 03:44:50 +00:00
|
|
|
if (tlb_type == hypervisor)
|
|
|
|
|
return;
|
|
|
|
|
|
2005-04-18 01:03:09 +00:00
|
|
|
/* Do not bother with the expensive D-cache flush if it
|
|
|
|
|
* is merely the zero page. The 'bigcore' testcase in GDB
|
|
|
|
|
* causes this case to run millions of times.
|
|
|
|
|
*/
|
|
|
|
|
if (page == ZERO_PAGE(0))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
this_cpu = get_cpu();
|
|
|
|
|
|
mm: fix races between swapoff and flush dcache
Thanks to commit 4b3ef9daa4fc ("mm/swap: split swap cache into 64MB
trunks"), after swapoff the address_space associated with the swap
device will be freed. So page_mapping() users which may touch the
address_space need some kind of mechanism to prevent the address_space
from being freed during accessing.
The dcache flushing functions (flush_dcache_page(), etc) in architecture
specific code may access the address_space of swap device for anonymous
pages in swap cache via page_mapping() function. But in some cases
there are no mechanisms to prevent the swap device from being swapoff,
for example,
CPU1 CPU2
__get_user_pages() swapoff()
flush_dcache_page()
mapping = page_mapping()
... exit_swap_address_space()
... kvfree(spaces)
mapping_mapped(mapping)
The address space may be accessed after being freed.
But from cachetlb.txt and Russell King, flush_dcache_page() only care
about file cache pages, for anonymous pages, flush_anon_page() should be
used. The implementation of flush_dcache_page() in all architectures
follows this too. They will check whether page_mapping() is NULL and
whether mapping_mapped() is true to determine whether to flush the
dcache immediately. And they will use interval tree (mapping->i_mmap)
to find all user space mappings. While mapping_mapped() and
mapping->i_mmap isn't used by anonymous pages in swap cache at all.
So, to fix the race between swapoff and flush dcache, __page_mapping()
is add to return the address_space for file cache pages and NULL
otherwise. All page_mapping() invoking in flush dcache functions are
replaced with page_mapping_file().
[akpm@linux-foundation.org: simplify page_mapping_file(), per Mike]
Link: http://lkml.kernel.org/r/20180305083634.15174-1-ying.huang@intel.com
Signed-off-by: "Huang, Ying" <ying.huang@intel.com>
Reviewed-by: Andrew Morton <akpm@linux-foundation.org>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Mel Gorman <mgorman@techsingularity.net>
Cc: Dave Hansen <dave.hansen@intel.com>
Cc: Chen Liqin <liqin.linux@gmail.com>
Cc: Russell King <linux@armlinux.org.uk>
Cc: Yoshinori Sato <ysato@users.sourceforge.jp>
Cc: "James E.J. Bottomley" <jejb@parisc-linux.org>
Cc: Guan Xuetao <gxt@mprc.pku.edu.cn>
Cc: "David S. Miller" <davem@davemloft.net>
Cc: Chris Zankel <chris@zankel.net>
Cc: Vineet Gupta <vgupta@synopsys.com>
Cc: Ley Foon Tan <lftan@altera.com>
Cc: Ralf Baechle <ralf@linux-mips.org>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Mike Rapoport <rppt@linux.vnet.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-05 23:24:39 +00:00
|
|
|
mapping = page_mapping_file(page);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (mapping && !mapping_mapped(mapping)) {
|
2005-04-18 01:03:09 +00:00
|
|
|
int dirty = test_bit(PG_dcache_dirty, &page->flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (dirty) {
|
2005-04-18 01:03:09 +00:00
|
|
|
int dirty_cpu = dcache_dirty_cpu(page);
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (dirty_cpu == this_cpu)
|
|
|
|
|
goto out;
|
|
|
|
|
smp_flush_dcache_page_impl(page, dirty_cpu);
|
|
|
|
|
}
|
|
|
|
|
set_dcache_dirty(page, this_cpu);
|
|
|
|
|
} else {
|
|
|
|
|
/* We could delay the flush for the !page_mapping
|
|
|
|
|
* case too. But that case is for exec env/arg
|
|
|
|
|
* pages and those are %99 certainly going to get
|
|
|
|
|
* faulted into the tlb (and thus flushed) anyways.
|
|
|
|
|
*/
|
|
|
|
|
flush_dcache_page_impl(page);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
put_cpu();
|
|
|
|
|
}
|
2009-01-09 00:58:20 +00:00
|
|
|
EXPORT_SYMBOL(flush_dcache_page);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-09-06 22:19:30 +00:00
|
|
|
void __kprobes flush_icache_range(unsigned long start, unsigned long end)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-02-04 11:10:53 +00:00
|
|
|
/* Cheetah and Hypervisor platform cpus have coherent I-cache. */
|
2005-04-16 22:20:36 +00:00
|
|
|
if (tlb_type == spitfire) {
|
|
|
|
|
unsigned long kaddr;
|
|
|
|
|
|
2007-03-15 22:50:11 +00:00
|
|
|
/* This code only runs on Spitfire cpus so this is
|
|
|
|
|
* why we can assume _PAGE_PADDR_4U.
|
|
|
|
|
*/
|
|
|
|
|
for (kaddr = start; kaddr < end; kaddr += PAGE_SIZE) {
|
|
|
|
|
unsigned long paddr, mask = _PAGE_PADDR_4U;
|
|
|
|
|
|
|
|
|
|
if (kaddr >= PAGE_OFFSET)
|
|
|
|
|
paddr = kaddr & mask;
|
|
|
|
|
else {
|
2020-06-09 04:33:05 +00:00
|
|
|
pte_t *ptep = virt_to_kpte(kaddr);
|
2007-03-15 22:50:11 +00:00
|
|
|
|
|
|
|
|
paddr = pte_val(*ptep) & mask;
|
|
|
|
|
}
|
|
|
|
|
__flush_icache_page(paddr);
|
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
}
|
2009-01-09 00:58:20 +00:00
|
|
|
EXPORT_SYMBOL(flush_icache_range);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
void mmu_info(struct seq_file *m)
|
|
|
|
|
{
|
2012-09-07 02:01:25 +00:00
|
|
|
static const char *pgsz_strings[] = {
|
|
|
|
|
"8K", "64K", "512K", "4MB", "32MB",
|
|
|
|
|
"256MB", "2GB", "16GB",
|
|
|
|
|
};
|
|
|
|
|
int i, printed;
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (tlb_type == cheetah)
|
|
|
|
|
seq_printf(m, "MMU Type\t: Cheetah\n");
|
|
|
|
|
else if (tlb_type == cheetah_plus)
|
|
|
|
|
seq_printf(m, "MMU Type\t: Cheetah+\n");
|
|
|
|
|
else if (tlb_type == spitfire)
|
|
|
|
|
seq_printf(m, "MMU Type\t: Spitfire\n");
|
2006-02-04 11:10:53 +00:00
|
|
|
else if (tlb_type == hypervisor)
|
|
|
|
|
seq_printf(m, "MMU Type\t: Hypervisor (sun4v)\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
else
|
|
|
|
|
seq_printf(m, "MMU Type\t: ???\n");
|
|
|
|
|
|
2012-09-07 02:01:25 +00:00
|
|
|
seq_printf(m, "MMU PGSZs\t: ");
|
|
|
|
|
printed = 0;
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(pgsz_strings); i++) {
|
|
|
|
|
if (cpu_pgsz_mask & (1UL << i)) {
|
|
|
|
|
seq_printf(m, "%s%s",
|
|
|
|
|
printed ? "," : "", pgsz_strings[i]);
|
|
|
|
|
printed++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
seq_putc(m, '\n');
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifdef CONFIG_DEBUG_DCFLUSH
|
|
|
|
|
seq_printf(m, "DCPageFlushes\t: %d\n",
|
|
|
|
|
atomic_read(&dcpage_flushes));
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
seq_printf(m, "DCPageFlushesXC\t: %d\n",
|
|
|
|
|
atomic_read(&dcpage_flushes_xcall));
|
|
|
|
|
#endif /* CONFIG_SMP */
|
|
|
|
|
#endif /* CONFIG_DEBUG_DCFLUSH */
|
|
|
|
|
}
|
|
|
|
|
|
2007-03-15 22:50:11 +00:00
|
|
|
struct linux_prom_translation prom_trans[512] __read_mostly;
|
|
|
|
|
unsigned int prom_trans_ents __read_mostly;
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long kern_locked_tte_data;
|
|
|
|
|
|
2005-10-12 19:22:46 +00:00
|
|
|
/* The obp translations are saved based on 8k pagesize, since obp can
|
|
|
|
|
* use a mixture of pagesizes. Misses to the LOW_OBP_ADDRESS ->
|
2006-02-01 02:29:18 +00:00
|
|
|
* HI_OBP_ADDRESS range are handled in ktlb.S.
|
2005-10-12 19:22:46 +00:00
|
|
|
*/
|
2005-09-22 07:45:41 +00:00
|
|
|
static inline int in_obp_range(unsigned long vaddr)
|
|
|
|
|
{
|
|
|
|
|
return (vaddr >= LOW_OBP_ADDRESS &&
|
|
|
|
|
vaddr < HI_OBP_ADDRESS);
|
|
|
|
|
}
|
|
|
|
|
|
2005-10-12 19:22:46 +00:00
|
|
|
static int cmp_ptrans(const void *a, const void *b)
|
2005-09-22 07:12:35 +00:00
|
|
|
{
|
2005-10-12 19:22:46 +00:00
|
|
|
const struct linux_prom_translation *x = a, *y = b;
|
2005-09-22 07:12:35 +00:00
|
|
|
|
2005-10-12 19:22:46 +00:00
|
|
|
if (x->virt > y->virt)
|
|
|
|
|
return 1;
|
|
|
|
|
if (x->virt < y->virt)
|
|
|
|
|
return -1;
|
|
|
|
|
return 0;
|
2005-09-22 07:12:35 +00:00
|
|
|
}
|
|
|
|
|
|
2005-10-12 19:22:46 +00:00
|
|
|
/* Read OBP translations property into 'prom_trans[]'. */
|
2005-10-05 22:12:00 +00:00
|
|
|
static void __init read_obp_translations(void)
|
2005-09-22 07:12:35 +00:00
|
|
|
{
|
2005-10-12 19:22:46 +00:00
|
|
|
int n, node, ents, first, last, i;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
node = prom_finddevice("/virtual-memory");
|
|
|
|
|
n = prom_getproplen(node, "translations");
|
2005-09-22 07:12:35 +00:00
|
|
|
if (unlikely(n == 0 || n == -1)) {
|
2005-09-22 05:31:13 +00:00
|
|
|
prom_printf("prom_mappings: Couldn't get size.\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
prom_halt();
|
|
|
|
|
}
|
2005-09-22 07:12:35 +00:00
|
|
|
if (unlikely(n > sizeof(prom_trans))) {
|
2012-09-29 03:14:49 +00:00
|
|
|
prom_printf("prom_mappings: Size %d is too big.\n", n);
|
2005-04-16 22:20:36 +00:00
|
|
|
prom_halt();
|
|
|
|
|
}
|
2005-09-22 07:12:35 +00:00
|
|
|
|
2005-09-22 05:31:13 +00:00
|
|
|
if ((n = prom_getproperty(node, "translations",
|
2005-09-22 07:12:35 +00:00
|
|
|
(char *)&prom_trans[0],
|
|
|
|
|
sizeof(prom_trans))) == -1) {
|
2005-09-22 05:31:13 +00:00
|
|
|
prom_printf("prom_mappings: Couldn't get property.\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
prom_halt();
|
|
|
|
|
}
|
2005-10-05 22:12:00 +00:00
|
|
|
|
2005-09-22 05:31:13 +00:00
|
|
|
n = n / sizeof(struct linux_prom_translation);
|
2005-10-05 22:12:00 +00:00
|
|
|
|
2005-10-12 19:22:46 +00:00
|
|
|
ents = n;
|
|
|
|
|
|
|
|
|
|
sort(prom_trans, ents, sizeof(struct linux_prom_translation),
|
|
|
|
|
cmp_ptrans, NULL);
|
|
|
|
|
|
|
|
|
|
/* Now kick out all the non-OBP entries. */
|
|
|
|
|
for (i = 0; i < ents; i++) {
|
|
|
|
|
if (in_obp_range(prom_trans[i].virt))
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
first = i;
|
|
|
|
|
for (; i < ents; i++) {
|
|
|
|
|
if (!in_obp_range(prom_trans[i].virt))
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
last = i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < (last - first); i++) {
|
|
|
|
|
struct linux_prom_translation *src = &prom_trans[i + first];
|
|
|
|
|
struct linux_prom_translation *dest = &prom_trans[i];
|
|
|
|
|
|
|
|
|
|
*dest = *src;
|
|
|
|
|
}
|
|
|
|
|
for (; i < ents; i++) {
|
|
|
|
|
struct linux_prom_translation *dest = &prom_trans[i];
|
|
|
|
|
dest->virt = dest->size = dest->data = 0x0UL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
prom_trans_ents = last - first;
|
|
|
|
|
|
|
|
|
|
if (tlb_type == spitfire) {
|
|
|
|
|
/* Clear diag TTE bits. */
|
|
|
|
|
for (i = 0; i < prom_trans_ents; i++)
|
|
|
|
|
prom_trans[i].data &= ~0x0003fe0000000000UL;
|
|
|
|
|
}
|
2011-09-29 19:18:59 +00:00
|
|
|
|
|
|
|
|
/* Force execute bit on. */
|
|
|
|
|
for (i = 0; i < prom_trans_ents; i++)
|
|
|
|
|
prom_trans[i].data |= (tlb_type == hypervisor ?
|
|
|
|
|
_PAGE_EXEC_4V : _PAGE_EXEC_4U);
|
2005-09-22 07:12:35 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-02-09 10:52:44 +00:00
|
|
|
static void __init hypervisor_tlb_lock(unsigned long vaddr,
|
|
|
|
|
unsigned long pte,
|
|
|
|
|
unsigned long mmu)
|
|
|
|
|
{
|
2007-05-29 09:22:14 +00:00
|
|
|
unsigned long ret = sun4v_mmu_map_perm_addr(vaddr, 0, pte, mmu);
|
|
|
|
|
|
|
|
|
|
if (ret != 0) {
|
2012-09-29 03:14:49 +00:00
|
|
|
prom_printf("hypervisor_tlb_lock[%lx:%x:%lx:%lx]: "
|
2007-05-29 09:22:14 +00:00
|
|
|
"errors with %lx\n", vaddr, 0, pte, mmu, ret);
|
2006-02-17 22:40:30 +00:00
|
|
|
prom_halt();
|
|
|
|
|
}
|
2006-02-09 10:52:44 +00:00
|
|
|
}
|
|
|
|
|
|
2006-02-12 05:57:54 +00:00
|
|
|
static unsigned long kern_large_tte(unsigned long paddr);
|
|
|
|
|
|
2005-09-23 18:59:44 +00:00
|
|
|
static void __init remap_kernel(void)
|
2005-09-22 07:12:35 +00:00
|
|
|
{
|
|
|
|
|
unsigned long phys_page, tte_vaddr, tte_data;
|
2008-03-22 00:01:38 +00:00
|
|
|
int i, tlb_ent = sparc64_highest_locked_tlbent();
|
2005-09-22 07:12:35 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
tte_vaddr = (unsigned long) KERNBASE;
|
2014-05-04 05:52:50 +00:00
|
|
|
phys_page = (prom_boot_mapping_phys_low >> ILOG2_4MB) << ILOG2_4MB;
|
2006-02-12 05:57:54 +00:00
|
|
|
tte_data = kern_large_tte(phys_page);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
kern_locked_tte_data = tte_data;
|
|
|
|
|
|
2006-02-09 10:52:44 +00:00
|
|
|
/* Now lock us into the TLBs via Hypervisor or OBP. */
|
|
|
|
|
if (tlb_type == hypervisor) {
|
2008-03-22 00:01:38 +00:00
|
|
|
for (i = 0; i < num_kernel_image_mappings; i++) {
|
2006-02-09 10:52:44 +00:00
|
|
|
hypervisor_tlb_lock(tte_vaddr, tte_data, HV_MMU_DMMU);
|
|
|
|
|
hypervisor_tlb_lock(tte_vaddr, tte_data, HV_MMU_IMMU);
|
2008-03-22 00:01:38 +00:00
|
|
|
tte_vaddr += 0x400000;
|
|
|
|
|
tte_data += 0x400000;
|
2006-02-09 10:52:44 +00:00
|
|
|
}
|
|
|
|
|
} else {
|
2008-03-22 00:01:38 +00:00
|
|
|
for (i = 0; i < num_kernel_image_mappings; i++) {
|
|
|
|
|
prom_dtlb_load(tlb_ent - i, tte_data, tte_vaddr);
|
|
|
|
|
prom_itlb_load(tlb_ent - i, tte_data, tte_vaddr);
|
|
|
|
|
tte_vaddr += 0x400000;
|
|
|
|
|
tte_data += 0x400000;
|
2006-02-09 10:52:44 +00:00
|
|
|
}
|
2008-03-22 00:01:38 +00:00
|
|
|
sparc64_highest_unlocked_tlb_ent = tlb_ent - i;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2005-10-04 22:23:20 +00:00
|
|
|
if (tlb_type == cheetah_plus) {
|
|
|
|
|
sparc64_kern_pri_context = (CTX_CHEETAH_PLUS_CTX0 |
|
|
|
|
|
CTX_CHEETAH_PLUS_NUC);
|
|
|
|
|
sparc64_kern_pri_nuc_bits = CTX_CHEETAH_PLUS_NUC;
|
|
|
|
|
sparc64_kern_sec_context = CTX_CHEETAH_PLUS_CTX0;
|
|
|
|
|
}
|
2005-09-22 07:12:35 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-09-22 07:12:35 +00:00
|
|
|
|
2005-10-12 19:22:46 +00:00
|
|
|
static void __init inherit_prom_mappings(void)
|
2005-10-05 22:12:00 +00:00
|
|
|
{
|
2005-09-22 07:12:35 +00:00
|
|
|
/* Now fixup OBP's idea about where we really are mapped. */
|
2008-02-18 07:22:50 +00:00
|
|
|
printk("Remapping the kernel... ");
|
2005-09-22 07:12:35 +00:00
|
|
|
remap_kernel();
|
2008-02-18 07:22:50 +00:00
|
|
|
printk("done.\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void prom_world(int enter)
|
|
|
|
|
{
|
|
|
|
|
if (!enter)
|
2012-09-26 05:21:14 +00:00
|
|
|
set_fs(get_fs());
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-02-01 02:33:25 +00:00
|
|
|
__asm__ __volatile__("flushw");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void __flush_dcache_range(unsigned long start, unsigned long end)
|
|
|
|
|
{
|
|
|
|
|
unsigned long va;
|
|
|
|
|
|
|
|
|
|
if (tlb_type == spitfire) {
|
|
|
|
|
int n = 0;
|
|
|
|
|
|
|
|
|
|
for (va = start; va < end; va += 32) {
|
|
|
|
|
spitfire_put_dcache_tag(va & 0x3fe0, 0x0);
|
|
|
|
|
if (++n >= 512)
|
|
|
|
|
break;
|
|
|
|
|
}
|
2006-02-04 11:10:53 +00:00
|
|
|
} else if (tlb_type == cheetah || tlb_type == cheetah_plus) {
|
2005-04-16 22:20:36 +00:00
|
|
|
start = __pa(start);
|
|
|
|
|
end = __pa(end);
|
|
|
|
|
for (va = start; va < end; va += 32)
|
|
|
|
|
__asm__ __volatile__("stxa %%g0, [%0] %1\n\t"
|
|
|
|
|
"membar #Sync"
|
|
|
|
|
: /* no outputs */
|
|
|
|
|
: "r" (va),
|
|
|
|
|
"i" (ASI_DCACHE_INVALIDATE));
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-01-09 00:58:20 +00:00
|
|
|
EXPORT_SYMBOL(__flush_dcache_range);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-03-16 00:51:26 +00:00
|
|
|
/* get_new_mmu_context() uses "cache + 1". */
|
|
|
|
|
DEFINE_SPINLOCK(ctx_alloc_lock);
|
2017-05-31 15:25:22 +00:00
|
|
|
unsigned long tlb_context_cache = CTX_FIRST_VERSION;
|
2007-03-16 00:51:26 +00:00
|
|
|
#define MAX_CTX_NR (1UL << CTX_NR_BITS)
|
|
|
|
|
#define CTX_BMAP_SLOTS BITS_TO_LONGS(MAX_CTX_NR)
|
|
|
|
|
DECLARE_BITMAP(mmu_context_bmap, MAX_CTX_NR);
|
2017-05-31 15:25:23 +00:00
|
|
|
DEFINE_PER_CPU(struct mm_struct *, per_cpu_secondary_mm) = {0};
|
2007-03-16 00:51:26 +00:00
|
|
|
|
sparc64: new context wrap
The current wrap implementation has a race issue: it is called outside of
the ctx_alloc_lock, and also does not wait for all CPUs to complete the
wrap. This means that a thread can get a new context with a new version
and another thread might still be running with the same context. The
problem is especially severe on CPUs with shared TLBs, like sun4v. I used
the following test to very quickly reproduce the problem:
- start over 8K processes (must be more than context IDs)
- write and read values at a memory location in every process.
Very quickly memory corruptions start happening, and what we read back
does not equal what we wrote.
Several approaches were explored before settling on this one:
Approach 1:
Move smp_new_mmu_context_version() inside ctx_alloc_lock, and wait for
every process to complete the wrap. (Note: every CPU must WAIT before
leaving smp_new_mmu_context_version_client() until every one arrives).
This approach ends up with deadlocks, as some threads own locks which other
threads are waiting for, and they never receive softint until these threads
exit smp_new_mmu_context_version_client(). Since we do not allow the exit,
deadlock happens.
Approach 2:
Handle wrap right during mondo interrupt. Use etrap/rtrap to enter into
into C code, and issue new versions to every CPU.
This approach adds some overhead to runtime: in switch_mm() we must add
some checks to make sure that versions have not changed due to wrap while
we were loading the new secondary context. (could be protected by PSTATE_IE
but that degrades performance as on M7 and older CPUs as it takes 50 cycles
for each access). Also, we still need a global per-cpu array of MMs to know
where we need to load new contexts, otherwise we can change context to a
thread that is going way (if we received mondo between switch_mm() and
switch_to() time). Finally, there are some issues with window registers in
rtrap() when context IDs are changed during CPU mondo time.
The approach in this patch is the simplest and has almost no impact on
runtime. We use the array with mm's where last secondary contexts were
loaded onto CPUs and bump their versions to the new generation without
changing context IDs. If a new process comes in to get a context ID, it
will go through get_new_mmu_context() because of version mismatch. But the
running processes do not need to be interrupted. And wrap is quicker as we
do not need to xcall and wait for everyone to receive and complete wrap.
Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-05-31 15:25:24 +00:00
|
|
|
static void mmu_context_wrap(void)
|
|
|
|
|
{
|
|
|
|
|
unsigned long old_ver = tlb_context_cache & CTX_VERSION_MASK;
|
|
|
|
|
unsigned long new_ver, new_ctx, old_ctx;
|
|
|
|
|
struct mm_struct *mm;
|
|
|
|
|
int cpu;
|
|
|
|
|
|
|
|
|
|
bitmap_zero(mmu_context_bmap, 1 << CTX_NR_BITS);
|
|
|
|
|
|
|
|
|
|
/* Reserve kernel context */
|
|
|
|
|
set_bit(0, mmu_context_bmap);
|
|
|
|
|
|
|
|
|
|
new_ver = (tlb_context_cache & CTX_VERSION_MASK) + CTX_FIRST_VERSION;
|
|
|
|
|
if (unlikely(new_ver == 0))
|
|
|
|
|
new_ver = CTX_FIRST_VERSION;
|
|
|
|
|
tlb_context_cache = new_ver;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Make sure that any new mm that are added into per_cpu_secondary_mm,
|
|
|
|
|
* are going to go through get_new_mmu_context() path.
|
|
|
|
|
*/
|
|
|
|
|
mb();
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Updated versions to current on those CPUs that had valid secondary
|
|
|
|
|
* contexts
|
|
|
|
|
*/
|
|
|
|
|
for_each_online_cpu(cpu) {
|
|
|
|
|
/*
|
|
|
|
|
* If a new mm is stored after we took this mm from the array,
|
|
|
|
|
* it will go into get_new_mmu_context() path, because we
|
|
|
|
|
* already bumped the version in tlb_context_cache.
|
|
|
|
|
*/
|
|
|
|
|
mm = per_cpu(per_cpu_secondary_mm, cpu);
|
|
|
|
|
|
|
|
|
|
if (unlikely(!mm || mm == &init_mm))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
old_ctx = mm->context.sparc64_ctx_val;
|
|
|
|
|
if (likely((old_ctx & CTX_VERSION_MASK) == old_ver)) {
|
|
|
|
|
new_ctx = (old_ctx & ~CTX_VERSION_MASK) | new_ver;
|
|
|
|
|
set_bit(new_ctx & CTX_NR_MASK, mmu_context_bmap);
|
|
|
|
|
mm->context.sparc64_ctx_val = new_ctx;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Caller does TLB context flushing on local CPU if necessary.
|
|
|
|
|
* The caller also ensures that CTX_VALID(mm->context) is false.
|
|
|
|
|
*
|
|
|
|
|
* We must be careful about boundary cases so that we never
|
|
|
|
|
* let the user have CTX 0 (nucleus) or we ever use a CTX
|
|
|
|
|
* version of zero (and thus NO_CONTEXT would not be caught
|
|
|
|
|
* by version mis-match tests in mmu_context.h).
|
2006-02-23 22:19:28 +00:00
|
|
|
*
|
|
|
|
|
* Always invoked with interrupts disabled.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
|
void get_new_mmu_context(struct mm_struct *mm)
|
|
|
|
|
{
|
|
|
|
|
unsigned long ctx, new_ctx;
|
|
|
|
|
unsigned long orig_pgsz_bits;
|
|
|
|
|
|
2013-04-08 20:29:46 +00:00
|
|
|
spin_lock(&ctx_alloc_lock);
|
sparc64: new context wrap
The current wrap implementation has a race issue: it is called outside of
the ctx_alloc_lock, and also does not wait for all CPUs to complete the
wrap. This means that a thread can get a new context with a new version
and another thread might still be running with the same context. The
problem is especially severe on CPUs with shared TLBs, like sun4v. I used
the following test to very quickly reproduce the problem:
- start over 8K processes (must be more than context IDs)
- write and read values at a memory location in every process.
Very quickly memory corruptions start happening, and what we read back
does not equal what we wrote.
Several approaches were explored before settling on this one:
Approach 1:
Move smp_new_mmu_context_version() inside ctx_alloc_lock, and wait for
every process to complete the wrap. (Note: every CPU must WAIT before
leaving smp_new_mmu_context_version_client() until every one arrives).
This approach ends up with deadlocks, as some threads own locks which other
threads are waiting for, and they never receive softint until these threads
exit smp_new_mmu_context_version_client(). Since we do not allow the exit,
deadlock happens.
Approach 2:
Handle wrap right during mondo interrupt. Use etrap/rtrap to enter into
into C code, and issue new versions to every CPU.
This approach adds some overhead to runtime: in switch_mm() we must add
some checks to make sure that versions have not changed due to wrap while
we were loading the new secondary context. (could be protected by PSTATE_IE
but that degrades performance as on M7 and older CPUs as it takes 50 cycles
for each access). Also, we still need a global per-cpu array of MMs to know
where we need to load new contexts, otherwise we can change context to a
thread that is going way (if we received mondo between switch_mm() and
switch_to() time). Finally, there are some issues with window registers in
rtrap() when context IDs are changed during CPU mondo time.
The approach in this patch is the simplest and has almost no impact on
runtime. We use the array with mm's where last secondary contexts were
loaded onto CPUs and bump their versions to the new generation without
changing context IDs. If a new process comes in to get a context ID, it
will go through get_new_mmu_context() because of version mismatch. But the
running processes do not need to be interrupted. And wrap is quicker as we
do not need to xcall and wait for everyone to receive and complete wrap.
Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-05-31 15:25:24 +00:00
|
|
|
retry:
|
|
|
|
|
/* wrap might have happened, test again if our context became valid */
|
|
|
|
|
if (unlikely(CTX_VALID(mm->context)))
|
|
|
|
|
goto out;
|
2005-04-16 22:20:36 +00:00
|
|
|
orig_pgsz_bits = (mm->context.sparc64_ctx_val & CTX_PGSZ_MASK);
|
|
|
|
|
ctx = (tlb_context_cache + 1) & CTX_NR_MASK;
|
|
|
|
|
new_ctx = find_next_zero_bit(mmu_context_bmap, 1 << CTX_NR_BITS, ctx);
|
|
|
|
|
if (new_ctx >= (1 << CTX_NR_BITS)) {
|
|
|
|
|
new_ctx = find_next_zero_bit(mmu_context_bmap, ctx, 1);
|
|
|
|
|
if (new_ctx >= ctx) {
|
sparc64: new context wrap
The current wrap implementation has a race issue: it is called outside of
the ctx_alloc_lock, and also does not wait for all CPUs to complete the
wrap. This means that a thread can get a new context with a new version
and another thread might still be running with the same context. The
problem is especially severe on CPUs with shared TLBs, like sun4v. I used
the following test to very quickly reproduce the problem:
- start over 8K processes (must be more than context IDs)
- write and read values at a memory location in every process.
Very quickly memory corruptions start happening, and what we read back
does not equal what we wrote.
Several approaches were explored before settling on this one:
Approach 1:
Move smp_new_mmu_context_version() inside ctx_alloc_lock, and wait for
every process to complete the wrap. (Note: every CPU must WAIT before
leaving smp_new_mmu_context_version_client() until every one arrives).
This approach ends up with deadlocks, as some threads own locks which other
threads are waiting for, and they never receive softint until these threads
exit smp_new_mmu_context_version_client(). Since we do not allow the exit,
deadlock happens.
Approach 2:
Handle wrap right during mondo interrupt. Use etrap/rtrap to enter into
into C code, and issue new versions to every CPU.
This approach adds some overhead to runtime: in switch_mm() we must add
some checks to make sure that versions have not changed due to wrap while
we were loading the new secondary context. (could be protected by PSTATE_IE
but that degrades performance as on M7 and older CPUs as it takes 50 cycles
for each access). Also, we still need a global per-cpu array of MMs to know
where we need to load new contexts, otherwise we can change context to a
thread that is going way (if we received mondo between switch_mm() and
switch_to() time). Finally, there are some issues with window registers in
rtrap() when context IDs are changed during CPU mondo time.
The approach in this patch is the simplest and has almost no impact on
runtime. We use the array with mm's where last secondary contexts were
loaded onto CPUs and bump their versions to the new generation without
changing context IDs. If a new process comes in to get a context ID, it
will go through get_new_mmu_context() because of version mismatch. But the
running processes do not need to be interrupted. And wrap is quicker as we
do not need to xcall and wait for everyone to receive and complete wrap.
Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-05-31 15:25:24 +00:00
|
|
|
mmu_context_wrap();
|
|
|
|
|
goto retry;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
}
|
2017-05-31 15:25:20 +00:00
|
|
|
if (mm->context.sparc64_ctx_val)
|
|
|
|
|
cpumask_clear(mm_cpumask(mm));
|
2005-04-16 22:20:36 +00:00
|
|
|
mmu_context_bmap[new_ctx>>6] |= (1UL << (new_ctx & 63));
|
|
|
|
|
new_ctx |= (tlb_context_cache & CTX_VERSION_MASK);
|
|
|
|
|
tlb_context_cache = new_ctx;
|
|
|
|
|
mm->context.sparc64_ctx_val = new_ctx | orig_pgsz_bits;
|
sparc64: new context wrap
The current wrap implementation has a race issue: it is called outside of
the ctx_alloc_lock, and also does not wait for all CPUs to complete the
wrap. This means that a thread can get a new context with a new version
and another thread might still be running with the same context. The
problem is especially severe on CPUs with shared TLBs, like sun4v. I used
the following test to very quickly reproduce the problem:
- start over 8K processes (must be more than context IDs)
- write and read values at a memory location in every process.
Very quickly memory corruptions start happening, and what we read back
does not equal what we wrote.
Several approaches were explored before settling on this one:
Approach 1:
Move smp_new_mmu_context_version() inside ctx_alloc_lock, and wait for
every process to complete the wrap. (Note: every CPU must WAIT before
leaving smp_new_mmu_context_version_client() until every one arrives).
This approach ends up with deadlocks, as some threads own locks which other
threads are waiting for, and they never receive softint until these threads
exit smp_new_mmu_context_version_client(). Since we do not allow the exit,
deadlock happens.
Approach 2:
Handle wrap right during mondo interrupt. Use etrap/rtrap to enter into
into C code, and issue new versions to every CPU.
This approach adds some overhead to runtime: in switch_mm() we must add
some checks to make sure that versions have not changed due to wrap while
we were loading the new secondary context. (could be protected by PSTATE_IE
but that degrades performance as on M7 and older CPUs as it takes 50 cycles
for each access). Also, we still need a global per-cpu array of MMs to know
where we need to load new contexts, otherwise we can change context to a
thread that is going way (if we received mondo between switch_mm() and
switch_to() time). Finally, there are some issues with window registers in
rtrap() when context IDs are changed during CPU mondo time.
The approach in this patch is the simplest and has almost no impact on
runtime. We use the array with mm's where last secondary contexts were
loaded onto CPUs and bump their versions to the new generation without
changing context IDs. If a new process comes in to get a context ID, it
will go through get_new_mmu_context() because of version mismatch. But the
running processes do not need to be interrupted. And wrap is quicker as we
do not need to xcall and wait for everyone to receive and complete wrap.
Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-05-31 15:25:24 +00:00
|
|
|
out:
|
2013-04-08 20:29:46 +00:00
|
|
|
spin_unlock(&ctx_alloc_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
2008-04-23 12:40:25 +00:00
|
|
|
static int numa_enabled = 1;
|
|
|
|
|
static int numa_debug;
|
|
|
|
|
|
|
|
|
|
static int __init early_numa(char *p)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-04-23 12:40:25 +00:00
|
|
|
if (!p)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
if (strstr(p, "off"))
|
|
|
|
|
numa_enabled = 0;
|
2006-03-08 10:16:07 +00:00
|
|
|
|
2008-04-23 12:40:25 +00:00
|
|
|
if (strstr(p, "debug"))
|
|
|
|
|
numa_debug = 1;
|
2006-03-08 10:16:07 +00:00
|
|
|
|
2008-04-23 12:40:25 +00:00
|
|
|
return 0;
|
2006-03-08 10:16:07 +00:00
|
|
|
}
|
2008-04-23 12:40:25 +00:00
|
|
|
early_param("numa", early_numa);
|
|
|
|
|
|
|
|
|
|
#define numadbg(f, a...) \
|
|
|
|
|
do { if (numa_debug) \
|
|
|
|
|
printk(KERN_INFO f, ## a); \
|
|
|
|
|
} while (0)
|
2006-03-08 10:16:07 +00:00
|
|
|
|
2008-02-14 02:00:03 +00:00
|
|
|
static void __init find_ramdisk(unsigned long phys_base)
|
|
|
|
|
{
|
|
|
|
|
#ifdef CONFIG_BLK_DEV_INITRD
|
|
|
|
|
if (sparc_ramdisk_image || sparc_ramdisk_image64) {
|
|
|
|
|
unsigned long ramdisk_image;
|
|
|
|
|
|
|
|
|
|
/* Older versions of the bootloader only supported a
|
|
|
|
|
* 32-bit physical address for the ramdisk image
|
|
|
|
|
* location, stored at sparc_ramdisk_image. Newer
|
|
|
|
|
* SILO versions set sparc_ramdisk_image to zero and
|
|
|
|
|
* provide a full 64-bit physical address at
|
|
|
|
|
* sparc_ramdisk_image64.
|
|
|
|
|
*/
|
|
|
|
|
ramdisk_image = sparc_ramdisk_image;
|
|
|
|
|
if (!ramdisk_image)
|
|
|
|
|
ramdisk_image = sparc_ramdisk_image64;
|
|
|
|
|
|
|
|
|
|
/* Another bootloader quirk. The bootloader normalizes
|
|
|
|
|
* the physical address to KERNBASE, so we have to
|
|
|
|
|
* factor that back out and add in the lowest valid
|
|
|
|
|
* physical page address to get the true physical address.
|
|
|
|
|
*/
|
|
|
|
|
ramdisk_image -= KERNBASE;
|
|
|
|
|
ramdisk_image += phys_base;
|
|
|
|
|
|
2008-04-23 12:40:25 +00:00
|
|
|
numadbg("Found ramdisk at physical address 0x%lx, size %u\n",
|
|
|
|
|
ramdisk_image, sparc_ramdisk_size);
|
|
|
|
|
|
2008-02-14 02:00:03 +00:00
|
|
|
initrd_start = ramdisk_image;
|
|
|
|
|
initrd_end = ramdisk_image + sparc_ramdisk_size;
|
2008-02-14 02:13:20 +00:00
|
|
|
|
2010-07-12 04:36:09 +00:00
|
|
|
memblock_reserve(initrd_start, sparc_ramdisk_size);
|
2008-05-06 22:19:54 +00:00
|
|
|
|
|
|
|
|
initrd_start += PAGE_OFFSET;
|
|
|
|
|
initrd_end += PAGE_OFFSET;
|
2008-02-14 02:00:03 +00:00
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2008-04-23 12:40:25 +00:00
|
|
|
struct node_mem_mask {
|
|
|
|
|
unsigned long mask;
|
2017-02-16 20:05:58 +00:00
|
|
|
unsigned long match;
|
2008-04-23 12:40:25 +00:00
|
|
|
};
|
|
|
|
|
static struct node_mem_mask node_masks[MAX_NUMNODES];
|
|
|
|
|
static int num_node_masks;
|
|
|
|
|
|
2021-06-29 02:43:01 +00:00
|
|
|
#ifdef CONFIG_NUMA
|
2014-05-16 21:26:12 +00:00
|
|
|
|
2017-02-16 20:05:58 +00:00
|
|
|
struct mdesc_mlgroup {
|
|
|
|
|
u64 node;
|
|
|
|
|
u64 latency;
|
|
|
|
|
u64 match;
|
|
|
|
|
u64 mask;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static struct mdesc_mlgroup *mlgroups;
|
|
|
|
|
static int num_mlgroups;
|
|
|
|
|
|
2008-04-23 12:40:25 +00:00
|
|
|
int numa_cpu_lookup_table[NR_CPUS];
|
|
|
|
|
cpumask_t numa_cpumask_lookup_table[MAX_NUMNODES];
|
|
|
|
|
|
|
|
|
|
struct mdesc_mblock {
|
|
|
|
|
u64 base;
|
|
|
|
|
u64 size;
|
|
|
|
|
u64 offset; /* RA-to-PA */
|
|
|
|
|
};
|
|
|
|
|
static struct mdesc_mblock *mblocks;
|
|
|
|
|
static int num_mblocks;
|
|
|
|
|
|
2017-02-16 20:05:58 +00:00
|
|
|
static struct mdesc_mblock * __init addr_to_mblock(unsigned long addr)
|
2008-04-23 12:40:25 +00:00
|
|
|
{
|
2017-02-16 20:05:58 +00:00
|
|
|
struct mdesc_mblock *m = NULL;
|
2008-04-23 12:40:25 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < num_mblocks; i++) {
|
2017-02-16 20:05:58 +00:00
|
|
|
m = &mblocks[i];
|
2008-04-23 12:40:25 +00:00
|
|
|
|
|
|
|
|
if (addr >= m->base &&
|
|
|
|
|
addr < (m->base + m->size)) {
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2017-02-16 20:05:58 +00:00
|
|
|
|
|
|
|
|
return m;
|
2008-04-23 12:40:25 +00:00
|
|
|
}
|
|
|
|
|
|
2017-02-16 20:05:58 +00:00
|
|
|
static u64 __init memblock_nid_range_sun4u(u64 start, u64 end, int *nid)
|
2008-04-23 12:40:25 +00:00
|
|
|
{
|
2017-02-16 20:05:58 +00:00
|
|
|
int prev_nid, new_nid;
|
2008-04-23 12:40:25 +00:00
|
|
|
|
2019-03-05 23:42:58 +00:00
|
|
|
prev_nid = NUMA_NO_NODE;
|
2017-02-16 20:05:58 +00:00
|
|
|
for ( ; start < end; start += PAGE_SIZE) {
|
|
|
|
|
for (new_nid = 0; new_nid < num_node_masks; new_nid++) {
|
|
|
|
|
struct node_mem_mask *p = &node_masks[new_nid];
|
2008-04-23 12:40:25 +00:00
|
|
|
|
2017-02-16 20:05:58 +00:00
|
|
|
if ((start & p->mask) == p->match) {
|
2019-03-05 23:42:58 +00:00
|
|
|
if (prev_nid == NUMA_NO_NODE)
|
2017-02-16 20:05:58 +00:00
|
|
|
prev_nid = new_nid;
|
|
|
|
|
break;
|
|
|
|
|
}
|
2016-11-03 16:19:01 +00:00
|
|
|
}
|
2017-02-16 20:05:58 +00:00
|
|
|
|
|
|
|
|
if (new_nid == num_node_masks) {
|
|
|
|
|
prev_nid = 0;
|
|
|
|
|
WARN_ONCE(1, "addr[%Lx] doesn't match a NUMA node rule. Some memory will be owned by node 0.",
|
|
|
|
|
start);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (prev_nid != new_nid)
|
|
|
|
|
break;
|
2016-11-03 16:19:01 +00:00
|
|
|
}
|
2017-02-16 20:05:58 +00:00
|
|
|
*nid = prev_nid;
|
2016-11-03 16:19:01 +00:00
|
|
|
|
2017-02-16 20:05:58 +00:00
|
|
|
return start > end ? end : start;
|
2008-04-23 12:40:25 +00:00
|
|
|
}
|
|
|
|
|
|
2016-11-12 00:41:00 +00:00
|
|
|
static u64 __init memblock_nid_range(u64 start, u64 end, int *nid)
|
2008-04-23 12:40:25 +00:00
|
|
|
{
|
2017-02-16 20:05:58 +00:00
|
|
|
u64 ret_end, pa_start, m_mask, m_match, m_end;
|
|
|
|
|
struct mdesc_mblock *mblock;
|
|
|
|
|
int _nid, i;
|
|
|
|
|
|
|
|
|
|
if (tlb_type != hypervisor)
|
|
|
|
|
return memblock_nid_range_sun4u(start, end, nid);
|
|
|
|
|
|
|
|
|
|
mblock = addr_to_mblock(start);
|
|
|
|
|
if (!mblock) {
|
|
|
|
|
WARN_ONCE(1, "memblock_nid_range: Can't find mblock addr[%Lx]",
|
|
|
|
|
start);
|
|
|
|
|
|
|
|
|
|
_nid = 0;
|
|
|
|
|
ret_end = end;
|
|
|
|
|
goto done;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pa_start = start + mblock->offset;
|
|
|
|
|
m_match = 0;
|
|
|
|
|
m_mask = 0;
|
2008-04-23 12:40:25 +00:00
|
|
|
|
2017-02-16 20:05:58 +00:00
|
|
|
for (_nid = 0; _nid < num_node_masks; _nid++) {
|
|
|
|
|
struct node_mem_mask *const m = &node_masks[_nid];
|
|
|
|
|
|
|
|
|
|
if ((pa_start & m->mask) == m->match) {
|
|
|
|
|
m_match = m->match;
|
|
|
|
|
m_mask = m->mask;
|
2008-04-23 12:40:25 +00:00
|
|
|
break;
|
2017-02-16 20:05:58 +00:00
|
|
|
}
|
2008-04-23 12:40:25 +00:00
|
|
|
}
|
|
|
|
|
|
2017-02-16 20:05:58 +00:00
|
|
|
if (num_node_masks == _nid) {
|
|
|
|
|
/* We could not find NUMA group, so default to 0, but lets
|
|
|
|
|
* search for latency group, so we could calculate the correct
|
|
|
|
|
* end address that we return
|
|
|
|
|
*/
|
|
|
|
|
_nid = 0;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < num_mlgroups; i++) {
|
|
|
|
|
struct mdesc_mlgroup *const m = &mlgroups[i];
|
2008-08-14 08:41:39 +00:00
|
|
|
|
2017-02-16 20:05:58 +00:00
|
|
|
if ((pa_start & m->mask) == m->match) {
|
|
|
|
|
m_match = m->match;
|
|
|
|
|
m_mask = m->mask;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (i == num_mlgroups) {
|
|
|
|
|
WARN_ONCE(1, "memblock_nid_range: Can't find latency group addr[%Lx]",
|
|
|
|
|
start);
|
|
|
|
|
|
|
|
|
|
ret_end = end;
|
|
|
|
|
goto done;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Each latency group has match and mask, and each memory block has an
|
|
|
|
|
* offset. An address belongs to a latency group if its address matches
|
|
|
|
|
* the following formula: ((addr + offset) & mask) == match
|
|
|
|
|
* It is, however, slow to check every single page if it matches a
|
|
|
|
|
* particular latency group. As optimization we calculate end value by
|
|
|
|
|
* using bit arithmetics.
|
|
|
|
|
*/
|
|
|
|
|
m_end = m_match + (1ul << __ffs(m_mask)) - mblock->offset;
|
|
|
|
|
m_end += pa_start & ~((1ul << fls64(m_mask)) - 1);
|
|
|
|
|
ret_end = m_end > end ? end : m_end;
|
|
|
|
|
|
|
|
|
|
done:
|
|
|
|
|
*nid = _nid;
|
|
|
|
|
return ret_end;
|
2008-04-23 12:40:25 +00:00
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* This must be invoked after performing all of the necessary
|
2011-12-08 18:22:08 +00:00
|
|
|
* memblock_set_node() calls for 'nid'. We need to be able to get
|
2008-04-23 12:40:25 +00:00
|
|
|
* correct data from get_pfn_range_for_nid().
|
2007-03-16 05:52:18 +00:00
|
|
|
*/
|
2008-04-23 12:40:25 +00:00
|
|
|
static void __init allocate_node_data(int nid)
|
|
|
|
|
{
|
|
|
|
|
struct pglist_data *p;
|
2012-05-10 00:44:29 +00:00
|
|
|
unsigned long start_pfn, end_pfn;
|
2021-06-29 02:43:01 +00:00
|
|
|
#ifdef CONFIG_NUMA
|
2012-05-10 00:44:29 +00:00
|
|
|
|
2019-03-08 00:31:06 +00:00
|
|
|
NODE_DATA(nid) = memblock_alloc_node(sizeof(struct pglist_data),
|
|
|
|
|
SMP_CACHE_BYTES, nid);
|
|
|
|
|
if (!NODE_DATA(nid)) {
|
2008-04-23 12:40:25 +00:00
|
|
|
prom_printf("Cannot allocate pglist_data for nid[%d]\n", nid);
|
|
|
|
|
prom_halt();
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-25 20:13:43 +00:00
|
|
|
NODE_DATA(nid)->node_id = nid;
|
2008-04-23 12:40:25 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
p = NODE_DATA(nid);
|
|
|
|
|
|
|
|
|
|
get_pfn_range_for_nid(nid, &start_pfn, &end_pfn);
|
|
|
|
|
p->node_start_pfn = start_pfn;
|
|
|
|
|
p->node_spanned_pages = end_pfn - start_pfn;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void init_node_masks_nonnuma(void)
|
2006-03-08 10:16:07 +00:00
|
|
|
{
|
2021-06-29 02:43:01 +00:00
|
|
|
#ifdef CONFIG_NUMA
|
2005-04-16 22:20:36 +00:00
|
|
|
int i;
|
2014-05-16 21:26:12 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-23 12:40:25 +00:00
|
|
|
numadbg("Initializing tables for non-numa.\n");
|
2006-12-29 05:00:23 +00:00
|
|
|
|
2017-02-16 20:05:58 +00:00
|
|
|
node_masks[0].mask = 0;
|
|
|
|
|
node_masks[0].match = 0;
|
2008-04-23 12:40:25 +00:00
|
|
|
num_node_masks = 1;
|
2006-03-08 10:16:07 +00:00
|
|
|
|
2021-06-29 02:43:01 +00:00
|
|
|
#ifdef CONFIG_NUMA
|
2008-04-23 12:40:25 +00:00
|
|
|
for (i = 0; i < NR_CPUS; i++)
|
|
|
|
|
numa_cpu_lookup_table[i] = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-05-16 20:38:07 +00:00
|
|
|
cpumask_setall(&numa_cpumask_lookup_table[0]);
|
2014-05-16 21:26:12 +00:00
|
|
|
#endif
|
2008-04-23 12:40:25 +00:00
|
|
|
}
|
|
|
|
|
|
2021-06-29 02:43:01 +00:00
|
|
|
#ifdef CONFIG_NUMA
|
2008-04-23 12:40:25 +00:00
|
|
|
struct pglist_data *node_data[MAX_NUMNODES];
|
|
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(numa_cpu_lookup_table);
|
|
|
|
|
EXPORT_SYMBOL(numa_cpumask_lookup_table);
|
|
|
|
|
EXPORT_SYMBOL(node_data);
|
|
|
|
|
|
|
|
|
|
static int scan_pio_for_cfg_handle(struct mdesc_handle *md, u64 pio,
|
|
|
|
|
u32 cfg_handle)
|
|
|
|
|
{
|
|
|
|
|
u64 arc;
|
|
|
|
|
|
|
|
|
|
mdesc_for_each_arc(arc, md, pio, MDESC_ARC_TYPE_FWD) {
|
|
|
|
|
u64 target = mdesc_arc_target(md, arc);
|
|
|
|
|
const u64 *val;
|
|
|
|
|
|
|
|
|
|
val = mdesc_get_property(md, target,
|
|
|
|
|
"cfg-handle", NULL);
|
|
|
|
|
if (val && *val == cfg_handle)
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int scan_arcs_for_cfg_handle(struct mdesc_handle *md, u64 grp,
|
|
|
|
|
u32 cfg_handle)
|
|
|
|
|
{
|
|
|
|
|
u64 arc, candidate, best_latency = ~(u64)0;
|
|
|
|
|
|
|
|
|
|
candidate = MDESC_NODE_NULL;
|
|
|
|
|
mdesc_for_each_arc(arc, md, grp, MDESC_ARC_TYPE_FWD) {
|
|
|
|
|
u64 target = mdesc_arc_target(md, arc);
|
|
|
|
|
const char *name = mdesc_node_name(md, target);
|
|
|
|
|
const u64 *val;
|
|
|
|
|
|
|
|
|
|
if (strcmp(name, "pio-latency-group"))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
val = mdesc_get_property(md, target, "latency", NULL);
|
|
|
|
|
if (!val)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if (*val < best_latency) {
|
|
|
|
|
candidate = target;
|
|
|
|
|
best_latency = *val;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (candidate == MDESC_NODE_NULL)
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
|
|
return scan_pio_for_cfg_handle(md, candidate, cfg_handle);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int of_node_to_nid(struct device_node *dp)
|
|
|
|
|
{
|
|
|
|
|
const struct linux_prom64_registers *regs;
|
|
|
|
|
struct mdesc_handle *md;
|
|
|
|
|
u32 cfg_handle;
|
|
|
|
|
int count, nid;
|
|
|
|
|
u64 grp;
|
|
|
|
|
|
2008-08-19 03:36:17 +00:00
|
|
|
/* This is the right thing to do on currently supported
|
|
|
|
|
* SUN4U NUMA platforms as well, as the PCI controller does
|
|
|
|
|
* not sit behind any particular memory controller.
|
|
|
|
|
*/
|
2008-04-23 12:40:25 +00:00
|
|
|
if (!mlgroups)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
regs = of_get_property(dp, "reg", NULL);
|
|
|
|
|
if (!regs)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
cfg_handle = (regs->phys_addr >> 32UL) & 0x0fffffff;
|
|
|
|
|
|
|
|
|
|
md = mdesc_grab();
|
|
|
|
|
|
|
|
|
|
count = 0;
|
2019-03-05 23:42:58 +00:00
|
|
|
nid = NUMA_NO_NODE;
|
2008-04-23 12:40:25 +00:00
|
|
|
mdesc_for_each_node_by_name(md, grp, "group") {
|
|
|
|
|
if (!scan_arcs_for_cfg_handle(md, grp, cfg_handle)) {
|
|
|
|
|
nid = count;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
count++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mdesc_release(md);
|
|
|
|
|
|
|
|
|
|
return nid;
|
|
|
|
|
}
|
|
|
|
|
|
2009-04-07 08:05:22 +00:00
|
|
|
static void __init add_node_ranges(void)
|
2008-04-23 12:40:25 +00:00
|
|
|
{
|
2020-10-13 23:58:08 +00:00
|
|
|
phys_addr_t start, end;
|
2017-02-16 20:13:54 +00:00
|
|
|
unsigned long prev_max;
|
2020-10-13 23:58:08 +00:00
|
|
|
u64 i;
|
2017-02-16 20:13:54 +00:00
|
|
|
|
|
|
|
|
memblock_resized:
|
|
|
|
|
prev_max = memblock.memory.max;
|
2008-04-23 12:40:25 +00:00
|
|
|
|
2020-10-13 23:58:08 +00:00
|
|
|
for_each_mem_range(i, &start, &end) {
|
2008-04-23 12:40:25 +00:00
|
|
|
while (start < end) {
|
|
|
|
|
unsigned long this_end;
|
|
|
|
|
int nid;
|
|
|
|
|
|
2010-07-06 22:38:58 +00:00
|
|
|
this_end = memblock_nid_range(start, end, &nid);
|
2008-04-23 12:40:25 +00:00
|
|
|
|
2011-12-08 18:22:08 +00:00
|
|
|
numadbg("Setting memblock NUMA node nid[%d] "
|
2020-10-13 23:58:08 +00:00
|
|
|
"start[%llx] end[%lx]\n",
|
2008-04-23 12:40:25 +00:00
|
|
|
nid, start, this_end);
|
|
|
|
|
|
2014-01-21 23:49:26 +00:00
|
|
|
memblock_set_node(start, this_end - start,
|
|
|
|
|
&memblock.memory, nid);
|
2017-02-16 20:13:54 +00:00
|
|
|
if (memblock.memory.max != prev_max)
|
|
|
|
|
goto memblock_resized;
|
2008-04-23 12:40:25 +00:00
|
|
|
start = this_end;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int __init grab_mlgroups(struct mdesc_handle *md)
|
|
|
|
|
{
|
|
|
|
|
unsigned long paddr;
|
|
|
|
|
int count = 0;
|
|
|
|
|
u64 node;
|
|
|
|
|
|
|
|
|
|
mdesc_for_each_node_by_name(md, node, "memory-latency-group")
|
|
|
|
|
count++;
|
|
|
|
|
if (!count)
|
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
memblock: rename memblock_alloc{_nid,_try_nid} to memblock_phys_alloc*
Make it explicit that the caller gets a physical address rather than a
virtual one.
This will also allow using meblock_alloc prefix for memblock allocations
returning virtual address, which is done in the following patches.
The conversion is done using the following semantic patch:
@@
expression e1, e2, e3;
@@
(
- memblock_alloc(e1, e2)
+ memblock_phys_alloc(e1, e2)
|
- memblock_alloc_nid(e1, e2, e3)
+ memblock_phys_alloc_nid(e1, e2, e3)
|
- memblock_alloc_try_nid(e1, e2, e3)
+ memblock_phys_alloc_try_nid(e1, e2, e3)
)
Link: http://lkml.kernel.org/r/1536927045-23536-7-git-send-email-rppt@linux.vnet.ibm.com
Signed-off-by: Mike Rapoport <rppt@linux.vnet.ibm.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Cc: Catalin Marinas <catalin.marinas@arm.com>
Cc: Chris Zankel <chris@zankel.net>
Cc: "David S. Miller" <davem@davemloft.net>
Cc: Geert Uytterhoeven <geert@linux-m68k.org>
Cc: Greentime Hu <green.hu@gmail.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Guan Xuetao <gxt@pku.edu.cn>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: "James E.J. Bottomley" <jejb@parisc-linux.org>
Cc: Jonas Bonn <jonas@southpole.se>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: Ley Foon Tan <lftan@altera.com>
Cc: Mark Salter <msalter@redhat.com>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: Matt Turner <mattst88@gmail.com>
Cc: Michael Ellerman <mpe@ellerman.id.au>
Cc: Michal Simek <monstr@monstr.eu>
Cc: Palmer Dabbelt <palmer@sifive.com>
Cc: Paul Burton <paul.burton@mips.com>
Cc: Richard Kuo <rkuo@codeaurora.org>
Cc: Richard Weinberger <richard@nod.at>
Cc: Rich Felker <dalias@libc.org>
Cc: Russell King <linux@armlinux.org.uk>
Cc: Serge Semin <fancer.lancer@gmail.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Tony Luck <tony.luck@intel.com>
Cc: Vineet Gupta <vgupta@synopsys.com>
Cc: Yoshinori Sato <ysato@users.sourceforge.jp>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-10-30 22:07:59 +00:00
|
|
|
paddr = memblock_phys_alloc(count * sizeof(struct mdesc_mlgroup),
|
|
|
|
|
SMP_CACHE_BYTES);
|
2008-04-23 12:40:25 +00:00
|
|
|
if (!paddr)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
mlgroups = __va(paddr);
|
|
|
|
|
num_mlgroups = count;
|
|
|
|
|
|
|
|
|
|
count = 0;
|
|
|
|
|
mdesc_for_each_node_by_name(md, node, "memory-latency-group") {
|
|
|
|
|
struct mdesc_mlgroup *m = &mlgroups[count++];
|
|
|
|
|
const u64 *val;
|
|
|
|
|
|
|
|
|
|
m->node = node;
|
|
|
|
|
|
|
|
|
|
val = mdesc_get_property(md, node, "latency", NULL);
|
|
|
|
|
m->latency = *val;
|
|
|
|
|
val = mdesc_get_property(md, node, "address-match", NULL);
|
|
|
|
|
m->match = *val;
|
|
|
|
|
val = mdesc_get_property(md, node, "address-mask", NULL);
|
|
|
|
|
m->mask = *val;
|
|
|
|
|
|
2009-01-06 21:19:28 +00:00
|
|
|
numadbg("MLGROUP[%d]: node[%llx] latency[%llx] "
|
|
|
|
|
"match[%llx] mask[%llx]\n",
|
2008-04-23 12:40:25 +00:00
|
|
|
count - 1, m->node, m->latency, m->match, m->mask);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int __init grab_mblocks(struct mdesc_handle *md)
|
|
|
|
|
{
|
|
|
|
|
unsigned long paddr;
|
|
|
|
|
int count = 0;
|
|
|
|
|
u64 node;
|
|
|
|
|
|
|
|
|
|
mdesc_for_each_node_by_name(md, node, "mblock")
|
|
|
|
|
count++;
|
|
|
|
|
if (!count)
|
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
memblock: rename memblock_alloc{_nid,_try_nid} to memblock_phys_alloc*
Make it explicit that the caller gets a physical address rather than a
virtual one.
This will also allow using meblock_alloc prefix for memblock allocations
returning virtual address, which is done in the following patches.
The conversion is done using the following semantic patch:
@@
expression e1, e2, e3;
@@
(
- memblock_alloc(e1, e2)
+ memblock_phys_alloc(e1, e2)
|
- memblock_alloc_nid(e1, e2, e3)
+ memblock_phys_alloc_nid(e1, e2, e3)
|
- memblock_alloc_try_nid(e1, e2, e3)
+ memblock_phys_alloc_try_nid(e1, e2, e3)
)
Link: http://lkml.kernel.org/r/1536927045-23536-7-git-send-email-rppt@linux.vnet.ibm.com
Signed-off-by: Mike Rapoport <rppt@linux.vnet.ibm.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Cc: Catalin Marinas <catalin.marinas@arm.com>
Cc: Chris Zankel <chris@zankel.net>
Cc: "David S. Miller" <davem@davemloft.net>
Cc: Geert Uytterhoeven <geert@linux-m68k.org>
Cc: Greentime Hu <green.hu@gmail.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Guan Xuetao <gxt@pku.edu.cn>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: "James E.J. Bottomley" <jejb@parisc-linux.org>
Cc: Jonas Bonn <jonas@southpole.se>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: Ley Foon Tan <lftan@altera.com>
Cc: Mark Salter <msalter@redhat.com>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: Matt Turner <mattst88@gmail.com>
Cc: Michael Ellerman <mpe@ellerman.id.au>
Cc: Michal Simek <monstr@monstr.eu>
Cc: Palmer Dabbelt <palmer@sifive.com>
Cc: Paul Burton <paul.burton@mips.com>
Cc: Richard Kuo <rkuo@codeaurora.org>
Cc: Richard Weinberger <richard@nod.at>
Cc: Rich Felker <dalias@libc.org>
Cc: Russell King <linux@armlinux.org.uk>
Cc: Serge Semin <fancer.lancer@gmail.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Tony Luck <tony.luck@intel.com>
Cc: Vineet Gupta <vgupta@synopsys.com>
Cc: Yoshinori Sato <ysato@users.sourceforge.jp>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-10-30 22:07:59 +00:00
|
|
|
paddr = memblock_phys_alloc(count * sizeof(struct mdesc_mblock),
|
|
|
|
|
SMP_CACHE_BYTES);
|
2008-04-23 12:40:25 +00:00
|
|
|
if (!paddr)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
mblocks = __va(paddr);
|
|
|
|
|
num_mblocks = count;
|
|
|
|
|
|
|
|
|
|
count = 0;
|
|
|
|
|
mdesc_for_each_node_by_name(md, node, "mblock") {
|
|
|
|
|
struct mdesc_mblock *m = &mblocks[count++];
|
|
|
|
|
const u64 *val;
|
|
|
|
|
|
|
|
|
|
val = mdesc_get_property(md, node, "base", NULL);
|
|
|
|
|
m->base = *val;
|
|
|
|
|
val = mdesc_get_property(md, node, "size", NULL);
|
|
|
|
|
m->size = *val;
|
|
|
|
|
val = mdesc_get_property(md, node,
|
|
|
|
|
"address-congruence-offset", NULL);
|
2013-06-11 18:54:51 +00:00
|
|
|
|
|
|
|
|
/* The address-congruence-offset property is optional.
|
|
|
|
|
* Explicity zero it be identifty this.
|
|
|
|
|
*/
|
|
|
|
|
if (val)
|
|
|
|
|
m->offset = *val;
|
|
|
|
|
else
|
|
|
|
|
m->offset = 0UL;
|
2008-04-23 12:40:25 +00:00
|
|
|
|
2009-01-06 21:19:28 +00:00
|
|
|
numadbg("MBLOCK[%d]: base[%llx] size[%llx] offset[%llx]\n",
|
2008-04-23 12:40:25 +00:00
|
|
|
count - 1, m->base, m->size, m->offset);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void __init numa_parse_mdesc_group_cpus(struct mdesc_handle *md,
|
|
|
|
|
u64 grp, cpumask_t *mask)
|
|
|
|
|
{
|
|
|
|
|
u64 arc;
|
|
|
|
|
|
2011-05-16 20:38:07 +00:00
|
|
|
cpumask_clear(mask);
|
2008-04-23 12:40:25 +00:00
|
|
|
|
|
|
|
|
mdesc_for_each_arc(arc, md, grp, MDESC_ARC_TYPE_BACK) {
|
|
|
|
|
u64 target = mdesc_arc_target(md, arc);
|
|
|
|
|
const char *name = mdesc_node_name(md, target);
|
|
|
|
|
const u64 *id;
|
|
|
|
|
|
|
|
|
|
if (strcmp(name, "cpu"))
|
|
|
|
|
continue;
|
|
|
|
|
id = mdesc_get_property(md, target, "id", NULL);
|
2009-03-16 04:10:23 +00:00
|
|
|
if (*id < nr_cpu_ids)
|
2011-05-16 20:38:07 +00:00
|
|
|
cpumask_set_cpu(*id, mask);
|
2008-04-23 12:40:25 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct mdesc_mlgroup * __init find_mlgroup(u64 node)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < num_mlgroups; i++) {
|
|
|
|
|
struct mdesc_mlgroup *m = &mlgroups[i];
|
|
|
|
|
if (m->node == node)
|
|
|
|
|
return m;
|
|
|
|
|
}
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2015-11-02 21:30:24 +00:00
|
|
|
int __node_distance(int from, int to)
|
|
|
|
|
{
|
|
|
|
|
if ((from >= MAX_NUMNODES) || (to >= MAX_NUMNODES)) {
|
|
|
|
|
pr_warn("Returning default NUMA distance value for %d->%d\n",
|
|
|
|
|
from, to);
|
|
|
|
|
return (from == to) ? LOCAL_DISTANCE : REMOTE_DISTANCE;
|
|
|
|
|
}
|
|
|
|
|
return numa_latency[from][to];
|
|
|
|
|
}
|
2018-10-26 22:11:56 +00:00
|
|
|
EXPORT_SYMBOL(__node_distance);
|
2015-11-02 21:30:24 +00:00
|
|
|
|
2016-08-06 04:31:48 +00:00
|
|
|
static int __init find_best_numa_node_for_mlgroup(struct mdesc_mlgroup *grp)
|
2015-11-02 21:30:24 +00:00
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < MAX_NUMNODES; i++) {
|
|
|
|
|
struct node_mem_mask *n = &node_masks[i];
|
|
|
|
|
|
2017-02-16 20:05:58 +00:00
|
|
|
if ((grp->mask == n->mask) && (grp->match == n->match))
|
2015-11-02 21:30:24 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
|
2016-08-06 04:31:48 +00:00
|
|
|
static void __init find_numa_latencies_for_group(struct mdesc_handle *md,
|
|
|
|
|
u64 grp, int index)
|
2015-11-02 21:30:24 +00:00
|
|
|
{
|
|
|
|
|
u64 arc;
|
|
|
|
|
|
|
|
|
|
mdesc_for_each_arc(arc, md, grp, MDESC_ARC_TYPE_FWD) {
|
|
|
|
|
int tnode;
|
|
|
|
|
u64 target = mdesc_arc_target(md, arc);
|
|
|
|
|
struct mdesc_mlgroup *m = find_mlgroup(target);
|
|
|
|
|
|
|
|
|
|
if (!m)
|
|
|
|
|
continue;
|
|
|
|
|
tnode = find_best_numa_node_for_mlgroup(m);
|
|
|
|
|
if (tnode == MAX_NUMNODES)
|
|
|
|
|
continue;
|
|
|
|
|
numa_latency[index][tnode] = m->latency;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-04-23 12:40:25 +00:00
|
|
|
static int __init numa_attach_mlgroup(struct mdesc_handle *md, u64 grp,
|
|
|
|
|
int index)
|
|
|
|
|
{
|
|
|
|
|
struct mdesc_mlgroup *candidate = NULL;
|
|
|
|
|
u64 arc, best_latency = ~(u64)0;
|
|
|
|
|
struct node_mem_mask *n;
|
|
|
|
|
|
|
|
|
|
mdesc_for_each_arc(arc, md, grp, MDESC_ARC_TYPE_FWD) {
|
|
|
|
|
u64 target = mdesc_arc_target(md, arc);
|
|
|
|
|
struct mdesc_mlgroup *m = find_mlgroup(target);
|
|
|
|
|
if (!m)
|
|
|
|
|
continue;
|
|
|
|
|
if (m->latency < best_latency) {
|
|
|
|
|
candidate = m;
|
|
|
|
|
best_latency = m->latency;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (!candidate)
|
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
|
|
if (num_node_masks != index) {
|
|
|
|
|
printk(KERN_ERR "Inconsistent NUMA state, "
|
|
|
|
|
"index[%d] != num_node_masks[%d]\n",
|
|
|
|
|
index, num_node_masks);
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
n = &node_masks[num_node_masks++];
|
|
|
|
|
|
|
|
|
|
n->mask = candidate->mask;
|
2017-02-16 20:05:58 +00:00
|
|
|
n->match = candidate->match;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-02-16 20:05:58 +00:00
|
|
|
numadbg("NUMA NODE[%d]: mask[%lx] match[%lx] (latency[%llx])\n",
|
|
|
|
|
index, n->mask, n->match, candidate->latency);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-23 12:40:25 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int __init numa_parse_mdesc_group(struct mdesc_handle *md, u64 grp,
|
|
|
|
|
int index)
|
|
|
|
|
{
|
|
|
|
|
cpumask_t mask;
|
|
|
|
|
int cpu;
|
|
|
|
|
|
|
|
|
|
numa_parse_mdesc_group_cpus(md, grp, &mask);
|
|
|
|
|
|
2011-05-16 20:38:07 +00:00
|
|
|
for_each_cpu(cpu, &mask)
|
2008-04-23 12:40:25 +00:00
|
|
|
numa_cpu_lookup_table[cpu] = index;
|
2011-05-16 20:38:07 +00:00
|
|
|
cpumask_copy(&numa_cpumask_lookup_table[index], &mask);
|
2008-04-23 12:40:25 +00:00
|
|
|
|
|
|
|
|
if (numa_debug) {
|
|
|
|
|
printk(KERN_INFO "NUMA GROUP[%d]: cpus [ ", index);
|
2011-05-16 20:38:07 +00:00
|
|
|
for_each_cpu(cpu, &mask)
|
2008-04-23 12:40:25 +00:00
|
|
|
printk("%d ", cpu);
|
|
|
|
|
printk("]\n");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return numa_attach_mlgroup(md, grp, index);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int __init numa_parse_mdesc(void)
|
|
|
|
|
{
|
|
|
|
|
struct mdesc_handle *md = mdesc_grab();
|
2015-11-02 21:30:24 +00:00
|
|
|
int i, j, err, count;
|
2008-04-23 12:40:25 +00:00
|
|
|
u64 node;
|
|
|
|
|
|
|
|
|
|
node = mdesc_node_by_name(md, MDESC_NODE_NULL, "latency-groups");
|
|
|
|
|
if (node == MDESC_NODE_NULL) {
|
|
|
|
|
mdesc_release(md);
|
|
|
|
|
return -ENOENT;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
err = grab_mblocks(md);
|
|
|
|
|
if (err < 0)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
err = grab_mlgroups(md);
|
|
|
|
|
if (err < 0)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
count = 0;
|
|
|
|
|
mdesc_for_each_node_by_name(md, node, "group") {
|
|
|
|
|
err = numa_parse_mdesc_group(md, node, count);
|
|
|
|
|
if (err < 0)
|
|
|
|
|
break;
|
|
|
|
|
count++;
|
|
|
|
|
}
|
|
|
|
|
|
2015-11-02 21:30:24 +00:00
|
|
|
count = 0;
|
|
|
|
|
mdesc_for_each_node_by_name(md, node, "group") {
|
|
|
|
|
find_numa_latencies_for_group(md, node, count);
|
|
|
|
|
count++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Normalize numa latency matrix according to ACPI SLIT spec. */
|
|
|
|
|
for (i = 0; i < MAX_NUMNODES; i++) {
|
|
|
|
|
u64 self_latency = numa_latency[i][i];
|
|
|
|
|
|
|
|
|
|
for (j = 0; j < MAX_NUMNODES; j++) {
|
|
|
|
|
numa_latency[i][j] =
|
|
|
|
|
(numa_latency[i][j] * LOCAL_DISTANCE) /
|
|
|
|
|
self_latency;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-04-23 12:40:25 +00:00
|
|
|
add_node_ranges();
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < num_node_masks; i++) {
|
|
|
|
|
allocate_node_data(i);
|
|
|
|
|
node_set_online(i);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
err = 0;
|
|
|
|
|
out:
|
|
|
|
|
mdesc_release(md);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-19 03:36:17 +00:00
|
|
|
static int __init numa_parse_jbus(void)
|
|
|
|
|
{
|
|
|
|
|
unsigned long cpu, index;
|
|
|
|
|
|
|
|
|
|
/* NUMA node id is encoded in bits 36 and higher, and there is
|
|
|
|
|
* a 1-to-1 mapping from CPU ID to NUMA node ID.
|
|
|
|
|
*/
|
|
|
|
|
index = 0;
|
|
|
|
|
for_each_present_cpu(cpu) {
|
|
|
|
|
numa_cpu_lookup_table[cpu] = index;
|
2011-05-16 20:38:07 +00:00
|
|
|
cpumask_copy(&numa_cpumask_lookup_table[index], cpumask_of(cpu));
|
2008-08-19 03:36:17 +00:00
|
|
|
node_masks[index].mask = ~((1UL << 36UL) - 1UL);
|
2017-02-16 20:05:58 +00:00
|
|
|
node_masks[index].match = cpu << 36UL;
|
2008-08-19 03:36:17 +00:00
|
|
|
|
|
|
|
|
index++;
|
|
|
|
|
}
|
|
|
|
|
num_node_masks = index;
|
|
|
|
|
|
|
|
|
|
add_node_ranges();
|
|
|
|
|
|
|
|
|
|
for (index = 0; index < num_node_masks; index++) {
|
|
|
|
|
allocate_node_data(index);
|
|
|
|
|
node_set_online(index);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-04-23 12:40:25 +00:00
|
|
|
static int __init numa_parse_sun4u(void)
|
|
|
|
|
{
|
2008-08-19 03:36:17 +00:00
|
|
|
if (tlb_type == cheetah || tlb_type == cheetah_plus) {
|
|
|
|
|
unsigned long ver;
|
|
|
|
|
|
|
|
|
|
__asm__ ("rdpr %%ver, %0" : "=r" (ver));
|
|
|
|
|
if ((ver >> 32UL) == __JALAPENO_ID ||
|
|
|
|
|
(ver >> 32UL) == __SERRANO_ID)
|
|
|
|
|
return numa_parse_jbus();
|
|
|
|
|
}
|
2008-04-23 12:40:25 +00:00
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int __init bootmem_init_numa(void)
|
|
|
|
|
{
|
2016-01-06 06:35:35 +00:00
|
|
|
int i, j;
|
2008-04-23 12:40:25 +00:00
|
|
|
int err = -1;
|
|
|
|
|
|
|
|
|
|
numadbg("bootmem_init_numa()\n");
|
|
|
|
|
|
2016-01-06 06:35:35 +00:00
|
|
|
/* Some sane defaults for numa latency values */
|
|
|
|
|
for (i = 0; i < MAX_NUMNODES; i++) {
|
|
|
|
|
for (j = 0; j < MAX_NUMNODES; j++)
|
|
|
|
|
numa_latency[i][j] = (i == j) ?
|
|
|
|
|
LOCAL_DISTANCE : REMOTE_DISTANCE;
|
|
|
|
|
}
|
|
|
|
|
|
2008-04-23 12:40:25 +00:00
|
|
|
if (numa_enabled) {
|
|
|
|
|
if (tlb_type == hypervisor)
|
|
|
|
|
err = numa_parse_mdesc();
|
|
|
|
|
else
|
|
|
|
|
err = numa_parse_sun4u();
|
|
|
|
|
}
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#else
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-23 12:40:25 +00:00
|
|
|
static int bootmem_init_numa(void)
|
|
|
|
|
{
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
static void __init bootmem_init_nonnuma(void)
|
|
|
|
|
{
|
2010-07-12 04:36:09 +00:00
|
|
|
unsigned long top_of_ram = memblock_end_of_DRAM();
|
|
|
|
|
unsigned long total_ram = memblock_phys_mem_size();
|
2008-04-23 12:40:25 +00:00
|
|
|
|
|
|
|
|
numadbg("bootmem_init_nonnuma()\n");
|
|
|
|
|
|
|
|
|
|
printk(KERN_INFO "Top of RAM: 0x%lx, Total RAM: 0x%lx\n",
|
|
|
|
|
top_of_ram, total_ram);
|
|
|
|
|
printk(KERN_INFO "Memory hole size: %ldMB\n",
|
|
|
|
|
(top_of_ram - total_ram) >> 20);
|
|
|
|
|
|
|
|
|
|
init_node_masks_nonnuma();
|
2018-06-14 22:28:02 +00:00
|
|
|
memblock_set_node(0, PHYS_ADDR_MAX, &memblock.memory, 0);
|
2008-04-23 12:40:25 +00:00
|
|
|
allocate_node_data(0);
|
|
|
|
|
node_set_online(0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static unsigned long __init bootmem_init(unsigned long phys_base)
|
|
|
|
|
{
|
|
|
|
|
unsigned long end_pfn;
|
|
|
|
|
|
2010-07-12 04:36:09 +00:00
|
|
|
end_pfn = memblock_end_of_DRAM() >> PAGE_SHIFT;
|
2008-04-23 12:40:25 +00:00
|
|
|
max_pfn = max_low_pfn = end_pfn;
|
|
|
|
|
min_low_pfn = (phys_base >> PAGE_SHIFT);
|
|
|
|
|
|
|
|
|
|
if (bootmem_init_numa() < 0)
|
|
|
|
|
bootmem_init_nonnuma();
|
|
|
|
|
|
2012-04-25 20:13:43 +00:00
|
|
|
/* Dump memblock with node info. */
|
|
|
|
|
memblock_dump_all();
|
2008-04-23 12:40:25 +00:00
|
|
|
|
2012-04-25 20:13:43 +00:00
|
|
|
/* XXX cpu notifier XXX */
|
2006-03-08 10:16:07 +00:00
|
|
|
|
|
|
|
|
sparse_init();
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return end_pfn;
|
|
|
|
|
}
|
|
|
|
|
|
2006-02-22 04:51:13 +00:00
|
|
|
static struct linux_prom64_registers pall[MAX_BANKS] __initdata;
|
|
|
|
|
static int pall_ents __initdata;
|
|
|
|
|
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
static unsigned long max_phys_bits = 40;
|
|
|
|
|
|
|
|
|
|
bool kern_addr_valid(unsigned long addr)
|
|
|
|
|
{
|
|
|
|
|
pgd_t *pgd;
|
2019-11-24 08:57:20 +00:00
|
|
|
p4d_t *p4d;
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
pud_t *pud;
|
|
|
|
|
pmd_t *pmd;
|
|
|
|
|
pte_t *pte;
|
|
|
|
|
|
2014-09-27 18:05:21 +00:00
|
|
|
if ((long)addr < 0L) {
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
unsigned long pa = __pa(addr);
|
|
|
|
|
|
2017-03-10 19:31:19 +00:00
|
|
|
if ((pa >> max_phys_bits) != 0UL)
|
2014-09-27 18:05:21 +00:00
|
|
|
return false;
|
|
|
|
|
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
return pfn_valid(pa >> PAGE_SHIFT);
|
|
|
|
|
}
|
|
|
|
|
|
2014-09-27 18:05:21 +00:00
|
|
|
if (addr >= (unsigned long) KERNBASE &&
|
|
|
|
|
addr < (unsigned long)&_end)
|
|
|
|
|
return true;
|
|
|
|
|
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
pgd = pgd_offset_k(addr);
|
|
|
|
|
if (pgd_none(*pgd))
|
2020-05-06 06:16:59 +00:00
|
|
|
return false;
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
|
2019-11-24 08:57:20 +00:00
|
|
|
p4d = p4d_offset(pgd, addr);
|
|
|
|
|
if (p4d_none(*p4d))
|
2020-05-06 06:16:59 +00:00
|
|
|
return false;
|
2019-11-24 08:57:20 +00:00
|
|
|
|
|
|
|
|
pud = pud_offset(p4d, addr);
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
if (pud_none(*pud))
|
2020-05-06 06:16:59 +00:00
|
|
|
return false;
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
|
|
|
|
|
if (pud_large(*pud))
|
|
|
|
|
return pfn_valid(pud_pfn(*pud));
|
|
|
|
|
|
|
|
|
|
pmd = pmd_offset(pud, addr);
|
|
|
|
|
if (pmd_none(*pmd))
|
2020-05-06 06:16:59 +00:00
|
|
|
return false;
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
|
|
|
|
|
if (pmd_large(*pmd))
|
|
|
|
|
return pfn_valid(pmd_pfn(*pmd));
|
|
|
|
|
|
|
|
|
|
pte = pte_offset_kernel(pmd, addr);
|
|
|
|
|
if (pte_none(*pte))
|
2020-05-06 06:16:59 +00:00
|
|
|
return false;
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
|
|
|
|
|
return pfn_valid(pte_pfn(*pte));
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(kern_addr_valid);
|
|
|
|
|
|
|
|
|
|
static unsigned long __ref kernel_map_hugepud(unsigned long vstart,
|
|
|
|
|
unsigned long vend,
|
|
|
|
|
pud_t *pud)
|
|
|
|
|
{
|
|
|
|
|
const unsigned long mask16gb = (1UL << 34) - 1UL;
|
|
|
|
|
u64 pte_val = vstart;
|
|
|
|
|
|
|
|
|
|
/* Each PUD is 8GB */
|
|
|
|
|
if ((vstart & mask16gb) ||
|
|
|
|
|
(vend - vstart <= mask16gb)) {
|
|
|
|
|
pte_val ^= kern_linear_pte_xor[2];
|
|
|
|
|
pud_val(*pud) = pte_val | _PAGE_PUD_HUGE;
|
|
|
|
|
|
|
|
|
|
return vstart + PUD_SIZE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pte_val ^= kern_linear_pte_xor[3];
|
|
|
|
|
pte_val |= _PAGE_PUD_HUGE;
|
|
|
|
|
|
|
|
|
|
vend = vstart + mask16gb + 1UL;
|
|
|
|
|
while (vstart < vend) {
|
|
|
|
|
pud_val(*pud) = pte_val;
|
|
|
|
|
|
|
|
|
|
pte_val += PUD_SIZE;
|
|
|
|
|
vstart += PUD_SIZE;
|
|
|
|
|
pud++;
|
|
|
|
|
}
|
|
|
|
|
return vstart;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static bool kernel_can_map_hugepud(unsigned long vstart, unsigned long vend,
|
|
|
|
|
bool guard)
|
|
|
|
|
{
|
|
|
|
|
if (guard && !(vstart & ~PUD_MASK) && (vend - vstart) >= PUD_SIZE)
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static unsigned long __ref kernel_map_hugepmd(unsigned long vstart,
|
|
|
|
|
unsigned long vend,
|
|
|
|
|
pmd_t *pmd)
|
|
|
|
|
{
|
|
|
|
|
const unsigned long mask256mb = (1UL << 28) - 1UL;
|
|
|
|
|
const unsigned long mask2gb = (1UL << 31) - 1UL;
|
|
|
|
|
u64 pte_val = vstart;
|
|
|
|
|
|
|
|
|
|
/* Each PMD is 8MB */
|
|
|
|
|
if ((vstart & mask256mb) ||
|
|
|
|
|
(vend - vstart <= mask256mb)) {
|
|
|
|
|
pte_val ^= kern_linear_pte_xor[0];
|
|
|
|
|
pmd_val(*pmd) = pte_val | _PAGE_PMD_HUGE;
|
|
|
|
|
|
|
|
|
|
return vstart + PMD_SIZE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ((vstart & mask2gb) ||
|
|
|
|
|
(vend - vstart <= mask2gb)) {
|
|
|
|
|
pte_val ^= kern_linear_pte_xor[1];
|
|
|
|
|
pte_val |= _PAGE_PMD_HUGE;
|
|
|
|
|
vend = vstart + mask256mb + 1UL;
|
|
|
|
|
} else {
|
|
|
|
|
pte_val ^= kern_linear_pte_xor[2];
|
|
|
|
|
pte_val |= _PAGE_PMD_HUGE;
|
|
|
|
|
vend = vstart + mask2gb + 1UL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
while (vstart < vend) {
|
|
|
|
|
pmd_val(*pmd) = pte_val;
|
|
|
|
|
|
|
|
|
|
pte_val += PMD_SIZE;
|
|
|
|
|
vstart += PMD_SIZE;
|
|
|
|
|
pmd++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return vstart;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static bool kernel_can_map_hugepmd(unsigned long vstart, unsigned long vend,
|
|
|
|
|
bool guard)
|
|
|
|
|
{
|
|
|
|
|
if (guard && !(vstart & ~PMD_MASK) && (vend - vstart) >= PMD_SIZE)
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2008-02-25 03:49:52 +00:00
|
|
|
static unsigned long __ref kernel_map_range(unsigned long pstart,
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
unsigned long pend, pgprot_t prot,
|
|
|
|
|
bool use_huge)
|
2005-09-25 23:46:57 +00:00
|
|
|
{
|
|
|
|
|
unsigned long vstart = PAGE_OFFSET + pstart;
|
|
|
|
|
unsigned long vend = PAGE_OFFSET + pend;
|
|
|
|
|
unsigned long alloc_bytes = 0UL;
|
|
|
|
|
|
|
|
|
|
if ((vstart & ~PAGE_MASK) || (vend & ~PAGE_MASK)) {
|
2005-09-30 00:58:26 +00:00
|
|
|
prom_printf("kernel_map: Unaligned physmem[%lx:%lx]\n",
|
2005-09-25 23:46:57 +00:00
|
|
|
vstart, vend);
|
|
|
|
|
prom_halt();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
while (vstart < vend) {
|
|
|
|
|
unsigned long this_end, paddr = __pa(vstart);
|
|
|
|
|
pgd_t *pgd = pgd_offset_k(vstart);
|
2019-11-24 08:57:20 +00:00
|
|
|
p4d_t *p4d;
|
2005-09-25 23:46:57 +00:00
|
|
|
pud_t *pud;
|
|
|
|
|
pmd_t *pmd;
|
|
|
|
|
pte_t *pte;
|
|
|
|
|
|
2014-09-27 04:19:46 +00:00
|
|
|
if (pgd_none(*pgd)) {
|
|
|
|
|
pud_t *new;
|
|
|
|
|
|
2018-10-30 22:09:03 +00:00
|
|
|
new = memblock_alloc_from(PAGE_SIZE, PAGE_SIZE,
|
|
|
|
|
PAGE_SIZE);
|
2019-03-12 06:30:10 +00:00
|
|
|
if (!new)
|
|
|
|
|
goto err_alloc;
|
2014-09-27 04:19:46 +00:00
|
|
|
alloc_bytes += PAGE_SIZE;
|
|
|
|
|
pgd_populate(&init_mm, pgd, new);
|
|
|
|
|
}
|
2019-11-24 08:57:20 +00:00
|
|
|
|
|
|
|
|
p4d = p4d_offset(pgd, vstart);
|
|
|
|
|
if (p4d_none(*p4d)) {
|
|
|
|
|
pud_t *new;
|
|
|
|
|
|
|
|
|
|
new = memblock_alloc_from(PAGE_SIZE, PAGE_SIZE,
|
|
|
|
|
PAGE_SIZE);
|
|
|
|
|
if (!new)
|
|
|
|
|
goto err_alloc;
|
|
|
|
|
alloc_bytes += PAGE_SIZE;
|
|
|
|
|
p4d_populate(&init_mm, p4d, new);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pud = pud_offset(p4d, vstart);
|
2005-09-25 23:46:57 +00:00
|
|
|
if (pud_none(*pud)) {
|
|
|
|
|
pmd_t *new;
|
|
|
|
|
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
if (kernel_can_map_hugepud(vstart, vend, use_huge)) {
|
|
|
|
|
vstart = kernel_map_hugepud(vstart, vend, pud);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2018-10-30 22:09:03 +00:00
|
|
|
new = memblock_alloc_from(PAGE_SIZE, PAGE_SIZE,
|
|
|
|
|
PAGE_SIZE);
|
2019-03-12 06:30:10 +00:00
|
|
|
if (!new)
|
|
|
|
|
goto err_alloc;
|
2005-09-25 23:46:57 +00:00
|
|
|
alloc_bytes += PAGE_SIZE;
|
|
|
|
|
pud_populate(&init_mm, pud, new);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pmd = pmd_offset(pud, vstart);
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
if (pmd_none(*pmd)) {
|
2005-09-25 23:46:57 +00:00
|
|
|
pte_t *new;
|
|
|
|
|
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
if (kernel_can_map_hugepmd(vstart, vend, use_huge)) {
|
|
|
|
|
vstart = kernel_map_hugepmd(vstart, vend, pmd);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2018-10-30 22:09:03 +00:00
|
|
|
new = memblock_alloc_from(PAGE_SIZE, PAGE_SIZE,
|
|
|
|
|
PAGE_SIZE);
|
2019-03-12 06:30:10 +00:00
|
|
|
if (!new)
|
|
|
|
|
goto err_alloc;
|
2005-09-25 23:46:57 +00:00
|
|
|
alloc_bytes += PAGE_SIZE;
|
|
|
|
|
pmd_populate_kernel(&init_mm, pmd, new);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pte = pte_offset_kernel(pmd, vstart);
|
|
|
|
|
this_end = (vstart + PMD_SIZE) & PMD_MASK;
|
|
|
|
|
if (this_end > vend)
|
|
|
|
|
this_end = vend;
|
|
|
|
|
|
|
|
|
|
while (vstart < this_end) {
|
|
|
|
|
pte_val(*pte) = (paddr | pgprot_val(prot));
|
|
|
|
|
|
|
|
|
|
vstart += PAGE_SIZE;
|
|
|
|
|
paddr += PAGE_SIZE;
|
|
|
|
|
pte++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return alloc_bytes;
|
2019-03-12 06:30:10 +00:00
|
|
|
|
|
|
|
|
err_alloc:
|
|
|
|
|
panic("%s: Failed to allocate %lu bytes align=%lx from=%lx\n",
|
|
|
|
|
__func__, PAGE_SIZE, PAGE_SIZE, PAGE_SIZE);
|
|
|
|
|
return -ENOMEM;
|
2005-09-25 23:46:57 +00:00
|
|
|
}
|
|
|
|
|
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
static void __init flush_all_kernel_tsbs(void)
|
2012-09-07 01:13:58 +00:00
|
|
|
{
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
int i;
|
2012-09-07 01:13:58 +00:00
|
|
|
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
for (i = 0; i < KERNEL_TSB_NENTRIES; i++) {
|
|
|
|
|
struct tsb *ent = &swapper_tsb[i];
|
2012-09-07 01:13:58 +00:00
|
|
|
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
ent->tag = (1UL << TSB_TAG_INVALID_BIT);
|
2012-09-07 01:13:58 +00:00
|
|
|
}
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
#ifndef CONFIG_DEBUG_PAGEALLOC
|
|
|
|
|
for (i = 0; i < KERNEL_TSB4M_NENTRIES; i++) {
|
|
|
|
|
struct tsb *ent = &swapper_4m_tsb[i];
|
2012-09-07 01:13:58 +00:00
|
|
|
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
ent->tag = (1UL << TSB_TAG_INVALID_BIT);
|
2006-02-22 04:51:13 +00:00
|
|
|
}
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
#endif
|
2006-02-22 04:51:13 +00:00
|
|
|
}
|
2005-09-25 23:46:57 +00:00
|
|
|
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
extern unsigned int kvmap_linear_patch[1];
|
2006-02-22 04:51:13 +00:00
|
|
|
|
2007-12-13 14:13:38 +00:00
|
|
|
static void __init kernel_physical_mapping_init(void)
|
|
|
|
|
{
|
|
|
|
|
unsigned long i, mem_alloced = 0UL;
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
bool use_huge = true;
|
2007-12-13 14:13:38 +00:00
|
|
|
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
#ifdef CONFIG_DEBUG_PAGEALLOC
|
|
|
|
|
use_huge = false;
|
|
|
|
|
#endif
|
2007-12-13 14:13:38 +00:00
|
|
|
for (i = 0; i < pall_ents; i++) {
|
|
|
|
|
unsigned long phys_start, phys_end;
|
|
|
|
|
|
|
|
|
|
phys_start = pall[i].phys_addr;
|
|
|
|
|
phys_end = phys_start + pall[i].reg_size;
|
|
|
|
|
|
2005-09-25 23:46:57 +00:00
|
|
|
mem_alloced += kernel_map_range(phys_start, phys_end,
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
PAGE_KERNEL, use_huge);
|
2005-09-25 23:46:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
printk("Allocated %ld bytes for kernel page tables.\n",
|
|
|
|
|
mem_alloced);
|
|
|
|
|
|
|
|
|
|
kvmap_linear_patch[0] = 0x01000000; /* nop */
|
|
|
|
|
flushi(&kvmap_linear_patch[0]);
|
|
|
|
|
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
flush_all_kernel_tsbs();
|
|
|
|
|
|
2005-09-25 23:46:57 +00:00
|
|
|
__flush_tlb_all();
|
|
|
|
|
}
|
|
|
|
|
|
2006-02-22 04:51:13 +00:00
|
|
|
#ifdef CONFIG_DEBUG_PAGEALLOC
|
2014-12-13 00:55:52 +00:00
|
|
|
void __kernel_map_pages(struct page *page, int numpages, int enable)
|
2005-09-25 23:46:57 +00:00
|
|
|
{
|
|
|
|
|
unsigned long phys_start = page_to_pfn(page) << PAGE_SHIFT;
|
|
|
|
|
unsigned long phys_end = phys_start + (numpages * PAGE_SIZE);
|
|
|
|
|
|
|
|
|
|
kernel_map_range(phys_start, phys_end,
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
(enable ? PAGE_KERNEL : __pgprot(0)), false);
|
2005-09-25 23:46:57 +00:00
|
|
|
|
2006-02-01 02:29:18 +00:00
|
|
|
flush_tsb_kernel_range(PAGE_OFFSET + phys_start,
|
|
|
|
|
PAGE_OFFSET + phys_end);
|
|
|
|
|
|
2005-09-25 23:46:57 +00:00
|
|
|
/* we should perform an IPI and flush all tlbs,
|
|
|
|
|
* but that can deadlock->flush only current cpu.
|
|
|
|
|
*/
|
|
|
|
|
__flush_tlb_kernel_range(PAGE_OFFSET + phys_start,
|
|
|
|
|
PAGE_OFFSET + phys_end);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2005-09-29 04:46:43 +00:00
|
|
|
unsigned long __init find_ecache_flush_span(unsigned long size)
|
|
|
|
|
{
|
2005-09-29 04:38:08 +00:00
|
|
|
int i;
|
|
|
|
|
|
2005-09-30 00:58:26 +00:00
|
|
|
for (i = 0; i < pavail_ents; i++) {
|
|
|
|
|
if (pavail[i].reg_size >= size)
|
|
|
|
|
return pavail[i].phys_addr;
|
2005-09-29 04:38:08 +00:00
|
|
|
}
|
|
|
|
|
|
2005-09-30 00:58:26 +00:00
|
|
|
return ~0UL;
|
2005-09-29 04:38:08 +00:00
|
|
|
}
|
|
|
|
|
|
2013-09-21 04:50:41 +00:00
|
|
|
unsigned long PAGE_OFFSET;
|
|
|
|
|
EXPORT_SYMBOL(PAGE_OFFSET);
|
|
|
|
|
|
2014-09-27 18:05:21 +00:00
|
|
|
unsigned long VMALLOC_END = 0x0000010000000000UL;
|
|
|
|
|
EXPORT_SYMBOL(VMALLOC_END);
|
|
|
|
|
|
2014-09-27 04:58:33 +00:00
|
|
|
unsigned long sparc64_va_hole_top = 0xfffff80000000000UL;
|
|
|
|
|
unsigned long sparc64_va_hole_bottom = 0x0000080000000000UL;
|
|
|
|
|
|
2013-09-21 04:50:41 +00:00
|
|
|
static void __init setup_page_offset(void)
|
|
|
|
|
{
|
|
|
|
|
if (tlb_type == cheetah || tlb_type == cheetah_plus) {
|
2014-09-27 04:58:33 +00:00
|
|
|
/* Cheetah/Panther support a full 64-bit virtual
|
|
|
|
|
* address, so we can use all that our page tables
|
|
|
|
|
* support.
|
|
|
|
|
*/
|
|
|
|
|
sparc64_va_hole_top = 0xfff0000000000000UL;
|
|
|
|
|
sparc64_va_hole_bottom = 0x0010000000000000UL;
|
|
|
|
|
|
2013-09-21 04:50:41 +00:00
|
|
|
max_phys_bits = 42;
|
|
|
|
|
} else if (tlb_type == hypervisor) {
|
|
|
|
|
switch (sun4v_chip_type) {
|
|
|
|
|
case SUN4V_CHIP_NIAGARA1:
|
|
|
|
|
case SUN4V_CHIP_NIAGARA2:
|
2014-09-27 04:58:33 +00:00
|
|
|
/* T1 and T2 support 48-bit virtual addresses. */
|
|
|
|
|
sparc64_va_hole_top = 0xffff800000000000UL;
|
|
|
|
|
sparc64_va_hole_bottom = 0x0000800000000000UL;
|
|
|
|
|
|
2013-09-21 04:50:41 +00:00
|
|
|
max_phys_bits = 39;
|
|
|
|
|
break;
|
|
|
|
|
case SUN4V_CHIP_NIAGARA3:
|
2014-09-27 04:58:33 +00:00
|
|
|
/* T3 supports 48-bit virtual addresses. */
|
|
|
|
|
sparc64_va_hole_top = 0xffff800000000000UL;
|
|
|
|
|
sparc64_va_hole_bottom = 0x0000800000000000UL;
|
|
|
|
|
|
2013-09-21 04:50:41 +00:00
|
|
|
max_phys_bits = 43;
|
|
|
|
|
break;
|
|
|
|
|
case SUN4V_CHIP_NIAGARA4:
|
|
|
|
|
case SUN4V_CHIP_NIAGARA5:
|
|
|
|
|
case SUN4V_CHIP_SPARC64X:
|
2014-09-25 04:49:29 +00:00
|
|
|
case SUN4V_CHIP_SPARC_M6:
|
2014-09-27 04:58:33 +00:00
|
|
|
/* T4 and later support 52-bit virtual addresses. */
|
|
|
|
|
sparc64_va_hole_top = 0xfff8000000000000UL;
|
|
|
|
|
sparc64_va_hole_bottom = 0x0008000000000000UL;
|
2013-09-21 04:50:41 +00:00
|
|
|
max_phys_bits = 47;
|
|
|
|
|
break;
|
2014-09-25 04:49:29 +00:00
|
|
|
case SUN4V_CHIP_SPARC_M7:
|
2016-04-19 17:12:54 +00:00
|
|
|
case SUN4V_CHIP_SPARC_SN:
|
2014-09-25 04:49:29 +00:00
|
|
|
/* M7 and later support 52-bit virtual addresses. */
|
|
|
|
|
sparc64_va_hole_top = 0xfff8000000000000UL;
|
|
|
|
|
sparc64_va_hole_bottom = 0x0008000000000000UL;
|
|
|
|
|
max_phys_bits = 49;
|
|
|
|
|
break;
|
2017-07-29 01:29:32 +00:00
|
|
|
case SUN4V_CHIP_SPARC_M8:
|
|
|
|
|
default:
|
|
|
|
|
/* M8 and later support 54-bit virtual addresses.
|
|
|
|
|
* However, restricting M8 and above VA bits to 53
|
|
|
|
|
* as 4-level page table cannot support more than
|
|
|
|
|
* 53 VA bits.
|
|
|
|
|
*/
|
|
|
|
|
sparc64_va_hole_top = 0xfff0000000000000UL;
|
|
|
|
|
sparc64_va_hole_bottom = 0x0010000000000000UL;
|
|
|
|
|
max_phys_bits = 51;
|
|
|
|
|
break;
|
2013-09-21 04:50:41 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (max_phys_bits > MAX_PHYS_ADDRESS_BITS) {
|
|
|
|
|
prom_printf("MAX_PHYS_ADDRESS_BITS is too small, need %lu\n",
|
|
|
|
|
max_phys_bits);
|
|
|
|
|
prom_halt();
|
|
|
|
|
}
|
|
|
|
|
|
2014-09-27 18:05:21 +00:00
|
|
|
PAGE_OFFSET = sparc64_va_hole_top;
|
|
|
|
|
VMALLOC_END = ((sparc64_va_hole_bottom >> 1) +
|
|
|
|
|
(sparc64_va_hole_bottom >> 2));
|
2013-09-21 04:50:41 +00:00
|
|
|
|
2014-09-27 18:05:21 +00:00
|
|
|
pr_info("MM: PAGE_OFFSET is 0x%016lx (max_phys_bits == %lu)\n",
|
2013-09-21 04:50:41 +00:00
|
|
|
PAGE_OFFSET, max_phys_bits);
|
2014-09-27 18:05:21 +00:00
|
|
|
pr_info("MM: VMALLOC [0x%016lx --> 0x%016lx]\n",
|
|
|
|
|
VMALLOC_START, VMALLOC_END);
|
|
|
|
|
pr_info("MM: VMEMMAP [0x%016lx --> 0x%016lx]\n",
|
|
|
|
|
VMEMMAP_BASE, VMEMMAP_BASE << 1);
|
2013-09-21 04:50:41 +00:00
|
|
|
}
|
|
|
|
|
|
2006-02-01 23:55:21 +00:00
|
|
|
static void __init tsb_phys_patch(void)
|
|
|
|
|
{
|
2006-02-07 07:44:37 +00:00
|
|
|
struct tsb_ldquad_phys_patch_entry *pquad;
|
2006-02-01 23:55:21 +00:00
|
|
|
struct tsb_phys_patch_entry *p;
|
|
|
|
|
|
2006-02-07 07:44:37 +00:00
|
|
|
pquad = &__tsb_ldquad_phys_patch;
|
|
|
|
|
while (pquad < &__tsb_ldquad_phys_patch_end) {
|
|
|
|
|
unsigned long addr = pquad->addr;
|
|
|
|
|
|
|
|
|
|
if (tlb_type == hypervisor)
|
|
|
|
|
*(unsigned int *) addr = pquad->sun4v_insn;
|
|
|
|
|
else
|
|
|
|
|
*(unsigned int *) addr = pquad->sun4u_insn;
|
|
|
|
|
wmb();
|
|
|
|
|
__asm__ __volatile__("flush %0"
|
|
|
|
|
: /* no outputs */
|
|
|
|
|
: "r" (addr));
|
|
|
|
|
|
|
|
|
|
pquad++;
|
|
|
|
|
}
|
|
|
|
|
|
2006-02-01 23:55:21 +00:00
|
|
|
p = &__tsb_phys_patch;
|
|
|
|
|
while (p < &__tsb_phys_patch_end) {
|
|
|
|
|
unsigned long addr = p->addr;
|
|
|
|
|
|
|
|
|
|
*(unsigned int *) addr = p->insn;
|
|
|
|
|
wmb();
|
|
|
|
|
__asm__ __volatile__("flush %0"
|
|
|
|
|
: /* no outputs */
|
|
|
|
|
: "r" (addr));
|
|
|
|
|
|
|
|
|
|
p++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-02-11 22:41:18 +00:00
|
|
|
/* Don't mark as init, we give this to the Hypervisor. */
|
2007-03-17 00:20:28 +00:00
|
|
|
#ifndef CONFIG_DEBUG_PAGEALLOC
|
|
|
|
|
#define NUM_KTSB_DESCR 2
|
|
|
|
|
#else
|
|
|
|
|
#define NUM_KTSB_DESCR 1
|
|
|
|
|
#endif
|
|
|
|
|
static struct hv_tsb_descr ktsb_descr[NUM_KTSB_DESCR];
|
2006-02-11 22:41:18 +00:00
|
|
|
|
2014-09-17 17:14:56 +00:00
|
|
|
/* The swapper TSBs are loaded with a base sequence of:
|
|
|
|
|
*
|
|
|
|
|
* sethi %uhi(SYMBOL), REG1
|
|
|
|
|
* sethi %hi(SYMBOL), REG2
|
|
|
|
|
* or REG1, %ulo(SYMBOL), REG1
|
|
|
|
|
* or REG2, %lo(SYMBOL), REG2
|
|
|
|
|
* sllx REG1, 32, REG1
|
|
|
|
|
* or REG1, REG2, REG1
|
|
|
|
|
*
|
|
|
|
|
* When we use physical addressing for the TSB accesses, we patch the
|
|
|
|
|
* first four instructions in the above sequence.
|
|
|
|
|
*/
|
|
|
|
|
|
2011-08-05 07:53:57 +00:00
|
|
|
static void patch_one_ktsb_phys(unsigned int *start, unsigned int *end, unsigned long pa)
|
|
|
|
|
{
|
2014-09-17 17:14:56 +00:00
|
|
|
unsigned long high_bits, low_bits;
|
|
|
|
|
|
|
|
|
|
high_bits = (pa >> 32) & 0xffffffff;
|
|
|
|
|
low_bits = (pa >> 0) & 0xffffffff;
|
2011-08-05 07:53:57 +00:00
|
|
|
|
|
|
|
|
while (start < end) {
|
|
|
|
|
unsigned int *ia = (unsigned int *)(unsigned long)*start;
|
|
|
|
|
|
2014-09-17 17:14:56 +00:00
|
|
|
ia[0] = (ia[0] & ~0x3fffff) | (high_bits >> 10);
|
2011-08-05 07:53:57 +00:00
|
|
|
__asm__ __volatile__("flush %0" : : "r" (ia));
|
|
|
|
|
|
2014-09-17 17:14:56 +00:00
|
|
|
ia[1] = (ia[1] & ~0x3fffff) | (low_bits >> 10);
|
2011-08-05 07:53:57 +00:00
|
|
|
__asm__ __volatile__("flush %0" : : "r" (ia + 1));
|
|
|
|
|
|
2014-09-17 17:14:56 +00:00
|
|
|
ia[2] = (ia[2] & ~0x1fff) | (high_bits & 0x3ff);
|
|
|
|
|
__asm__ __volatile__("flush %0" : : "r" (ia + 2));
|
|
|
|
|
|
|
|
|
|
ia[3] = (ia[3] & ~0x1fff) | (low_bits & 0x3ff);
|
|
|
|
|
__asm__ __volatile__("flush %0" : : "r" (ia + 3));
|
|
|
|
|
|
2011-08-05 07:53:57 +00:00
|
|
|
start++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void ktsb_phys_patch(void)
|
|
|
|
|
{
|
|
|
|
|
extern unsigned int __swapper_tsb_phys_patch;
|
|
|
|
|
extern unsigned int __swapper_tsb_phys_patch_end;
|
|
|
|
|
unsigned long ktsb_pa;
|
|
|
|
|
|
|
|
|
|
ktsb_pa = kern_base + ((unsigned long)&swapper_tsb[0] - KERNBASE);
|
|
|
|
|
patch_one_ktsb_phys(&__swapper_tsb_phys_patch,
|
|
|
|
|
&__swapper_tsb_phys_patch_end, ktsb_pa);
|
|
|
|
|
#ifndef CONFIG_DEBUG_PAGEALLOC
|
2011-08-06 12:26:35 +00:00
|
|
|
{
|
|
|
|
|
extern unsigned int __swapper_4m_tsb_phys_patch;
|
|
|
|
|
extern unsigned int __swapper_4m_tsb_phys_patch_end;
|
2011-08-05 07:53:57 +00:00
|
|
|
ktsb_pa = (kern_base +
|
|
|
|
|
((unsigned long)&swapper_4m_tsb[0] - KERNBASE));
|
|
|
|
|
patch_one_ktsb_phys(&__swapper_4m_tsb_phys_patch,
|
|
|
|
|
&__swapper_4m_tsb_phys_patch_end, ktsb_pa);
|
2011-08-06 12:26:35 +00:00
|
|
|
}
|
2011-08-05 07:53:57 +00:00
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2006-02-11 22:41:18 +00:00
|
|
|
static void __init sun4v_ktsb_init(void)
|
|
|
|
|
{
|
|
|
|
|
unsigned long ktsb_pa;
|
|
|
|
|
|
2006-02-22 06:31:11 +00:00
|
|
|
/* First KTSB for PAGE_SIZE mappings. */
|
2006-02-11 22:41:18 +00:00
|
|
|
ktsb_pa = kern_base + ((unsigned long)&swapper_tsb[0] - KERNBASE);
|
|
|
|
|
|
|
|
|
|
switch (PAGE_SIZE) {
|
|
|
|
|
case 8 * 1024:
|
|
|
|
|
default:
|
|
|
|
|
ktsb_descr[0].pgsz_idx = HV_PGSZ_IDX_8K;
|
|
|
|
|
ktsb_descr[0].pgsz_mask = HV_PGSZ_MASK_8K;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 64 * 1024:
|
|
|
|
|
ktsb_descr[0].pgsz_idx = HV_PGSZ_IDX_64K;
|
|
|
|
|
ktsb_descr[0].pgsz_mask = HV_PGSZ_MASK_64K;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 512 * 1024:
|
|
|
|
|
ktsb_descr[0].pgsz_idx = HV_PGSZ_IDX_512K;
|
|
|
|
|
ktsb_descr[0].pgsz_mask = HV_PGSZ_MASK_512K;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 4 * 1024 * 1024:
|
|
|
|
|
ktsb_descr[0].pgsz_idx = HV_PGSZ_IDX_4MB;
|
|
|
|
|
ktsb_descr[0].pgsz_mask = HV_PGSZ_MASK_4MB;
|
|
|
|
|
break;
|
2011-06-03 14:45:23 +00:00
|
|
|
}
|
2006-02-11 22:41:18 +00:00
|
|
|
|
2006-02-17 20:03:20 +00:00
|
|
|
ktsb_descr[0].assoc = 1;
|
2006-02-11 22:41:18 +00:00
|
|
|
ktsb_descr[0].num_ttes = KERNEL_TSB_NENTRIES;
|
|
|
|
|
ktsb_descr[0].ctx_idx = 0;
|
|
|
|
|
ktsb_descr[0].tsb_base = ktsb_pa;
|
|
|
|
|
ktsb_descr[0].resv = 0;
|
|
|
|
|
|
2007-03-17 00:20:28 +00:00
|
|
|
#ifndef CONFIG_DEBUG_PAGEALLOC
|
2012-09-07 01:13:58 +00:00
|
|
|
/* Second KTSB for 4MB/256MB/2GB/16GB mappings. */
|
2006-02-22 06:31:11 +00:00
|
|
|
ktsb_pa = (kern_base +
|
|
|
|
|
((unsigned long)&swapper_4m_tsb[0] - KERNBASE));
|
|
|
|
|
|
|
|
|
|
ktsb_descr[1].pgsz_idx = HV_PGSZ_IDX_4MB;
|
2012-09-07 03:35:36 +00:00
|
|
|
ktsb_descr[1].pgsz_mask = ((HV_PGSZ_MASK_4MB |
|
|
|
|
|
HV_PGSZ_MASK_256MB |
|
|
|
|
|
HV_PGSZ_MASK_2GB |
|
|
|
|
|
HV_PGSZ_MASK_16GB) &
|
|
|
|
|
cpu_pgsz_mask);
|
2006-02-22 06:31:11 +00:00
|
|
|
ktsb_descr[1].assoc = 1;
|
|
|
|
|
ktsb_descr[1].num_ttes = KERNEL_TSB4M_NENTRIES;
|
|
|
|
|
ktsb_descr[1].ctx_idx = 0;
|
|
|
|
|
ktsb_descr[1].tsb_base = ktsb_pa;
|
|
|
|
|
ktsb_descr[1].resv = 0;
|
2007-03-17 00:20:28 +00:00
|
|
|
#endif
|
2006-02-11 22:41:18 +00:00
|
|
|
}
|
|
|
|
|
|
sparc: delete __cpuinit/__CPUINIT usage from all users
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
are flagged as __cpuinit -- so if we remove the __cpuinit from
arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
content into no-ops as early as possible, since that will get rid
of these warnings. In any case, they are temporary and harmless.
This removes all the arch/sparc uses of the __cpuinit macros from
C files and removes __CPUINIT from assembly files. Note that even
though arch/sparc/kernel/trampoline_64.S has instances of ".previous"
in it, they are all paired off against explicit ".section" directives,
and not implicitly paired with __CPUINIT (unlike mips and arm were).
[1] https://lkml.org/lkml/2013/5/20/589
Cc: "David S. Miller" <davem@davemloft.net>
Cc: sparclinux@vger.kernel.org
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2013-06-17 19:43:14 +00:00
|
|
|
void sun4v_ktsb_register(void)
|
2006-02-11 22:41:18 +00:00
|
|
|
{
|
2007-05-29 09:22:14 +00:00
|
|
|
unsigned long pa, ret;
|
2006-02-11 22:41:18 +00:00
|
|
|
|
|
|
|
|
pa = kern_base + ((unsigned long)&ktsb_descr[0] - KERNBASE);
|
|
|
|
|
|
2007-05-29 09:22:14 +00:00
|
|
|
ret = sun4v_mmu_tsb_ctx0(NUM_KTSB_DESCR, pa);
|
|
|
|
|
if (ret != 0) {
|
|
|
|
|
prom_printf("hypervisor_mmu_tsb_ctx0[%lx]: "
|
|
|
|
|
"errors with %lx\n", pa, ret);
|
|
|
|
|
prom_halt();
|
|
|
|
|
}
|
2006-02-11 22:41:18 +00:00
|
|
|
}
|
|
|
|
|
|
2012-09-07 03:35:36 +00:00
|
|
|
static void __init sun4u_linear_pte_xor_finalize(void)
|
|
|
|
|
{
|
|
|
|
|
#ifndef CONFIG_DEBUG_PAGEALLOC
|
|
|
|
|
/* This is where we would add Panther support for
|
|
|
|
|
* 32MB and 256MB pages.
|
|
|
|
|
*/
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void __init sun4v_linear_pte_xor_finalize(void)
|
|
|
|
|
{
|
2015-05-27 16:00:46 +00:00
|
|
|
unsigned long pagecv_flag;
|
|
|
|
|
|
|
|
|
|
/* Bit 9 of TTE is no longer CV bit on M7 processor and it instead
|
|
|
|
|
* enables MCD error. Do not set bit 9 on M7 processor.
|
|
|
|
|
*/
|
|
|
|
|
switch (sun4v_chip_type) {
|
|
|
|
|
case SUN4V_CHIP_SPARC_M7:
|
2017-07-24 06:14:18 +00:00
|
|
|
case SUN4V_CHIP_SPARC_M8:
|
2016-04-19 17:12:54 +00:00
|
|
|
case SUN4V_CHIP_SPARC_SN:
|
2015-05-27 16:00:46 +00:00
|
|
|
pagecv_flag = 0x00;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
pagecv_flag = _PAGE_CV_4V;
|
|
|
|
|
break;
|
|
|
|
|
}
|
2012-09-07 03:35:36 +00:00
|
|
|
#ifndef CONFIG_DEBUG_PAGEALLOC
|
|
|
|
|
if (cpu_pgsz_mask & HV_PGSZ_MASK_256MB) {
|
|
|
|
|
kern_linear_pte_xor[1] = (_PAGE_VALID | _PAGE_SZ256MB_4V) ^
|
2013-09-18 19:00:00 +00:00
|
|
|
PAGE_OFFSET;
|
2015-05-27 16:00:46 +00:00
|
|
|
kern_linear_pte_xor[1] |= (_PAGE_CP_4V | pagecv_flag |
|
2012-09-07 03:35:36 +00:00
|
|
|
_PAGE_P_4V | _PAGE_W_4V);
|
|
|
|
|
} else {
|
|
|
|
|
kern_linear_pte_xor[1] = kern_linear_pte_xor[0];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (cpu_pgsz_mask & HV_PGSZ_MASK_2GB) {
|
|
|
|
|
kern_linear_pte_xor[2] = (_PAGE_VALID | _PAGE_SZ2GB_4V) ^
|
2013-09-18 19:00:00 +00:00
|
|
|
PAGE_OFFSET;
|
2015-05-27 16:00:46 +00:00
|
|
|
kern_linear_pte_xor[2] |= (_PAGE_CP_4V | pagecv_flag |
|
2012-09-07 03:35:36 +00:00
|
|
|
_PAGE_P_4V | _PAGE_W_4V);
|
|
|
|
|
} else {
|
|
|
|
|
kern_linear_pte_xor[2] = kern_linear_pte_xor[1];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (cpu_pgsz_mask & HV_PGSZ_MASK_16GB) {
|
|
|
|
|
kern_linear_pte_xor[3] = (_PAGE_VALID | _PAGE_SZ16GB_4V) ^
|
2013-09-18 19:00:00 +00:00
|
|
|
PAGE_OFFSET;
|
2015-05-27 16:00:46 +00:00
|
|
|
kern_linear_pte_xor[3] |= (_PAGE_CP_4V | pagecv_flag |
|
2012-09-07 03:35:36 +00:00
|
|
|
_PAGE_P_4V | _PAGE_W_4V);
|
|
|
|
|
} else {
|
|
|
|
|
kern_linear_pte_xor[3] = kern_linear_pte_xor[2];
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* paging_init() sets up the page tables */
|
|
|
|
|
|
|
|
|
|
static unsigned long last_valid_pfn;
|
2014-09-27 04:19:46 +00:00
|
|
|
|
2006-02-12 05:57:54 +00:00
|
|
|
static void sun4u_pgprot_init(void);
|
|
|
|
|
static void sun4v_pgprot_init(void);
|
|
|
|
|
|
2015-05-27 16:00:46 +00:00
|
|
|
#define _PAGE_CACHE_4U (_PAGE_CP_4U | _PAGE_CV_4U)
|
|
|
|
|
#define _PAGE_CACHE_4V (_PAGE_CP_4V | _PAGE_CV_4V)
|
|
|
|
|
#define __DIRTY_BITS_4U (_PAGE_MODIFIED_4U | _PAGE_WRITE_4U | _PAGE_W_4U)
|
|
|
|
|
#define __DIRTY_BITS_4V (_PAGE_MODIFIED_4V | _PAGE_WRITE_4V | _PAGE_W_4V)
|
|
|
|
|
#define __ACCESS_BITS_4U (_PAGE_ACCESSED_4U | _PAGE_READ_4U | _PAGE_R)
|
|
|
|
|
#define __ACCESS_BITS_4V (_PAGE_ACCESSED_4V | _PAGE_READ_4V | _PAGE_R)
|
|
|
|
|
|
sparc64: mem boot option correction
The "mem" boot option can result in many unexpected consequences. This patch
attempts to prevent boot hangs which have been experienced on T4-4 and T5-8.
Basically the boot loader allocates vmlinuz and initrd higher in available
OBP physical memory. For example, on a 2Tb T5-8 it isn't possible to boot
with mem=20G.
The patch utilizes memblock to avoid reserved regions and trim memory which
is only free. Other improvements are possible for a multi-node machine.
This is a snippet of the boot log with mem=20G on T5-8 with the patch applied:
MEMBLOCK configuration: <- before memory reduction
memory size = 0x1ffad6ce000 reserved size = 0xa1adf44
memory.cnt = 0xb
memory[0x0] [0x00000030400000-0x00003fdde47fff], 0x3fada48000 bytes
memory[0x1] [0x00003fdde4e000-0x00003fdde4ffff], 0x2000 bytes
memory[0x2] [0x00080000000000-0x00083fffffffff], 0x4000000000 bytes
memory[0x3] [0x00100000000000-0x00103fffffffff], 0x4000000000 bytes
memory[0x4] [0x00180000000000-0x00183fffffffff], 0x4000000000 bytes
memory[0x5] [0x00200000000000-0x00203fffffffff], 0x4000000000 bytes
memory[0x6] [0x00280000000000-0x00283fffffffff], 0x4000000000 bytes
memory[0x7] [0x00300000000000-0x00303fffffffff], 0x4000000000 bytes
memory[0x8] [0x00380000000000-0x00383fffc71fff], 0x3fffc72000 bytes
memory[0x9] [0x00383fffc92000-0x00383fffca1fff], 0x10000 bytes
memory[0xa] [0x00383fffcb4000-0x00383fffcb5fff], 0x2000 bytes
reserved.cnt = 0x2
reserved[0x0] [0x00380000000000-0x0038000117e7f8], 0x117e7f9 bytes
reserved[0x1] [0x00380004000000-0x0038000d02f74a], 0x902f74b bytes
...
MEMBLOCK configuration: <- after reduction of memory
memory size = 0x50a1adf44 reserved size = 0xa1adf44
memory.cnt = 0x4
memory[0x0] [0x00380000000000-0x0038000117e7f8], 0x117e7f9 bytes
memory[0x1] [0x00380004000000-0x0038050d01d74a], 0x50901d74b bytes
memory[0x2] [0x00383fffc92000-0x00383fffca1fff], 0x10000 bytes
memory[0x3] [0x00383fffcb4000-0x00383fffcb5fff], 0x2000 bytes
reserved.cnt = 0x2
reserved[0x0] [0x00380000000000-0x0038000117e7f8], 0x117e7f9 bytes
reserved[0x1] [0x00380004000000-0x0038000d02f74a], 0x902f74b bytes
...
Early memory node ranges
node 7: [mem 0x380000000000-0x38000117dfff]
node 7: [mem 0x380004000000-0x380f0d01bfff]
node 7: [mem 0x383fffc92000-0x383fffca1fff]
node 7: [mem 0x383fffcb4000-0x383fffcb5fff]
Could not find start_pfn for node 0
Could not find start_pfn for node 1
Could not find start_pfn for node 2
Could not find start_pfn for node 3
Could not find start_pfn for node 4
Could not find start_pfn for node 5
Could not find start_pfn for node 6
.
The patch was tested on T4-1, T5-8 and Jalap?no.
Cc: sparclinux@vger.kernel.org
Signed-off-by: Bob Picco <bob.picco@oracle.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-09-16 13:29:54 +00:00
|
|
|
/* We need to exclude reserved regions. This exclusion will include
|
|
|
|
|
* vmlinux and initrd. To be more precise the initrd size could be used to
|
|
|
|
|
* compute a new lower limit because it is freed later during initialization.
|
|
|
|
|
*/
|
|
|
|
|
static void __init reduce_memory(phys_addr_t limit_ram)
|
|
|
|
|
{
|
2019-02-12 09:32:36 +00:00
|
|
|
limit_ram += memblock_reserved_size();
|
|
|
|
|
memblock_enforce_memory_limit(limit_ram);
|
sparc64: mem boot option correction
The "mem" boot option can result in many unexpected consequences. This patch
attempts to prevent boot hangs which have been experienced on T4-4 and T5-8.
Basically the boot loader allocates vmlinuz and initrd higher in available
OBP physical memory. For example, on a 2Tb T5-8 it isn't possible to boot
with mem=20G.
The patch utilizes memblock to avoid reserved regions and trim memory which
is only free. Other improvements are possible for a multi-node machine.
This is a snippet of the boot log with mem=20G on T5-8 with the patch applied:
MEMBLOCK configuration: <- before memory reduction
memory size = 0x1ffad6ce000 reserved size = 0xa1adf44
memory.cnt = 0xb
memory[0x0] [0x00000030400000-0x00003fdde47fff], 0x3fada48000 bytes
memory[0x1] [0x00003fdde4e000-0x00003fdde4ffff], 0x2000 bytes
memory[0x2] [0x00080000000000-0x00083fffffffff], 0x4000000000 bytes
memory[0x3] [0x00100000000000-0x00103fffffffff], 0x4000000000 bytes
memory[0x4] [0x00180000000000-0x00183fffffffff], 0x4000000000 bytes
memory[0x5] [0x00200000000000-0x00203fffffffff], 0x4000000000 bytes
memory[0x6] [0x00280000000000-0x00283fffffffff], 0x4000000000 bytes
memory[0x7] [0x00300000000000-0x00303fffffffff], 0x4000000000 bytes
memory[0x8] [0x00380000000000-0x00383fffc71fff], 0x3fffc72000 bytes
memory[0x9] [0x00383fffc92000-0x00383fffca1fff], 0x10000 bytes
memory[0xa] [0x00383fffcb4000-0x00383fffcb5fff], 0x2000 bytes
reserved.cnt = 0x2
reserved[0x0] [0x00380000000000-0x0038000117e7f8], 0x117e7f9 bytes
reserved[0x1] [0x00380004000000-0x0038000d02f74a], 0x902f74b bytes
...
MEMBLOCK configuration: <- after reduction of memory
memory size = 0x50a1adf44 reserved size = 0xa1adf44
memory.cnt = 0x4
memory[0x0] [0x00380000000000-0x0038000117e7f8], 0x117e7f9 bytes
memory[0x1] [0x00380004000000-0x0038050d01d74a], 0x50901d74b bytes
memory[0x2] [0x00383fffc92000-0x00383fffca1fff], 0x10000 bytes
memory[0x3] [0x00383fffcb4000-0x00383fffcb5fff], 0x2000 bytes
reserved.cnt = 0x2
reserved[0x0] [0x00380000000000-0x0038000117e7f8], 0x117e7f9 bytes
reserved[0x1] [0x00380004000000-0x0038000d02f74a], 0x902f74b bytes
...
Early memory node ranges
node 7: [mem 0x380000000000-0x38000117dfff]
node 7: [mem 0x380004000000-0x380f0d01bfff]
node 7: [mem 0x383fffc92000-0x383fffca1fff]
node 7: [mem 0x383fffcb4000-0x383fffcb5fff]
Could not find start_pfn for node 0
Could not find start_pfn for node 1
Could not find start_pfn for node 2
Could not find start_pfn for node 3
Could not find start_pfn for node 4
Could not find start_pfn for node 5
Could not find start_pfn for node 6
.
The patch was tested on T4-1, T5-8 and Jalap?no.
Cc: sparclinux@vger.kernel.org
Signed-off-by: Bob Picco <bob.picco@oracle.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-09-16 13:29:54 +00:00
|
|
|
}
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
void __init paging_init(void)
|
|
|
|
|
{
|
2008-04-23 12:40:25 +00:00
|
|
|
unsigned long end_pfn, shift, phys_base;
|
2005-09-29 04:38:08 +00:00
|
|
|
unsigned long real_end, i;
|
|
|
|
|
|
2013-09-21 04:50:41 +00:00
|
|
|
setup_page_offset();
|
|
|
|
|
|
2007-05-26 08:14:43 +00:00
|
|
|
/* These build time checkes make sure that the dcache_dirty_cpu()
|
|
|
|
|
* page->flags usage will work.
|
|
|
|
|
*
|
|
|
|
|
* When a page gets marked as dcache-dirty, we store the
|
|
|
|
|
* cpu number starting at bit 32 in the page->flags. Also,
|
|
|
|
|
* functions like clear_dcache_dirty_cpu use the cpu mask
|
|
|
|
|
* in 13-bit signed-immediate instruction fields.
|
|
|
|
|
*/
|
2008-04-28 09:12:48 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Page flags must not reach into upper 32 bits that are used
|
|
|
|
|
* for the cpu number
|
|
|
|
|
*/
|
|
|
|
|
BUILD_BUG_ON(NR_PAGEFLAGS > 32);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* The bit fields placed in the high range must not reach below
|
|
|
|
|
* the 32 bit boundary. Otherwise we cannot place the cpu field
|
|
|
|
|
* at the 32 bit boundary.
|
|
|
|
|
*/
|
2007-05-26 08:14:43 +00:00
|
|
|
BUILD_BUG_ON(SECTIONS_WIDTH + NODES_WIDTH + ZONES_WIDTH +
|
2008-04-28 09:12:48 +00:00
|
|
|
ilog2(roundup_pow_of_two(NR_CPUS)) > 32);
|
|
|
|
|
|
2007-05-26 08:14:43 +00:00
|
|
|
BUILD_BUG_ON(NR_CPUS > 4096);
|
|
|
|
|
|
2014-05-04 05:52:50 +00:00
|
|
|
kern_base = (prom_boot_mapping_phys_low >> ILOG2_4MB) << ILOG2_4MB;
|
2006-02-08 05:51:08 +00:00
|
|
|
kern_size = (unsigned long)&_end - (unsigned long)KERNBASE;
|
|
|
|
|
|
2006-02-22 06:31:11 +00:00
|
|
|
/* Invalidate both kernel TSBs. */
|
2006-02-18 02:01:02 +00:00
|
|
|
memset(swapper_tsb, 0x40, sizeof(swapper_tsb));
|
2007-03-17 00:20:28 +00:00
|
|
|
#ifndef CONFIG_DEBUG_PAGEALLOC
|
2006-02-22 06:31:11 +00:00
|
|
|
memset(swapper_4m_tsb, 0x40, sizeof(swapper_4m_tsb));
|
2007-03-17 00:20:28 +00:00
|
|
|
#endif
|
2006-02-18 02:01:02 +00:00
|
|
|
|
2015-05-27 16:00:46 +00:00
|
|
|
/* TTE.cv bit on sparc v9 occupies the same position as TTE.mcde
|
|
|
|
|
* bit on M7 processor. This is a conflicting usage of the same
|
|
|
|
|
* bit. Enabling TTE.cv on M7 would turn on Memory Corruption
|
|
|
|
|
* Detection error on all pages and this will lead to problems
|
|
|
|
|
* later. Kernel does not run with MCD enabled and hence rest
|
|
|
|
|
* of the required steps to fully configure memory corruption
|
|
|
|
|
* detection are not taken. We need to ensure TTE.mcde is not
|
|
|
|
|
* set on M7 processor. Compute the value of cacheability
|
|
|
|
|
* flag for use later taking this into consideration.
|
|
|
|
|
*/
|
|
|
|
|
switch (sun4v_chip_type) {
|
|
|
|
|
case SUN4V_CHIP_SPARC_M7:
|
2017-07-24 06:14:18 +00:00
|
|
|
case SUN4V_CHIP_SPARC_M8:
|
2016-04-19 17:12:54 +00:00
|
|
|
case SUN4V_CHIP_SPARC_SN:
|
2015-05-27 16:00:46 +00:00
|
|
|
page_cache4v_flag = _PAGE_CP_4V;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
page_cache4v_flag = _PAGE_CACHE_4V;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2006-02-12 05:57:54 +00:00
|
|
|
if (tlb_type == hypervisor)
|
|
|
|
|
sun4v_pgprot_init();
|
|
|
|
|
else
|
|
|
|
|
sun4u_pgprot_init();
|
|
|
|
|
|
2006-02-07 07:44:37 +00:00
|
|
|
if (tlb_type == cheetah_plus ||
|
2011-08-05 07:53:57 +00:00
|
|
|
tlb_type == hypervisor) {
|
2006-02-01 23:55:21 +00:00
|
|
|
tsb_phys_patch();
|
2011-08-05 07:53:57 +00:00
|
|
|
ktsb_phys_patch();
|
|
|
|
|
}
|
2006-02-01 23:55:21 +00:00
|
|
|
|
2012-09-07 03:35:36 +00:00
|
|
|
if (tlb_type == hypervisor)
|
2006-02-07 07:44:37 +00:00
|
|
|
sun4v_patch_tlb_handlers();
|
|
|
|
|
|
2008-05-12 04:04:48 +00:00
|
|
|
/* Find available physical memory...
|
|
|
|
|
*
|
|
|
|
|
* Read it twice in order to work around a bug in openfirmware.
|
|
|
|
|
* The call to grab this table itself can cause openfirmware to
|
|
|
|
|
* allocate memory, which in turn can take away some space from
|
|
|
|
|
* the list of available memory. Reading it twice makes sure
|
|
|
|
|
* we really do get the final value.
|
|
|
|
|
*/
|
|
|
|
|
read_obp_translations();
|
|
|
|
|
read_obp_memory("reg", &pall[0], &pall_ents);
|
|
|
|
|
read_obp_memory("available", &pavail[0], &pavail_ents);
|
2005-09-30 00:58:26 +00:00
|
|
|
read_obp_memory("available", &pavail[0], &pavail_ents);
|
2005-09-29 04:38:08 +00:00
|
|
|
|
|
|
|
|
phys_base = 0xffffffffffffffffUL;
|
2008-02-14 02:13:20 +00:00
|
|
|
for (i = 0; i < pavail_ents; i++) {
|
2005-09-30 00:58:26 +00:00
|
|
|
phys_base = min(phys_base, pavail[i].phys_addr);
|
2010-07-12 04:36:09 +00:00
|
|
|
memblock_add(pavail[i].phys_addr, pavail[i].reg_size);
|
2008-02-14 02:13:20 +00:00
|
|
|
}
|
|
|
|
|
|
2010-07-12 04:36:09 +00:00
|
|
|
memblock_reserve(kern_base, kern_size);
|
2005-09-29 04:38:08 +00:00
|
|
|
|
2008-02-14 02:00:03 +00:00
|
|
|
find_ramdisk(phys_base);
|
|
|
|
|
|
sparc64: mem boot option correction
The "mem" boot option can result in many unexpected consequences. This patch
attempts to prevent boot hangs which have been experienced on T4-4 and T5-8.
Basically the boot loader allocates vmlinuz and initrd higher in available
OBP physical memory. For example, on a 2Tb T5-8 it isn't possible to boot
with mem=20G.
The patch utilizes memblock to avoid reserved regions and trim memory which
is only free. Other improvements are possible for a multi-node machine.
This is a snippet of the boot log with mem=20G on T5-8 with the patch applied:
MEMBLOCK configuration: <- before memory reduction
memory size = 0x1ffad6ce000 reserved size = 0xa1adf44
memory.cnt = 0xb
memory[0x0] [0x00000030400000-0x00003fdde47fff], 0x3fada48000 bytes
memory[0x1] [0x00003fdde4e000-0x00003fdde4ffff], 0x2000 bytes
memory[0x2] [0x00080000000000-0x00083fffffffff], 0x4000000000 bytes
memory[0x3] [0x00100000000000-0x00103fffffffff], 0x4000000000 bytes
memory[0x4] [0x00180000000000-0x00183fffffffff], 0x4000000000 bytes
memory[0x5] [0x00200000000000-0x00203fffffffff], 0x4000000000 bytes
memory[0x6] [0x00280000000000-0x00283fffffffff], 0x4000000000 bytes
memory[0x7] [0x00300000000000-0x00303fffffffff], 0x4000000000 bytes
memory[0x8] [0x00380000000000-0x00383fffc71fff], 0x3fffc72000 bytes
memory[0x9] [0x00383fffc92000-0x00383fffca1fff], 0x10000 bytes
memory[0xa] [0x00383fffcb4000-0x00383fffcb5fff], 0x2000 bytes
reserved.cnt = 0x2
reserved[0x0] [0x00380000000000-0x0038000117e7f8], 0x117e7f9 bytes
reserved[0x1] [0x00380004000000-0x0038000d02f74a], 0x902f74b bytes
...
MEMBLOCK configuration: <- after reduction of memory
memory size = 0x50a1adf44 reserved size = 0xa1adf44
memory.cnt = 0x4
memory[0x0] [0x00380000000000-0x0038000117e7f8], 0x117e7f9 bytes
memory[0x1] [0x00380004000000-0x0038050d01d74a], 0x50901d74b bytes
memory[0x2] [0x00383fffc92000-0x00383fffca1fff], 0x10000 bytes
memory[0x3] [0x00383fffcb4000-0x00383fffcb5fff], 0x2000 bytes
reserved.cnt = 0x2
reserved[0x0] [0x00380000000000-0x0038000117e7f8], 0x117e7f9 bytes
reserved[0x1] [0x00380004000000-0x0038000d02f74a], 0x902f74b bytes
...
Early memory node ranges
node 7: [mem 0x380000000000-0x38000117dfff]
node 7: [mem 0x380004000000-0x380f0d01bfff]
node 7: [mem 0x383fffc92000-0x383fffca1fff]
node 7: [mem 0x383fffcb4000-0x383fffcb5fff]
Could not find start_pfn for node 0
Could not find start_pfn for node 1
Could not find start_pfn for node 2
Could not find start_pfn for node 3
Could not find start_pfn for node 4
Could not find start_pfn for node 5
Could not find start_pfn for node 6
.
The patch was tested on T4-1, T5-8 and Jalap?no.
Cc: sparclinux@vger.kernel.org
Signed-off-by: Bob Picco <bob.picco@oracle.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-09-16 13:29:54 +00:00
|
|
|
if (cmdline_memory_size)
|
|
|
|
|
reduce_memory(cmdline_memory_size);
|
2008-02-14 02:20:14 +00:00
|
|
|
|
2011-12-08 18:22:08 +00:00
|
|
|
memblock_allow_resize();
|
2010-07-12 04:36:09 +00:00
|
|
|
memblock_dump_all();
|
2008-02-14 02:13:20 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
set_bit(0, mmu_context_bmap);
|
|
|
|
|
|
2005-09-22 08:08:57 +00:00
|
|
|
shift = kern_base + PAGE_OFFSET - ((unsigned long)KERNBASE);
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
real_end = (unsigned long)_end;
|
2014-05-04 05:52:50 +00:00
|
|
|
num_kernel_image_mappings = DIV_ROUND_UP(real_end - KERNBASE, 1 << ILOG2_4MB);
|
2008-03-22 00:01:38 +00:00
|
|
|
printk("Kernel: Using %d locked TLB entries for main kernel image.\n",
|
|
|
|
|
num_kernel_image_mappings);
|
2005-09-22 08:08:57 +00:00
|
|
|
|
|
|
|
|
/* Set kernel pgd to upper alias so physical page computations
|
2005-04-16 22:20:36 +00:00
|
|
|
* work.
|
|
|
|
|
*/
|
|
|
|
|
init_mm.pgd += ((shift) / (sizeof(pgd_t)));
|
|
|
|
|
|
2014-09-28 04:30:57 +00:00
|
|
|
memset(swapper_pg_dir, 0, sizeof(swapper_pg_dir));
|
sparc64: Fix physical memory management regressions with large max_phys_bits.
If max_phys_bits needs to be > 43 (f.e. for T4 chips), things like
DEBUG_PAGEALLOC stop working because the 3-level page tables only
can cover up to 43 bits.
Another problem is that when we increased MAX_PHYS_ADDRESS_BITS up to
47, several statically allocated tables became enormous.
Compounding this is that we will need to support up to 49 bits of
physical addressing for M7 chips.
The two tables in question are sparc64_valid_addr_bitmap and
kpte_linear_bitmap.
The first holds a bitmap, with 1 bit for each 4MB chunk of physical
memory, indicating whether that chunk actually exists in the machine
and is valid.
The second table is a set of 2-bit values which tell how large of a
mapping (4MB, 256MB, 2GB, 16GB, respectively) we can use at each 256MB
chunk of ram in the system.
These tables are huge and take up an enormous amount of the BSS
section of the sparc64 kernel image. Specifically, the
sparc64_valid_addr_bitmap is 4MB, and the kpte_linear_bitmap is 128K.
So let's solve the space wastage and the DEBUG_PAGEALLOC problem
at the same time, by using the kernel page tables (as designed) to
manage this information.
We have to keep using large mappings when DEBUG_PAGEALLOC is disabled,
and we do this by encoding huge PMDs and PUDs.
On a T4-2 with 256GB of ram the kernel page table takes up 16K with
DEBUG_PAGEALLOC disabled and 256MB with it enabled. Furthermore, this
memory is dynamically allocated at run time rather than coded
statically into the kernel image.
Signed-off-by: David S. Miller <davem@davemloft.net>
Acked-by: Bob Picco <bob.picco@oracle.com>
2014-09-25 03:56:11 +00:00
|
|
|
|
2005-10-12 19:22:46 +00:00
|
|
|
inherit_prom_mappings();
|
2005-09-22 07:45:41 +00:00
|
|
|
|
2006-02-01 02:33:37 +00:00
|
|
|
/* Ok, we can use our TLB miss and window trap handlers safely. */
|
|
|
|
|
setup_tba();
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-10-12 19:22:46 +00:00
|
|
|
__flush_tlb_all();
|
2005-10-05 22:12:00 +00:00
|
|
|
|
2008-02-14 03:21:51 +00:00
|
|
|
prom_build_devicetree();
|
2009-05-27 05:37:25 +00:00
|
|
|
of_populate_present_mask();
|
2009-06-18 08:44:19 +00:00
|
|
|
#ifndef CONFIG_SMP
|
|
|
|
|
of_fill_in_cpu_data();
|
|
|
|
|
#endif
|
2008-02-14 03:21:51 +00:00
|
|
|
|
2009-04-01 10:13:15 +00:00
|
|
|
if (tlb_type == hypervisor) {
|
2008-02-14 03:22:23 +00:00
|
|
|
sun4v_mdesc_init();
|
2009-06-15 10:06:18 +00:00
|
|
|
mdesc_populate_present_mask(cpu_all_mask);
|
2009-06-18 08:44:19 +00:00
|
|
|
#ifndef CONFIG_SMP
|
|
|
|
|
mdesc_fill_in_cpu_data(cpu_all_mask);
|
|
|
|
|
#endif
|
2012-09-07 02:01:25 +00:00
|
|
|
mdesc_get_page_sizes(cpu_all_mask, &cpu_pgsz_mask);
|
2012-09-07 03:35:36 +00:00
|
|
|
|
|
|
|
|
sun4v_linear_pte_xor_finalize();
|
|
|
|
|
|
|
|
|
|
sun4v_ktsb_init();
|
|
|
|
|
sun4v_ktsb_register();
|
2012-09-07 02:01:25 +00:00
|
|
|
} else {
|
|
|
|
|
unsigned long impl, ver;
|
|
|
|
|
|
|
|
|
|
cpu_pgsz_mask = (HV_PGSZ_MASK_8K | HV_PGSZ_MASK_64K |
|
|
|
|
|
HV_PGSZ_MASK_512K | HV_PGSZ_MASK_4MB);
|
|
|
|
|
|
|
|
|
|
__asm__ __volatile__("rdpr %%ver, %0" : "=r" (ver));
|
|
|
|
|
impl = ((ver >> 32) & 0xffff);
|
|
|
|
|
if (impl == PANTHER_IMPL)
|
|
|
|
|
cpu_pgsz_mask |= (HV_PGSZ_MASK_32MB |
|
|
|
|
|
HV_PGSZ_MASK_256MB);
|
2012-09-07 03:35:36 +00:00
|
|
|
|
|
|
|
|
sun4u_linear_pte_xor_finalize();
|
2009-04-01 10:13:15 +00:00
|
|
|
}
|
2008-02-14 03:22:23 +00:00
|
|
|
|
2012-09-07 03:35:36 +00:00
|
|
|
/* Flush the TLBs and the 4M TSB so that the updated linear
|
|
|
|
|
* pte XOR settings are realized for all mappings.
|
|
|
|
|
*/
|
|
|
|
|
__flush_tlb_all();
|
|
|
|
|
#ifndef CONFIG_DEBUG_PAGEALLOC
|
|
|
|
|
memset(swapper_4m_tsb, 0x40, sizeof(swapper_4m_tsb));
|
|
|
|
|
#endif
|
|
|
|
|
__flush_tlb_all();
|
|
|
|
|
|
2012-04-27 03:50:34 +00:00
|
|
|
/* Setup bootmem... */
|
|
|
|
|
last_valid_pfn = end_pfn = bootmem_init(phys_base);
|
|
|
|
|
|
2005-09-25 23:46:57 +00:00
|
|
|
kernel_physical_mapping_init();
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-04-23 12:40:25 +00:00
|
|
|
unsigned long max_zone_pfns[MAX_NR_ZONES];
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-23 12:40:25 +00:00
|
|
|
memset(max_zone_pfns, 0, sizeof(max_zone_pfns));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-23 12:40:25 +00:00
|
|
|
max_zone_pfns[ZONE_NORMAL] = end_pfn;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2020-06-03 22:57:10 +00:00
|
|
|
free_area_init(max_zone_pfns);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
2008-02-18 07:22:50 +00:00
|
|
|
printk("Booting Linux...\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
2012-12-21 22:03:26 +00:00
|
|
|
int page_in_phys_avail(unsigned long paddr)
|
2008-04-23 12:40:25 +00:00
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
paddr &= PAGE_MASK;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < pavail_ents; i++) {
|
|
|
|
|
unsigned long start, end;
|
|
|
|
|
|
|
|
|
|
start = pavail[i].phys_addr;
|
|
|
|
|
end = start + pavail[i].reg_size;
|
|
|
|
|
|
|
|
|
|
if (paddr >= start && paddr < end)
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
if (paddr >= kern_base && paddr < (kern_base + kern_size))
|
|
|
|
|
return 1;
|
|
|
|
|
#ifdef CONFIG_BLK_DEV_INITRD
|
|
|
|
|
if (paddr >= __pa(initrd_start) &&
|
|
|
|
|
paddr < __pa(PAGE_ALIGN(initrd_end)))
|
|
|
|
|
return 1;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-17 03:39:21 +00:00
|
|
|
static void __init register_page_bootmem_info(void)
|
|
|
|
|
{
|
2021-06-29 02:43:01 +00:00
|
|
|
#ifdef CONFIG_NUMA
|
2012-11-17 03:39:21 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for_each_online_node(i)
|
|
|
|
|
if (NODE_DATA(i)->node_spanned_pages)
|
|
|
|
|
register_page_bootmem_info_node(NODE_DATA(i));
|
|
|
|
|
#endif
|
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
void __init mem_init(void)
|
|
|
|
|
{
|
|
|
|
|
high_memory = __va(last_valid_pfn << PAGE_SHIFT);
|
|
|
|
|
|
2018-10-30 22:09:30 +00:00
|
|
|
memblock_free_all();
|
2008-04-23 12:40:25 +00:00
|
|
|
|
2017-11-16 01:36:18 +00:00
|
|
|
/*
|
|
|
|
|
* Must be done after boot memory is put on freelist, because here we
|
|
|
|
|
* might set fields in deferred struct pages that have not yet been
|
2018-10-30 22:09:30 +00:00
|
|
|
* initialized, and memblock_free_all() initializes all the reserved
|
2017-11-16 01:36:18 +00:00
|
|
|
* deferred pages for us.
|
|
|
|
|
*/
|
|
|
|
|
register_page_bootmem_info();
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* Set up the zero page, mark it reserved, so that page count
|
|
|
|
|
* is not manipulated when freeing the page from user ptes.
|
|
|
|
|
*/
|
|
|
|
|
mem_map_zero = alloc_pages(GFP_KERNEL|__GFP_ZERO, 0);
|
|
|
|
|
if (mem_map_zero == NULL) {
|
|
|
|
|
prom_printf("paging_init: Cannot alloc zero page.\n");
|
|
|
|
|
prom_halt();
|
|
|
|
|
}
|
2013-05-07 23:18:08 +00:00
|
|
|
mark_page_reserved(mem_map_zero);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
if (tlb_type == cheetah || tlb_type == cheetah_plus)
|
|
|
|
|
cheetah_ecache_flush_init();
|
|
|
|
|
}
|
|
|
|
|
|
2005-09-23 18:59:44 +00:00
|
|
|
void free_initmem(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
|
unsigned long addr, initend;
|
2008-08-14 08:45:41 +00:00
|
|
|
int do_free = 1;
|
|
|
|
|
|
|
|
|
|
/* If the physical memory maps were trimmed by kernel command
|
|
|
|
|
* line options, don't even try freeing this initmem stuff up.
|
|
|
|
|
* The kernel image could have been in the trimmed out region
|
|
|
|
|
* and if so the freeing below will free invalid page structs.
|
|
|
|
|
*/
|
|
|
|
|
if (cmdline_memory_size)
|
|
|
|
|
do_free = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* The init section is aligned to 8k in vmlinux.lds. Page align for >8k pagesizes.
|
|
|
|
|
*/
|
|
|
|
|
addr = PAGE_ALIGN((unsigned long)(__init_begin));
|
|
|
|
|
initend = (unsigned long)(__init_end) & PAGE_MASK;
|
|
|
|
|
for (; addr < initend; addr += PAGE_SIZE) {
|
|
|
|
|
unsigned long page;
|
|
|
|
|
|
|
|
|
|
page = (addr +
|
|
|
|
|
((unsigned long) __va(kern_base)) -
|
|
|
|
|
((unsigned long) KERNBASE));
|
2006-06-27 09:53:52 +00:00
|
|
|
memset((void *)addr, POISON_FREE_INITMEM, PAGE_SIZE);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-05-07 23:18:08 +00:00
|
|
|
if (do_free)
|
|
|
|
|
free_reserved_page(virt_to_page(page));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-02-12 05:57:54 +00:00
|
|
|
pgprot_t PAGE_KERNEL __read_mostly;
|
|
|
|
|
EXPORT_SYMBOL(PAGE_KERNEL);
|
|
|
|
|
|
|
|
|
|
pgprot_t PAGE_KERNEL_LOCKED __read_mostly;
|
|
|
|
|
pgprot_t PAGE_COPY __read_mostly;
|
2006-02-18 20:43:16 +00:00
|
|
|
|
|
|
|
|
pgprot_t PAGE_SHARED __read_mostly;
|
|
|
|
|
EXPORT_SYMBOL(PAGE_SHARED);
|
|
|
|
|
|
2006-02-12 05:57:54 +00:00
|
|
|
unsigned long pg_iobits __read_mostly;
|
|
|
|
|
|
|
|
|
|
unsigned long _PAGE_IE __read_mostly;
|
2006-06-25 08:34:43 +00:00
|
|
|
EXPORT_SYMBOL(_PAGE_IE);
|
2006-02-23 09:55:55 +00:00
|
|
|
|
2006-02-12 05:57:54 +00:00
|
|
|
unsigned long _PAGE_E __read_mostly;
|
2006-02-23 09:55:55 +00:00
|
|
|
EXPORT_SYMBOL(_PAGE_E);
|
|
|
|
|
|
2006-02-12 05:57:54 +00:00
|
|
|
unsigned long _PAGE_CACHE __read_mostly;
|
2006-02-23 09:55:55 +00:00
|
|
|
EXPORT_SYMBOL(_PAGE_CACHE);
|
2006-02-12 05:57:54 +00:00
|
|
|
|
2007-10-16 08:24:16 +00:00
|
|
|
#ifdef CONFIG_SPARSEMEM_VMEMMAP
|
2013-04-29 22:07:50 +00:00
|
|
|
int __meminit vmemmap_populate(unsigned long vstart, unsigned long vend,
|
2017-12-29 07:53:54 +00:00
|
|
|
int node, struct vmem_altmap *altmap)
|
2007-10-16 08:24:16 +00:00
|
|
|
{
|
|
|
|
|
unsigned long pte_base;
|
|
|
|
|
|
|
|
|
|
pte_base = (_PAGE_VALID | _PAGE_SZ4MB_4U |
|
|
|
|
|
_PAGE_CP_4U | _PAGE_CV_4U |
|
|
|
|
|
_PAGE_P_4U | _PAGE_W_4U);
|
|
|
|
|
if (tlb_type == hypervisor)
|
|
|
|
|
pte_base = (_PAGE_VALID | _PAGE_SZ4MB_4V |
|
2015-05-27 16:00:46 +00:00
|
|
|
page_cache4v_flag | _PAGE_P_4V | _PAGE_W_4V);
|
2007-10-16 08:24:16 +00:00
|
|
|
|
2014-09-25 04:20:14 +00:00
|
|
|
pte_base |= _PAGE_PMD_HUGE;
|
2007-10-16 08:24:16 +00:00
|
|
|
|
2014-09-25 04:20:14 +00:00
|
|
|
vstart = vstart & PMD_MASK;
|
|
|
|
|
vend = ALIGN(vend, PMD_SIZE);
|
|
|
|
|
for (; vstart < vend; vstart += PMD_SIZE) {
|
2017-11-16 01:36:22 +00:00
|
|
|
pgd_t *pgd = vmemmap_pgd_populate(vstart, node);
|
2014-09-25 04:20:14 +00:00
|
|
|
unsigned long pte;
|
2019-11-24 08:57:20 +00:00
|
|
|
p4d_t *p4d;
|
2014-09-25 04:20:14 +00:00
|
|
|
pud_t *pud;
|
|
|
|
|
pmd_t *pmd;
|
|
|
|
|
|
2017-11-16 01:36:22 +00:00
|
|
|
if (!pgd)
|
|
|
|
|
return -ENOMEM;
|
2014-09-25 04:20:14 +00:00
|
|
|
|
2019-11-24 08:57:20 +00:00
|
|
|
p4d = vmemmap_p4d_populate(pgd, vstart, node);
|
|
|
|
|
if (!p4d)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
pud = vmemmap_pud_populate(p4d, vstart, node);
|
2017-11-16 01:36:22 +00:00
|
|
|
if (!pud)
|
|
|
|
|
return -ENOMEM;
|
2012-08-15 07:37:29 +00:00
|
|
|
|
2014-09-25 04:20:14 +00:00
|
|
|
pmd = pmd_offset(pud, vstart);
|
|
|
|
|
pte = pmd_val(*pmd);
|
|
|
|
|
if (!(pte & _PAGE_VALID)) {
|
|
|
|
|
void *block = vmemmap_alloc_block(PMD_SIZE, node);
|
|
|
|
|
|
|
|
|
|
if (!block)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
pmd_val(*pmd) = pte_base | __pa(block);
|
|
|
|
|
}
|
2012-08-15 07:37:29 +00:00
|
|
|
}
|
2014-09-25 04:20:14 +00:00
|
|
|
|
|
|
|
|
return 0;
|
2012-08-15 07:37:29 +00:00
|
|
|
}
|
2013-02-23 00:33:00 +00:00
|
|
|
|
2017-12-29 07:53:56 +00:00
|
|
|
void vmemmap_free(unsigned long start, unsigned long end,
|
|
|
|
|
struct vmem_altmap *altmap)
|
2013-02-23 00:33:08 +00:00
|
|
|
{
|
|
|
|
|
}
|
2007-10-16 08:24:16 +00:00
|
|
|
#endif /* CONFIG_SPARSEMEM_VMEMMAP */
|
|
|
|
|
|
2006-02-12 05:57:54 +00:00
|
|
|
static void prot_init_common(unsigned long page_none,
|
|
|
|
|
unsigned long page_shared,
|
|
|
|
|
unsigned long page_copy,
|
|
|
|
|
unsigned long page_readonly,
|
|
|
|
|
unsigned long page_exec_bit)
|
|
|
|
|
{
|
|
|
|
|
PAGE_COPY = __pgprot(page_copy);
|
2006-02-18 20:43:16 +00:00
|
|
|
PAGE_SHARED = __pgprot(page_shared);
|
2006-02-12 05:57:54 +00:00
|
|
|
|
|
|
|
|
protection_map[0x0] = __pgprot(page_none);
|
|
|
|
|
protection_map[0x1] = __pgprot(page_readonly & ~page_exec_bit);
|
|
|
|
|
protection_map[0x2] = __pgprot(page_copy & ~page_exec_bit);
|
|
|
|
|
protection_map[0x3] = __pgprot(page_copy & ~page_exec_bit);
|
|
|
|
|
protection_map[0x4] = __pgprot(page_readonly);
|
|
|
|
|
protection_map[0x5] = __pgprot(page_readonly);
|
|
|
|
|
protection_map[0x6] = __pgprot(page_copy);
|
|
|
|
|
protection_map[0x7] = __pgprot(page_copy);
|
|
|
|
|
protection_map[0x8] = __pgprot(page_none);
|
|
|
|
|
protection_map[0x9] = __pgprot(page_readonly & ~page_exec_bit);
|
|
|
|
|
protection_map[0xa] = __pgprot(page_shared & ~page_exec_bit);
|
|
|
|
|
protection_map[0xb] = __pgprot(page_shared & ~page_exec_bit);
|
|
|
|
|
protection_map[0xc] = __pgprot(page_readonly);
|
|
|
|
|
protection_map[0xd] = __pgprot(page_readonly);
|
|
|
|
|
protection_map[0xe] = __pgprot(page_shared);
|
|
|
|
|
protection_map[0xf] = __pgprot(page_shared);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void __init sun4u_pgprot_init(void)
|
|
|
|
|
{
|
|
|
|
|
unsigned long page_none, page_shared, page_copy, page_readonly;
|
|
|
|
|
unsigned long page_exec_bit;
|
2012-09-07 01:13:58 +00:00
|
|
|
int i;
|
2006-02-12 05:57:54 +00:00
|
|
|
|
|
|
|
|
PAGE_KERNEL = __pgprot (_PAGE_PRESENT_4U | _PAGE_VALID |
|
|
|
|
|
_PAGE_CACHE_4U | _PAGE_P_4U |
|
|
|
|
|
__ACCESS_BITS_4U | __DIRTY_BITS_4U |
|
|
|
|
|
_PAGE_EXEC_4U);
|
|
|
|
|
PAGE_KERNEL_LOCKED = __pgprot (_PAGE_PRESENT_4U | _PAGE_VALID |
|
|
|
|
|
_PAGE_CACHE_4U | _PAGE_P_4U |
|
|
|
|
|
__ACCESS_BITS_4U | __DIRTY_BITS_4U |
|
|
|
|
|
_PAGE_EXEC_4U | _PAGE_L_4U);
|
|
|
|
|
|
|
|
|
|
_PAGE_IE = _PAGE_IE_4U;
|
|
|
|
|
_PAGE_E = _PAGE_E_4U;
|
|
|
|
|
_PAGE_CACHE = _PAGE_CACHE_4U;
|
|
|
|
|
|
|
|
|
|
pg_iobits = (_PAGE_VALID | _PAGE_PRESENT_4U | __DIRTY_BITS_4U |
|
|
|
|
|
__ACCESS_BITS_4U | _PAGE_E_4U);
|
|
|
|
|
|
2007-03-17 00:20:28 +00:00
|
|
|
#ifdef CONFIG_DEBUG_PAGEALLOC
|
2013-09-18 19:00:00 +00:00
|
|
|
kern_linear_pte_xor[0] = _PAGE_VALID ^ PAGE_OFFSET;
|
2007-03-17 00:20:28 +00:00
|
|
|
#else
|
2006-02-22 04:51:13 +00:00
|
|
|
kern_linear_pte_xor[0] = (_PAGE_VALID | _PAGE_SZ4MB_4U) ^
|
2013-09-18 19:00:00 +00:00
|
|
|
PAGE_OFFSET;
|
2007-03-17 00:20:28 +00:00
|
|
|
#endif
|
2006-02-22 04:51:13 +00:00
|
|
|
kern_linear_pte_xor[0] |= (_PAGE_CP_4U | _PAGE_CV_4U |
|
|
|
|
|
_PAGE_P_4U | _PAGE_W_4U);
|
|
|
|
|
|
2012-09-07 01:13:58 +00:00
|
|
|
for (i = 1; i < 4; i++)
|
|
|
|
|
kern_linear_pte_xor[i] = kern_linear_pte_xor[0];
|
2006-02-12 05:57:54 +00:00
|
|
|
|
|
|
|
|
_PAGE_ALL_SZ_BITS = (_PAGE_SZ4MB_4U | _PAGE_SZ512K_4U |
|
|
|
|
|
_PAGE_SZ64K_4U | _PAGE_SZ8K_4U |
|
|
|
|
|
_PAGE_SZ32MB_4U | _PAGE_SZ256MB_4U);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
page_none = _PAGE_PRESENT_4U | _PAGE_ACCESSED_4U | _PAGE_CACHE_4U;
|
|
|
|
|
page_shared = (_PAGE_VALID | _PAGE_PRESENT_4U | _PAGE_CACHE_4U |
|
|
|
|
|
__ACCESS_BITS_4U | _PAGE_WRITE_4U | _PAGE_EXEC_4U);
|
|
|
|
|
page_copy = (_PAGE_VALID | _PAGE_PRESENT_4U | _PAGE_CACHE_4U |
|
|
|
|
|
__ACCESS_BITS_4U | _PAGE_EXEC_4U);
|
|
|
|
|
page_readonly = (_PAGE_VALID | _PAGE_PRESENT_4U | _PAGE_CACHE_4U |
|
|
|
|
|
__ACCESS_BITS_4U | _PAGE_EXEC_4U);
|
|
|
|
|
|
|
|
|
|
page_exec_bit = _PAGE_EXEC_4U;
|
|
|
|
|
|
|
|
|
|
prot_init_common(page_none, page_shared, page_copy, page_readonly,
|
|
|
|
|
page_exec_bit);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void __init sun4v_pgprot_init(void)
|
|
|
|
|
{
|
|
|
|
|
unsigned long page_none, page_shared, page_copy, page_readonly;
|
|
|
|
|
unsigned long page_exec_bit;
|
2012-09-07 01:13:58 +00:00
|
|
|
int i;
|
2006-02-12 05:57:54 +00:00
|
|
|
|
|
|
|
|
PAGE_KERNEL = __pgprot (_PAGE_PRESENT_4V | _PAGE_VALID |
|
2015-05-27 16:00:46 +00:00
|
|
|
page_cache4v_flag | _PAGE_P_4V |
|
2006-02-12 05:57:54 +00:00
|
|
|
__ACCESS_BITS_4V | __DIRTY_BITS_4V |
|
|
|
|
|
_PAGE_EXEC_4V);
|
|
|
|
|
PAGE_KERNEL_LOCKED = PAGE_KERNEL;
|
|
|
|
|
|
|
|
|
|
_PAGE_IE = _PAGE_IE_4V;
|
|
|
|
|
_PAGE_E = _PAGE_E_4V;
|
2015-05-27 16:00:46 +00:00
|
|
|
_PAGE_CACHE = page_cache4v_flag;
|
2006-02-12 05:57:54 +00:00
|
|
|
|
2007-03-17 00:20:28 +00:00
|
|
|
#ifdef CONFIG_DEBUG_PAGEALLOC
|
2013-09-18 19:00:00 +00:00
|
|
|
kern_linear_pte_xor[0] = _PAGE_VALID ^ PAGE_OFFSET;
|
2007-03-17 00:20:28 +00:00
|
|
|
#else
|
2006-02-22 04:51:13 +00:00
|
|
|
kern_linear_pte_xor[0] = (_PAGE_VALID | _PAGE_SZ4MB_4V) ^
|
2013-09-18 19:00:00 +00:00
|
|
|
PAGE_OFFSET;
|
2007-03-17 00:20:28 +00:00
|
|
|
#endif
|
2015-05-27 16:00:46 +00:00
|
|
|
kern_linear_pte_xor[0] |= (page_cache4v_flag | _PAGE_P_4V |
|
|
|
|
|
_PAGE_W_4V);
|
2006-02-22 04:51:13 +00:00
|
|
|
|
2012-09-07 03:35:36 +00:00
|
|
|
for (i = 1; i < 4; i++)
|
|
|
|
|
kern_linear_pte_xor[i] = kern_linear_pte_xor[0];
|
2012-09-07 01:13:58 +00:00
|
|
|
|
2006-02-12 05:57:54 +00:00
|
|
|
pg_iobits = (_PAGE_VALID | _PAGE_PRESENT_4V | __DIRTY_BITS_4V |
|
|
|
|
|
__ACCESS_BITS_4V | _PAGE_E_4V);
|
|
|
|
|
|
|
|
|
|
_PAGE_ALL_SZ_BITS = (_PAGE_SZ16GB_4V | _PAGE_SZ2GB_4V |
|
|
|
|
|
_PAGE_SZ256MB_4V | _PAGE_SZ32MB_4V |
|
|
|
|
|
_PAGE_SZ4MB_4V | _PAGE_SZ512K_4V |
|
|
|
|
|
_PAGE_SZ64K_4V | _PAGE_SZ8K_4V);
|
|
|
|
|
|
2015-05-27 16:00:46 +00:00
|
|
|
page_none = _PAGE_PRESENT_4V | _PAGE_ACCESSED_4V | page_cache4v_flag;
|
|
|
|
|
page_shared = (_PAGE_VALID | _PAGE_PRESENT_4V | page_cache4v_flag |
|
2006-02-12 05:57:54 +00:00
|
|
|
__ACCESS_BITS_4V | _PAGE_WRITE_4V | _PAGE_EXEC_4V);
|
2015-05-27 16:00:46 +00:00
|
|
|
page_copy = (_PAGE_VALID | _PAGE_PRESENT_4V | page_cache4v_flag |
|
2006-02-12 05:57:54 +00:00
|
|
|
__ACCESS_BITS_4V | _PAGE_EXEC_4V);
|
2015-05-27 16:00:46 +00:00
|
|
|
page_readonly = (_PAGE_VALID | _PAGE_PRESENT_4V | page_cache4v_flag |
|
2006-02-12 05:57:54 +00:00
|
|
|
__ACCESS_BITS_4V | _PAGE_EXEC_4V);
|
|
|
|
|
|
|
|
|
|
page_exec_bit = _PAGE_EXEC_4V;
|
|
|
|
|
|
|
|
|
|
prot_init_common(page_none, page_shared, page_copy, page_readonly,
|
|
|
|
|
page_exec_bit);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
unsigned long pte_sz_bits(unsigned long sz)
|
|
|
|
|
{
|
|
|
|
|
if (tlb_type == hypervisor) {
|
|
|
|
|
switch (sz) {
|
|
|
|
|
case 8 * 1024:
|
|
|
|
|
default:
|
|
|
|
|
return _PAGE_SZ8K_4V;
|
|
|
|
|
case 64 * 1024:
|
|
|
|
|
return _PAGE_SZ64K_4V;
|
|
|
|
|
case 512 * 1024:
|
|
|
|
|
return _PAGE_SZ512K_4V;
|
|
|
|
|
case 4 * 1024 * 1024:
|
|
|
|
|
return _PAGE_SZ4MB_4V;
|
2011-06-03 14:45:23 +00:00
|
|
|
}
|
2006-02-12 05:57:54 +00:00
|
|
|
} else {
|
|
|
|
|
switch (sz) {
|
|
|
|
|
case 8 * 1024:
|
|
|
|
|
default:
|
|
|
|
|
return _PAGE_SZ8K_4U;
|
|
|
|
|
case 64 * 1024:
|
|
|
|
|
return _PAGE_SZ64K_4U;
|
|
|
|
|
case 512 * 1024:
|
|
|
|
|
return _PAGE_SZ512K_4U;
|
|
|
|
|
case 4 * 1024 * 1024:
|
|
|
|
|
return _PAGE_SZ4MB_4U;
|
2011-06-03 14:45:23 +00:00
|
|
|
}
|
2006-02-12 05:57:54 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pte_t mk_pte_io(unsigned long page, pgprot_t prot, int space, unsigned long page_size)
|
|
|
|
|
{
|
|
|
|
|
pte_t pte;
|
2006-02-13 05:10:07 +00:00
|
|
|
|
|
|
|
|
pte_val(pte) = page | pgprot_val(pgprot_noncached(prot));
|
2006-02-12 05:57:54 +00:00
|
|
|
pte_val(pte) |= (((unsigned long)space) << 32);
|
|
|
|
|
pte_val(pte) |= pte_sz_bits(page_size);
|
|
|
|
|
|
2006-02-13 05:10:07 +00:00
|
|
|
return pte;
|
2006-02-12 05:57:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static unsigned long kern_large_tte(unsigned long paddr)
|
|
|
|
|
{
|
|
|
|
|
unsigned long val;
|
|
|
|
|
|
|
|
|
|
val = (_PAGE_VALID | _PAGE_SZ4MB_4U |
|
|
|
|
|
_PAGE_CP_4U | _PAGE_CV_4U | _PAGE_P_4U |
|
|
|
|
|
_PAGE_EXEC_4U | _PAGE_L_4U | _PAGE_W_4U);
|
|
|
|
|
if (tlb_type == hypervisor)
|
|
|
|
|
val = (_PAGE_VALID | _PAGE_SZ4MB_4V |
|
2015-05-27 16:00:46 +00:00
|
|
|
page_cache4v_flag | _PAGE_P_4V |
|
2006-02-12 05:57:54 +00:00
|
|
|
_PAGE_EXEC_4V | _PAGE_W_4V);
|
|
|
|
|
|
|
|
|
|
return val | paddr;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If not locked, zap it. */
|
|
|
|
|
void __flush_tlb_all(void)
|
|
|
|
|
{
|
|
|
|
|
unsigned long pstate;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
__asm__ __volatile__("flushw\n\t"
|
|
|
|
|
"rdpr %%pstate, %0\n\t"
|
|
|
|
|
"wrpr %0, %1, %%pstate"
|
|
|
|
|
: "=r" (pstate)
|
|
|
|
|
: "i" (PSTATE_IE));
|
2007-12-13 14:13:38 +00:00
|
|
|
if (tlb_type == hypervisor) {
|
|
|
|
|
sun4v_mmu_demap_all();
|
|
|
|
|
} else if (tlb_type == spitfire) {
|
2006-02-12 05:57:54 +00:00
|
|
|
for (i = 0; i < 64; i++) {
|
|
|
|
|
/* Spitfire Errata #32 workaround */
|
|
|
|
|
/* NOTE: Always runs on spitfire, so no
|
|
|
|
|
* cheetah+ page size encodings.
|
|
|
|
|
*/
|
|
|
|
|
__asm__ __volatile__("stxa %0, [%1] %2\n\t"
|
|
|
|
|
"flush %%g6"
|
|
|
|
|
: /* No outputs */
|
|
|
|
|
: "r" (0),
|
|
|
|
|
"r" (PRIMARY_CONTEXT), "i" (ASI_DMMU));
|
|
|
|
|
|
|
|
|
|
if (!(spitfire_get_dtlb_data(i) & _PAGE_L_4U)) {
|
|
|
|
|
__asm__ __volatile__("stxa %%g0, [%0] %1\n\t"
|
|
|
|
|
"membar #Sync"
|
|
|
|
|
: /* no outputs */
|
|
|
|
|
: "r" (TLB_TAG_ACCESS), "i" (ASI_DMMU));
|
|
|
|
|
spitfire_put_dtlb_data(i, 0x0UL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Spitfire Errata #32 workaround */
|
|
|
|
|
/* NOTE: Always runs on spitfire, so no
|
|
|
|
|
* cheetah+ page size encodings.
|
|
|
|
|
*/
|
|
|
|
|
__asm__ __volatile__("stxa %0, [%1] %2\n\t"
|
|
|
|
|
"flush %%g6"
|
|
|
|
|
: /* No outputs */
|
|
|
|
|
: "r" (0),
|
|
|
|
|
"r" (PRIMARY_CONTEXT), "i" (ASI_DMMU));
|
|
|
|
|
|
|
|
|
|
if (!(spitfire_get_itlb_data(i) & _PAGE_L_4U)) {
|
|
|
|
|
__asm__ __volatile__("stxa %%g0, [%0] %1\n\t"
|
|
|
|
|
"membar #Sync"
|
|
|
|
|
: /* no outputs */
|
|
|
|
|
: "r" (TLB_TAG_ACCESS), "i" (ASI_IMMU));
|
|
|
|
|
spitfire_put_itlb_data(i, 0x0UL);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} else if (tlb_type == cheetah || tlb_type == cheetah_plus) {
|
|
|
|
|
cheetah_flush_dtlb_all();
|
|
|
|
|
cheetah_flush_itlb_all();
|
|
|
|
|
}
|
|
|
|
|
__asm__ __volatile__("wrpr %0, 0, %%pstate"
|
|
|
|
|
: : "r" (pstate));
|
|
|
|
|
}
|
2012-10-08 23:34:22 +00:00
|
|
|
|
mm: treewide: remove unused address argument from pte_alloc functions
Patch series "Add support for fast mremap".
This series speeds up the mremap(2) syscall by copying page tables at
the PMD level even for non-THP systems. There is concern that the extra
'address' argument that mremap passes to pte_alloc may do something
subtle architecture related in the future that may make the scheme not
work. Also we find that there is no point in passing the 'address' to
pte_alloc since its unused. This patch therefore removes this argument
tree-wide resulting in a nice negative diff as well. Also ensuring
along the way that the enabled architectures do not do anything funky
with the 'address' argument that goes unnoticed by the optimization.
Build and boot tested on x86-64. Build tested on arm64. The config
enablement patch for arm64 will be posted in the future after more
testing.
The changes were obtained by applying the following Coccinelle script.
(thanks Julia for answering all Coccinelle questions!).
Following fix ups were done manually:
* Removal of address argument from pte_fragment_alloc
* Removal of pte_alloc_one_fast definitions from m68k and microblaze.
// Options: --include-headers --no-includes
// Note: I split the 'identifier fn' line, so if you are manually
// running it, please unsplit it so it runs for you.
virtual patch
@pte_alloc_func_def depends on patch exists@
identifier E2;
identifier fn =~
"^(__pte_alloc|pte_alloc_one|pte_alloc|__pte_alloc_kernel|pte_alloc_one_kernel)$";
type T2;
@@
fn(...
- , T2 E2
)
{ ... }
@pte_alloc_func_proto_noarg depends on patch exists@
type T1, T2, T3, T4;
identifier fn =~ "^(__pte_alloc|pte_alloc_one|pte_alloc|__pte_alloc_kernel|pte_alloc_one_kernel)$";
@@
(
- T3 fn(T1, T2);
+ T3 fn(T1);
|
- T3 fn(T1, T2, T4);
+ T3 fn(T1, T2);
)
@pte_alloc_func_proto depends on patch exists@
identifier E1, E2, E4;
type T1, T2, T3, T4;
identifier fn =~
"^(__pte_alloc|pte_alloc_one|pte_alloc|__pte_alloc_kernel|pte_alloc_one_kernel)$";
@@
(
- T3 fn(T1 E1, T2 E2);
+ T3 fn(T1 E1);
|
- T3 fn(T1 E1, T2 E2, T4 E4);
+ T3 fn(T1 E1, T2 E2);
)
@pte_alloc_func_call depends on patch exists@
expression E2;
identifier fn =~
"^(__pte_alloc|pte_alloc_one|pte_alloc|__pte_alloc_kernel|pte_alloc_one_kernel)$";
@@
fn(...
-, E2
)
@pte_alloc_macro depends on patch exists@
identifier fn =~
"^(__pte_alloc|pte_alloc_one|pte_alloc|__pte_alloc_kernel|pte_alloc_one_kernel)$";
identifier a, b, c;
expression e;
position p;
@@
(
- #define fn(a, b, c) e
+ #define fn(a, b) e
|
- #define fn(a, b) e
+ #define fn(a) e
)
Link: http://lkml.kernel.org/r/20181108181201.88826-2-joelaf@google.com
Signed-off-by: Joel Fernandes (Google) <joel@joelfernandes.org>
Suggested-by: Kirill A. Shutemov <kirill@shutemov.name>
Acked-by: Kirill A. Shutemov <kirill@shutemov.name>
Cc: Michal Hocko <mhocko@kernel.org>
Cc: Julia Lawall <Julia.Lawall@lip6.fr>
Cc: Kirill A. Shutemov <kirill@shutemov.name>
Cc: William Kucharski <william.kucharski@oracle.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2019-01-03 23:28:34 +00:00
|
|
|
pte_t *pte_alloc_one_kernel(struct mm_struct *mm)
|
2012-10-08 23:34:22 +00:00
|
|
|
{
|
2017-11-16 01:35:54 +00:00
|
|
|
struct page *page = alloc_page(GFP_KERNEL | __GFP_ZERO);
|
sparc64: Move from 4MB to 8MB huge pages.
The impetus for this is that we would like to move to 64-bit PMDs and
PGDs, but that would result in only supporting a 42-bit address space
with the current page table layout. It'd be nice to support at least
43-bits.
The reason we'd end up with only 42-bits after making PMDs and PGDs
64-bit is that we only use half-page sized PTE tables in order to make
PMDs line up to 4MB, the hardware huge page size we use.
So what we do here is we make huge pages 8MB, and fabricate them using
4MB hw TLB entries.
Facilitate this by providing a "REAL_HPAGE_SHIFT" which is used in
places that really need to operate on hardware 4MB pages.
Use full pages (512 entries) for PTE tables, and adjust PMD_SHIFT,
PGD_SHIFT, and the build time CPP test as needed. Use a CPP test to
make sure REAL_HPAGE_SHIFT and the _PAGE_SZHUGE_* we use match up.
This makes the pgtable cache completely unused, so remove the code
managing it and the state used in mm_context_t. Now we have less
spinlocks taken in the page table allocation path.
The technique we use to fabricate the 8MB pages is to transfer bit 22
from the missing virtual address into the PTEs physical address field.
That takes care of the transparent huge pages case.
For hugetlb, we fill things in at the PTE level and that code already
puts the sub huge page physical bits into the PTEs, based upon the
offset, so there is nothing special we need to do. It all just works
out.
So, a small amount of complexity in the THP case, but this code is
about to get much simpler when we move the 64-bit PMDs as we can move
away from the fancy 32-bit huge PMD encoding and just put a real PTE
value in there.
With bug fixes and help from Bob Picco.
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-09-25 20:48:49 +00:00
|
|
|
pte_t *pte = NULL;
|
2012-10-08 23:34:22 +00:00
|
|
|
|
|
|
|
|
if (page)
|
|
|
|
|
pte = (pte_t *) page_address(page);
|
|
|
|
|
|
|
|
|
|
return pte;
|
|
|
|
|
}
|
|
|
|
|
|
mm: treewide: remove unused address argument from pte_alloc functions
Patch series "Add support for fast mremap".
This series speeds up the mremap(2) syscall by copying page tables at
the PMD level even for non-THP systems. There is concern that the extra
'address' argument that mremap passes to pte_alloc may do something
subtle architecture related in the future that may make the scheme not
work. Also we find that there is no point in passing the 'address' to
pte_alloc since its unused. This patch therefore removes this argument
tree-wide resulting in a nice negative diff as well. Also ensuring
along the way that the enabled architectures do not do anything funky
with the 'address' argument that goes unnoticed by the optimization.
Build and boot tested on x86-64. Build tested on arm64. The config
enablement patch for arm64 will be posted in the future after more
testing.
The changes were obtained by applying the following Coccinelle script.
(thanks Julia for answering all Coccinelle questions!).
Following fix ups were done manually:
* Removal of address argument from pte_fragment_alloc
* Removal of pte_alloc_one_fast definitions from m68k and microblaze.
// Options: --include-headers --no-includes
// Note: I split the 'identifier fn' line, so if you are manually
// running it, please unsplit it so it runs for you.
virtual patch
@pte_alloc_func_def depends on patch exists@
identifier E2;
identifier fn =~
"^(__pte_alloc|pte_alloc_one|pte_alloc|__pte_alloc_kernel|pte_alloc_one_kernel)$";
type T2;
@@
fn(...
- , T2 E2
)
{ ... }
@pte_alloc_func_proto_noarg depends on patch exists@
type T1, T2, T3, T4;
identifier fn =~ "^(__pte_alloc|pte_alloc_one|pte_alloc|__pte_alloc_kernel|pte_alloc_one_kernel)$";
@@
(
- T3 fn(T1, T2);
+ T3 fn(T1);
|
- T3 fn(T1, T2, T4);
+ T3 fn(T1, T2);
)
@pte_alloc_func_proto depends on patch exists@
identifier E1, E2, E4;
type T1, T2, T3, T4;
identifier fn =~
"^(__pte_alloc|pte_alloc_one|pte_alloc|__pte_alloc_kernel|pte_alloc_one_kernel)$";
@@
(
- T3 fn(T1 E1, T2 E2);
+ T3 fn(T1 E1);
|
- T3 fn(T1 E1, T2 E2, T4 E4);
+ T3 fn(T1 E1, T2 E2);
)
@pte_alloc_func_call depends on patch exists@
expression E2;
identifier fn =~
"^(__pte_alloc|pte_alloc_one|pte_alloc|__pte_alloc_kernel|pte_alloc_one_kernel)$";
@@
fn(...
-, E2
)
@pte_alloc_macro depends on patch exists@
identifier fn =~
"^(__pte_alloc|pte_alloc_one|pte_alloc|__pte_alloc_kernel|pte_alloc_one_kernel)$";
identifier a, b, c;
expression e;
position p;
@@
(
- #define fn(a, b, c) e
+ #define fn(a, b) e
|
- #define fn(a, b) e
+ #define fn(a) e
)
Link: http://lkml.kernel.org/r/20181108181201.88826-2-joelaf@google.com
Signed-off-by: Joel Fernandes (Google) <joel@joelfernandes.org>
Suggested-by: Kirill A. Shutemov <kirill@shutemov.name>
Acked-by: Kirill A. Shutemov <kirill@shutemov.name>
Cc: Michal Hocko <mhocko@kernel.org>
Cc: Julia Lawall <Julia.Lawall@lip6.fr>
Cc: Kirill A. Shutemov <kirill@shutemov.name>
Cc: William Kucharski <william.kucharski@oracle.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2019-01-03 23:28:34 +00:00
|
|
|
pgtable_t pte_alloc_one(struct mm_struct *mm)
|
2012-10-08 23:34:22 +00:00
|
|
|
{
|
2017-11-16 01:35:54 +00:00
|
|
|
struct page *page = alloc_page(GFP_KERNEL | __GFP_ZERO);
|
2013-11-14 22:31:42 +00:00
|
|
|
if (!page)
|
|
|
|
|
return NULL;
|
2019-09-25 23:49:46 +00:00
|
|
|
if (!pgtable_pte_page_ctor(page)) {
|
2020-12-15 03:07:59 +00:00
|
|
|
__free_page(page);
|
2013-11-14 22:31:42 +00:00
|
|
|
return NULL;
|
2012-10-08 23:34:22 +00:00
|
|
|
}
|
2013-11-14 22:31:42 +00:00
|
|
|
return (pte_t *) page_address(page);
|
2012-10-08 23:34:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
|
|
|
|
|
{
|
sparc64: Move from 4MB to 8MB huge pages.
The impetus for this is that we would like to move to 64-bit PMDs and
PGDs, but that would result in only supporting a 42-bit address space
with the current page table layout. It'd be nice to support at least
43-bits.
The reason we'd end up with only 42-bits after making PMDs and PGDs
64-bit is that we only use half-page sized PTE tables in order to make
PMDs line up to 4MB, the hardware huge page size we use.
So what we do here is we make huge pages 8MB, and fabricate them using
4MB hw TLB entries.
Facilitate this by providing a "REAL_HPAGE_SHIFT" which is used in
places that really need to operate on hardware 4MB pages.
Use full pages (512 entries) for PTE tables, and adjust PMD_SHIFT,
PGD_SHIFT, and the build time CPP test as needed. Use a CPP test to
make sure REAL_HPAGE_SHIFT and the _PAGE_SZHUGE_* we use match up.
This makes the pgtable cache completely unused, so remove the code
managing it and the state used in mm_context_t. Now we have less
spinlocks taken in the page table allocation path.
The technique we use to fabricate the 8MB pages is to transfer bit 22
from the missing virtual address into the PTEs physical address field.
That takes care of the transparent huge pages case.
For hugetlb, we fill things in at the PTE level and that code already
puts the sub huge page physical bits into the PTEs, based upon the
offset, so there is nothing special we need to do. It all just works
out.
So, a small amount of complexity in the THP case, but this code is
about to get much simpler when we move the 64-bit PMDs as we can move
away from the fancy 32-bit huge PMD encoding and just put a real PTE
value in there.
With bug fixes and help from Bob Picco.
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-09-25 20:48:49 +00:00
|
|
|
free_page((unsigned long)pte);
|
2012-10-08 23:34:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void __pte_free(pgtable_t pte)
|
|
|
|
|
{
|
|
|
|
|
struct page *page = virt_to_page(pte);
|
sparc64: Move from 4MB to 8MB huge pages.
The impetus for this is that we would like to move to 64-bit PMDs and
PGDs, but that would result in only supporting a 42-bit address space
with the current page table layout. It'd be nice to support at least
43-bits.
The reason we'd end up with only 42-bits after making PMDs and PGDs
64-bit is that we only use half-page sized PTE tables in order to make
PMDs line up to 4MB, the hardware huge page size we use.
So what we do here is we make huge pages 8MB, and fabricate them using
4MB hw TLB entries.
Facilitate this by providing a "REAL_HPAGE_SHIFT" which is used in
places that really need to operate on hardware 4MB pages.
Use full pages (512 entries) for PTE tables, and adjust PMD_SHIFT,
PGD_SHIFT, and the build time CPP test as needed. Use a CPP test to
make sure REAL_HPAGE_SHIFT and the _PAGE_SZHUGE_* we use match up.
This makes the pgtable cache completely unused, so remove the code
managing it and the state used in mm_context_t. Now we have less
spinlocks taken in the page table allocation path.
The technique we use to fabricate the 8MB pages is to transfer bit 22
from the missing virtual address into the PTEs physical address field.
That takes care of the transparent huge pages case.
For hugetlb, we fill things in at the PTE level and that code already
puts the sub huge page physical bits into the PTEs, based upon the
offset, so there is nothing special we need to do. It all just works
out.
So, a small amount of complexity in the THP case, but this code is
about to get much simpler when we move the 64-bit PMDs as we can move
away from the fancy 32-bit huge PMD encoding and just put a real PTE
value in there.
With bug fixes and help from Bob Picco.
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-09-25 20:48:49 +00:00
|
|
|
|
2019-09-25 23:49:46 +00:00
|
|
|
pgtable_pte_page_dtor(page);
|
sparc64: Move from 4MB to 8MB huge pages.
The impetus for this is that we would like to move to 64-bit PMDs and
PGDs, but that would result in only supporting a 42-bit address space
with the current page table layout. It'd be nice to support at least
43-bits.
The reason we'd end up with only 42-bits after making PMDs and PGDs
64-bit is that we only use half-page sized PTE tables in order to make
PMDs line up to 4MB, the hardware huge page size we use.
So what we do here is we make huge pages 8MB, and fabricate them using
4MB hw TLB entries.
Facilitate this by providing a "REAL_HPAGE_SHIFT" which is used in
places that really need to operate on hardware 4MB pages.
Use full pages (512 entries) for PTE tables, and adjust PMD_SHIFT,
PGD_SHIFT, and the build time CPP test as needed. Use a CPP test to
make sure REAL_HPAGE_SHIFT and the _PAGE_SZHUGE_* we use match up.
This makes the pgtable cache completely unused, so remove the code
managing it and the state used in mm_context_t. Now we have less
spinlocks taken in the page table allocation path.
The technique we use to fabricate the 8MB pages is to transfer bit 22
from the missing virtual address into the PTEs physical address field.
That takes care of the transparent huge pages case.
For hugetlb, we fill things in at the PTE level and that code already
puts the sub huge page physical bits into the PTEs, based upon the
offset, so there is nothing special we need to do. It all just works
out.
So, a small amount of complexity in the THP case, but this code is
about to get much simpler when we move the 64-bit PMDs as we can move
away from the fancy 32-bit huge PMD encoding and just put a real PTE
value in there.
With bug fixes and help from Bob Picco.
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-09-25 20:48:49 +00:00
|
|
|
__free_page(page);
|
2012-10-08 23:34:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void pte_free(struct mm_struct *mm, pgtable_t pte)
|
|
|
|
|
{
|
|
|
|
|
__pte_free(pte);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void pgtable_free(void *table, bool is_page)
|
|
|
|
|
{
|
|
|
|
|
if (is_page)
|
|
|
|
|
__pte_free(table);
|
|
|
|
|
else
|
|
|
|
|
kmem_cache_free(pgtable_cache, table);
|
|
|
|
|
}
|
2012-10-08 23:34:29 +00:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
|
|
|
|
|
void update_mmu_cache_pmd(struct vm_area_struct *vma, unsigned long addr,
|
|
|
|
|
pmd_t *pmd)
|
|
|
|
|
{
|
|
|
|
|
unsigned long pte, flags;
|
|
|
|
|
struct mm_struct *mm;
|
|
|
|
|
pmd_t entry = *pmd;
|
|
|
|
|
|
|
|
|
|
if (!pmd_large(entry) || !pmd_young(entry))
|
|
|
|
|
return;
|
|
|
|
|
|
2013-09-26 20:45:15 +00:00
|
|
|
pte = pmd_val(entry);
|
2012-10-08 23:34:29 +00:00
|
|
|
|
2014-08-04 23:34:01 +00:00
|
|
|
/* Don't insert a non-valid PMD into the TSB, we'll deadlock. */
|
|
|
|
|
if (!(pte & _PAGE_VALID))
|
|
|
|
|
return;
|
|
|
|
|
|
sparc64: Move from 4MB to 8MB huge pages.
The impetus for this is that we would like to move to 64-bit PMDs and
PGDs, but that would result in only supporting a 42-bit address space
with the current page table layout. It'd be nice to support at least
43-bits.
The reason we'd end up with only 42-bits after making PMDs and PGDs
64-bit is that we only use half-page sized PTE tables in order to make
PMDs line up to 4MB, the hardware huge page size we use.
So what we do here is we make huge pages 8MB, and fabricate them using
4MB hw TLB entries.
Facilitate this by providing a "REAL_HPAGE_SHIFT" which is used in
places that really need to operate on hardware 4MB pages.
Use full pages (512 entries) for PTE tables, and adjust PMD_SHIFT,
PGD_SHIFT, and the build time CPP test as needed. Use a CPP test to
make sure REAL_HPAGE_SHIFT and the _PAGE_SZHUGE_* we use match up.
This makes the pgtable cache completely unused, so remove the code
managing it and the state used in mm_context_t. Now we have less
spinlocks taken in the page table allocation path.
The technique we use to fabricate the 8MB pages is to transfer bit 22
from the missing virtual address into the PTEs physical address field.
That takes care of the transparent huge pages case.
For hugetlb, we fill things in at the PTE level and that code already
puts the sub huge page physical bits into the PTEs, based upon the
offset, so there is nothing special we need to do. It all just works
out.
So, a small amount of complexity in the THP case, but this code is
about to get much simpler when we move the 64-bit PMDs as we can move
away from the fancy 32-bit huge PMD encoding and just put a real PTE
value in there.
With bug fixes and help from Bob Picco.
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-09-25 20:48:49 +00:00
|
|
|
/* We are fabricating 8MB pages using 4MB real hw pages. */
|
|
|
|
|
pte |= (addr & (1UL << REAL_HPAGE_SHIFT));
|
2012-10-08 23:34:29 +00:00
|
|
|
|
|
|
|
|
mm = vma->vm_mm;
|
|
|
|
|
|
|
|
|
|
spin_lock_irqsave(&mm->context.lock, flags);
|
|
|
|
|
|
|
|
|
|
if (mm->context.tsb_block[MM_TSB_HUGE].tsb != NULL)
|
sparc64: Move from 4MB to 8MB huge pages.
The impetus for this is that we would like to move to 64-bit PMDs and
PGDs, but that would result in only supporting a 42-bit address space
with the current page table layout. It'd be nice to support at least
43-bits.
The reason we'd end up with only 42-bits after making PMDs and PGDs
64-bit is that we only use half-page sized PTE tables in order to make
PMDs line up to 4MB, the hardware huge page size we use.
So what we do here is we make huge pages 8MB, and fabricate them using
4MB hw TLB entries.
Facilitate this by providing a "REAL_HPAGE_SHIFT" which is used in
places that really need to operate on hardware 4MB pages.
Use full pages (512 entries) for PTE tables, and adjust PMD_SHIFT,
PGD_SHIFT, and the build time CPP test as needed. Use a CPP test to
make sure REAL_HPAGE_SHIFT and the _PAGE_SZHUGE_* we use match up.
This makes the pgtable cache completely unused, so remove the code
managing it and the state used in mm_context_t. Now we have less
spinlocks taken in the page table allocation path.
The technique we use to fabricate the 8MB pages is to transfer bit 22
from the missing virtual address into the PTEs physical address field.
That takes care of the transparent huge pages case.
For hugetlb, we fill things in at the PTE level and that code already
puts the sub huge page physical bits into the PTEs, based upon the
offset, so there is nothing special we need to do. It all just works
out.
So, a small amount of complexity in the THP case, but this code is
about to get much simpler when we move the 64-bit PMDs as we can move
away from the fancy 32-bit huge PMD encoding and just put a real PTE
value in there.
With bug fixes and help from Bob Picco.
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-09-25 20:48:49 +00:00
|
|
|
__update_mmu_tsb_insert(mm, MM_TSB_HUGE, REAL_HPAGE_SHIFT,
|
2012-10-08 23:34:29 +00:00
|
|
|
addr, pte);
|
|
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&mm->context.lock, flags);
|
|
|
|
|
}
|
|
|
|
|
#endif /* CONFIG_TRANSPARENT_HUGEPAGE */
|
|
|
|
|
|
|
|
|
|
#if defined(CONFIG_HUGETLB_PAGE) || defined(CONFIG_TRANSPARENT_HUGEPAGE)
|
|
|
|
|
static void context_reload(void *__data)
|
|
|
|
|
{
|
|
|
|
|
struct mm_struct *mm = __data;
|
|
|
|
|
|
|
|
|
|
if (mm == current->mm)
|
|
|
|
|
load_secondary_context(mm);
|
|
|
|
|
}
|
|
|
|
|
|
2013-02-20 06:34:10 +00:00
|
|
|
void hugetlb_setup(struct pt_regs *regs)
|
2012-10-08 23:34:29 +00:00
|
|
|
{
|
2013-02-20 06:34:10 +00:00
|
|
|
struct mm_struct *mm = current->mm;
|
|
|
|
|
struct tsb_config *tp;
|
2012-10-08 23:34:29 +00:00
|
|
|
|
2015-05-11 15:52:11 +00:00
|
|
|
if (faulthandler_disabled() || !mm) {
|
2013-02-20 06:34:10 +00:00
|
|
|
const struct exception_table_entry *entry;
|
|
|
|
|
|
|
|
|
|
entry = search_exception_tables(regs->tpc);
|
|
|
|
|
if (entry) {
|
|
|
|
|
regs->tpc = entry->fixup;
|
|
|
|
|
regs->tnpc = regs->tpc + 4;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
pr_alert("Unexpected HugeTLB setup in atomic context.\n");
|
|
|
|
|
die_if_kernel("HugeTSB in atomic", regs);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
tp = &mm->context.tsb_block[MM_TSB_HUGE];
|
|
|
|
|
if (likely(tp->tsb == NULL))
|
|
|
|
|
tsb_grow(mm, MM_TSB_HUGE, 0);
|
2012-10-08 23:34:29 +00:00
|
|
|
|
|
|
|
|
tsb_context_switch(mm);
|
|
|
|
|
smp_tsb_sync(mm);
|
|
|
|
|
|
|
|
|
|
/* On UltraSPARC-III+ and later, configure the second half of
|
|
|
|
|
* the Data-TLB for huge pages.
|
|
|
|
|
*/
|
|
|
|
|
if (tlb_type == cheetah_plus) {
|
2016-05-25 19:51:20 +00:00
|
|
|
bool need_context_reload = false;
|
2012-10-08 23:34:29 +00:00
|
|
|
unsigned long ctx;
|
|
|
|
|
|
2016-05-25 19:51:20 +00:00
|
|
|
spin_lock_irq(&ctx_alloc_lock);
|
2012-10-08 23:34:29 +00:00
|
|
|
ctx = mm->context.sparc64_ctx_val;
|
|
|
|
|
ctx &= ~CTX_PGSZ_MASK;
|
|
|
|
|
ctx |= CTX_PGSZ_BASE << CTX_PGSZ0_SHIFT;
|
|
|
|
|
ctx |= CTX_PGSZ_HUGE << CTX_PGSZ1_SHIFT;
|
|
|
|
|
|
|
|
|
|
if (ctx != mm->context.sparc64_ctx_val) {
|
|
|
|
|
/* When changing the page size fields, we
|
|
|
|
|
* must perform a context flush so that no
|
|
|
|
|
* stale entries match. This flush must
|
|
|
|
|
* occur with the original context register
|
|
|
|
|
* settings.
|
|
|
|
|
*/
|
|
|
|
|
do_flush_tlb_mm(mm);
|
|
|
|
|
|
|
|
|
|
/* Reload the context register of all processors
|
|
|
|
|
* also executing in this address space.
|
|
|
|
|
*/
|
|
|
|
|
mm->context.sparc64_ctx_val = ctx;
|
2016-05-25 19:51:20 +00:00
|
|
|
need_context_reload = true;
|
2012-10-08 23:34:29 +00:00
|
|
|
}
|
2016-05-25 19:51:20 +00:00
|
|
|
spin_unlock_irq(&ctx_alloc_lock);
|
|
|
|
|
|
|
|
|
|
if (need_context_reload)
|
|
|
|
|
on_each_cpu(context_reload, mm, 0);
|
2012-10-08 23:34:29 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
2014-03-03 16:54:42 +00:00
|
|
|
|
|
|
|
|
static struct resource code_resource = {
|
|
|
|
|
.name = "Kernel code",
|
2016-01-26 20:57:22 +00:00
|
|
|
.flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM
|
2014-03-03 16:54:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static struct resource data_resource = {
|
|
|
|
|
.name = "Kernel data",
|
2016-01-26 20:57:22 +00:00
|
|
|
.flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM
|
2014-03-03 16:54:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static struct resource bss_resource = {
|
|
|
|
|
.name = "Kernel bss",
|
2016-01-26 20:57:22 +00:00
|
|
|
.flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM
|
2014-03-03 16:54:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static inline resource_size_t compute_kern_paddr(void *addr)
|
|
|
|
|
{
|
|
|
|
|
return (resource_size_t) (addr - KERNBASE + kern_base);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void __init kernel_lds_init(void)
|
|
|
|
|
{
|
|
|
|
|
code_resource.start = compute_kern_paddr(_text);
|
|
|
|
|
code_resource.end = compute_kern_paddr(_etext - 1);
|
|
|
|
|
data_resource.start = compute_kern_paddr(_etext);
|
|
|
|
|
data_resource.end = compute_kern_paddr(_edata - 1);
|
|
|
|
|
bss_resource.start = compute_kern_paddr(__bss_start);
|
|
|
|
|
bss_resource.end = compute_kern_paddr(_end - 1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int __init report_memory(void)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
struct resource *res;
|
|
|
|
|
|
|
|
|
|
kernel_lds_init();
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < pavail_ents; i++) {
|
|
|
|
|
res = kzalloc(sizeof(struct resource), GFP_KERNEL);
|
|
|
|
|
|
|
|
|
|
if (!res) {
|
|
|
|
|
pr_warn("Failed to allocate source.\n");
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
res->name = "System RAM";
|
|
|
|
|
res->start = pavail[i].phys_addr;
|
|
|
|
|
res->end = pavail[i].phys_addr + pavail[i].reg_size - 1;
|
2016-01-26 20:57:22 +00:00
|
|
|
res->flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM;
|
2014-03-03 16:54:42 +00:00
|
|
|
|
|
|
|
|
if (insert_resource(&iomem_resource, res) < 0) {
|
|
|
|
|
pr_warn("Resource insertion failed.\n");
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
insert_resource(res, &code_resource);
|
|
|
|
|
insert_resource(res, &data_resource);
|
|
|
|
|
insert_resource(res, &bss_resource);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2015-03-19 02:15:28 +00:00
|
|
|
arch_initcall(report_memory);
|
2014-08-06 01:57:18 +00:00
|
|
|
|
2014-08-05 03:07:37 +00:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
#define do_flush_tlb_kernel_range smp_flush_tlb_kernel_range
|
|
|
|
|
#else
|
|
|
|
|
#define do_flush_tlb_kernel_range __flush_tlb_kernel_range
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
void flush_tlb_kernel_range(unsigned long start, unsigned long end)
|
|
|
|
|
{
|
|
|
|
|
if (start < HI_OBP_ADDRESS && end > LOW_OBP_ADDRESS) {
|
|
|
|
|
if (start < LOW_OBP_ADDRESS) {
|
|
|
|
|
flush_tsb_kernel_range(start, LOW_OBP_ADDRESS);
|
|
|
|
|
do_flush_tlb_kernel_range(start, LOW_OBP_ADDRESS);
|
|
|
|
|
}
|
|
|
|
|
if (end > HI_OBP_ADDRESS) {
|
2014-10-05 04:05:14 +00:00
|
|
|
flush_tsb_kernel_range(HI_OBP_ADDRESS, end);
|
|
|
|
|
do_flush_tlb_kernel_range(HI_OBP_ADDRESS, end);
|
2014-08-05 03:07:37 +00:00
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
flush_tsb_kernel_range(start, end);
|
|
|
|
|
do_flush_tlb_kernel_range(start, end);
|
|
|
|
|
}
|
|
|
|
|
}
|
2018-02-23 22:46:41 +00:00
|
|
|
|
|
|
|
|
void copy_user_highpage(struct page *to, struct page *from,
|
|
|
|
|
unsigned long vaddr, struct vm_area_struct *vma)
|
|
|
|
|
{
|
|
|
|
|
char *vfrom, *vto;
|
|
|
|
|
|
|
|
|
|
vfrom = kmap_atomic(from);
|
|
|
|
|
vto = kmap_atomic(to);
|
|
|
|
|
copy_user_page(vto, vfrom, vaddr, to);
|
|
|
|
|
kunmap_atomic(vto);
|
|
|
|
|
kunmap_atomic(vfrom);
|
|
|
|
|
|
|
|
|
|
/* If this page has ADI enabled, copy over any ADI tags
|
|
|
|
|
* as well
|
|
|
|
|
*/
|
|
|
|
|
if (vma->vm_flags & VM_SPARC_ADI) {
|
|
|
|
|
unsigned long pfrom, pto, i, adi_tag;
|
|
|
|
|
|
|
|
|
|
pfrom = page_to_phys(from);
|
|
|
|
|
pto = page_to_phys(to);
|
|
|
|
|
|
|
|
|
|
for (i = pfrom; i < (pfrom + PAGE_SIZE); i += adi_blksize()) {
|
|
|
|
|
asm volatile("ldxa [%1] %2, %0\n\t"
|
|
|
|
|
: "=r" (adi_tag)
|
|
|
|
|
: "r" (i), "i" (ASI_MCD_REAL));
|
|
|
|
|
asm volatile("stxa %0, [%1] %2\n\t"
|
|
|
|
|
:
|
|
|
|
|
: "r" (adi_tag), "r" (pto),
|
|
|
|
|
"i" (ASI_MCD_REAL));
|
|
|
|
|
pto += adi_blksize();
|
|
|
|
|
}
|
|
|
|
|
asm volatile("membar #Sync\n\t");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(copy_user_highpage);
|
|
|
|
|
|
|
|
|
|
void copy_highpage(struct page *to, struct page *from)
|
|
|
|
|
{
|
|
|
|
|
char *vfrom, *vto;
|
|
|
|
|
|
|
|
|
|
vfrom = kmap_atomic(from);
|
|
|
|
|
vto = kmap_atomic(to);
|
|
|
|
|
copy_page(vto, vfrom);
|
|
|
|
|
kunmap_atomic(vto);
|
|
|
|
|
kunmap_atomic(vfrom);
|
|
|
|
|
|
|
|
|
|
/* If this platform is ADI enabled, copy any ADI tags
|
|
|
|
|
* as well
|
|
|
|
|
*/
|
|
|
|
|
if (adi_capable()) {
|
|
|
|
|
unsigned long pfrom, pto, i, adi_tag;
|
|
|
|
|
|
|
|
|
|
pfrom = page_to_phys(from);
|
|
|
|
|
pto = page_to_phys(to);
|
|
|
|
|
|
|
|
|
|
for (i = pfrom; i < (pfrom + PAGE_SIZE); i += adi_blksize()) {
|
|
|
|
|
asm volatile("ldxa [%1] %2, %0\n\t"
|
|
|
|
|
: "=r" (adi_tag)
|
|
|
|
|
: "r" (i), "i" (ASI_MCD_REAL));
|
|
|
|
|
asm volatile("stxa %0, [%1] %2\n\t"
|
|
|
|
|
:
|
|
|
|
|
: "r" (adi_tag), "r" (pto),
|
|
|
|
|
"i" (ASI_MCD_REAL));
|
|
|
|
|
pto += adi_blksize();
|
|
|
|
|
}
|
|
|
|
|
asm volatile("membar #Sync\n\t");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(copy_highpage);
|
