* [PATCH v6 12/24] mm: Introduce __lru_cache_add_active_or_unevictable
From: Laurent Dufour @ 2018-01-12 17:25 UTC (permalink / raw)
To: paulmck, peterz, akpm, kirill, ak, mhocko, dave, jack,
Matthew Wilcox, benh, mpe, paulus, Thomas Gleixner, Ingo Molnar,
hpa, Will Deacon, Sergey Senozhatsky, Andrea Arcangeli,
Alexei Starovoitov, kemi.wang, sergey.senozhatsky.work
Cc: linux-kernel, linux-mm, haren, khandual, npiggin, bsingharora,
Tim Chen, linuxppc-dev, x86
In-Reply-To: <1515777968-867-1-git-send-email-ldufour@linux.vnet.ibm.com>
The speculative page fault handler which is run without holding the
mmap_sem is calling lru_cache_add_active_or_unevictable() but the vm_flags
is not guaranteed to remain constant.
Introducing __lru_cache_add_active_or_unevictable() which has the vma flags
value parameter instead of the vma pointer.
Signed-off-by: Laurent Dufour <ldufour@linux.vnet.ibm.com>
---
include/linux/swap.h | 10 ++++++++--
mm/memory.c | 8 ++++----
mm/swap.c | 6 +++---
3 files changed, 15 insertions(+), 9 deletions(-)
diff --git a/include/linux/swap.h b/include/linux/swap.h
index a1a3f4ed94ce..99377b66ea93 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -337,8 +337,14 @@ extern void deactivate_file_page(struct page *page);
extern void mark_page_lazyfree(struct page *page);
extern void swap_setup(void);
-extern void lru_cache_add_active_or_unevictable(struct page *page,
- struct vm_area_struct *vma);
+extern void __lru_cache_add_active_or_unevictable(struct page *page,
+ unsigned long vma_flags);
+
+static inline void lru_cache_add_active_or_unevictable(struct page *page,
+ struct vm_area_struct *vma)
+{
+ return __lru_cache_add_active_or_unevictable(page, vma->vm_flags);
+}
/* linux/mm/vmscan.c */
extern unsigned long zone_reclaimable_pages(struct zone *zone);
diff --git a/mm/memory.c b/mm/memory.c
index e4c0f08b78e8..cbd7e5c3a42f 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -2540,7 +2540,7 @@ static int wp_page_copy(struct vm_fault *vmf)
ptep_clear_flush_notify(vma, vmf->address, vmf->pte);
page_add_new_anon_rmap(new_page, vma, vmf->address, false);
mem_cgroup_commit_charge(new_page, memcg, false, false);
- lru_cache_add_active_or_unevictable(new_page, vma);
+ __lru_cache_add_active_or_unevictable(new_page, vmf->vma_flags);
/*
* We call the notify macro here because, when using secondary
* mmu page tables (such as kvm shadow page tables), we want the
@@ -3082,7 +3082,7 @@ int do_swap_page(struct vm_fault *vmf)
if (unlikely(page != swapcache && swapcache)) {
page_add_new_anon_rmap(page, vma, vmf->address, false);
mem_cgroup_commit_charge(page, memcg, false, false);
- lru_cache_add_active_or_unevictable(page, vma);
+ __lru_cache_add_active_or_unevictable(page, vmf->vma_flags);
} else {
do_page_add_anon_rmap(page, vma, vmf->address, exclusive);
mem_cgroup_commit_charge(page, memcg, true, false);
@@ -3232,7 +3232,7 @@ static int do_anonymous_page(struct vm_fault *vmf)
inc_mm_counter_fast(vma->vm_mm, MM_ANONPAGES);
page_add_new_anon_rmap(page, vma, vmf->address, false);
mem_cgroup_commit_charge(page, memcg, false, false);
- lru_cache_add_active_or_unevictable(page, vma);
+ __lru_cache_add_active_or_unevictable(page, vmf->vma_flags);
setpte:
set_pte_at(vma->vm_mm, vmf->address, vmf->pte, entry);
@@ -3484,7 +3484,7 @@ int alloc_set_pte(struct vm_fault *vmf, struct mem_cgroup *memcg,
inc_mm_counter_fast(vma->vm_mm, MM_ANONPAGES);
page_add_new_anon_rmap(page, vma, vmf->address, false);
mem_cgroup_commit_charge(page, memcg, false, false);
- lru_cache_add_active_or_unevictable(page, vma);
+ __lru_cache_add_active_or_unevictable(page, vmf->vma_flags);
} else {
inc_mm_counter_fast(vma->vm_mm, mm_counter_file(page));
page_add_file_rmap(page, false);
diff --git a/mm/swap.c b/mm/swap.c
index 566cfb9fdaf3..7e25a74397b9 100644
--- a/mm/swap.c
+++ b/mm/swap.c
@@ -455,12 +455,12 @@ void lru_cache_add(struct page *page)
* directly back onto it's zone's unevictable list, it does NOT use a
* per cpu pagevec.
*/
-void lru_cache_add_active_or_unevictable(struct page *page,
- struct vm_area_struct *vma)
+void __lru_cache_add_active_or_unevictable(struct page *page,
+ unsigned long vma_flags)
{
VM_BUG_ON_PAGE(PageLRU(page), page);
- if (likely((vma->vm_flags & (VM_LOCKED | VM_SPECIAL)) != VM_LOCKED))
+ if (likely((vma_flags & (VM_LOCKED | VM_SPECIAL)) != VM_LOCKED))
SetPageActive(page);
else if (!TestSetPageMlocked(page)) {
/*
--
2.7.4
^ permalink raw reply related
* [PATCH v6 11/24] mm/migrate: Pass vm_fault pointer to migrate_misplaced_page()
From: Laurent Dufour @ 2018-01-12 17:25 UTC (permalink / raw)
To: paulmck, peterz, akpm, kirill, ak, mhocko, dave, jack,
Matthew Wilcox, benh, mpe, paulus, Thomas Gleixner, Ingo Molnar,
hpa, Will Deacon, Sergey Senozhatsky, Andrea Arcangeli,
Alexei Starovoitov, kemi.wang, sergey.senozhatsky.work
Cc: linux-kernel, linux-mm, haren, khandual, npiggin, bsingharora,
Tim Chen, linuxppc-dev, x86
In-Reply-To: <1515777968-867-1-git-send-email-ldufour@linux.vnet.ibm.com>
migrate_misplaced_page() is only called during the page fault handling so
it's better to pass the pointer to the struct vm_fault instead of the vma.
This way during the speculative page fault path the saved vma->vm_flags
could be used.
Signed-off-by: Laurent Dufour <ldufour@linux.vnet.ibm.com>
---
include/linux/migrate.h | 4 ++--
mm/memory.c | 2 +-
mm/migrate.c | 4 ++--
3 files changed, 5 insertions(+), 5 deletions(-)
diff --git a/include/linux/migrate.h b/include/linux/migrate.h
index 0c6fe904bc97..08960ec74246 100644
--- a/include/linux/migrate.h
+++ b/include/linux/migrate.h
@@ -126,14 +126,14 @@ static inline void __ClearPageMovable(struct page *page)
#ifdef CONFIG_NUMA_BALANCING
extern bool pmd_trans_migrating(pmd_t pmd);
extern int migrate_misplaced_page(struct page *page,
- struct vm_area_struct *vma, int node);
+ struct vm_fault *vmf, int node);
#else
static inline bool pmd_trans_migrating(pmd_t pmd)
{
return false;
}
static inline int migrate_misplaced_page(struct page *page,
- struct vm_area_struct *vma, int node)
+ struct vm_fault *vmf, int node)
{
return -EAGAIN; /* can't migrate now */
}
diff --git a/mm/memory.c b/mm/memory.c
index 79dfd2a60224..e4c0f08b78e8 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -3878,7 +3878,7 @@ static int do_numa_page(struct vm_fault *vmf)
}
/* Migrate to the requested node */
- migrated = migrate_misplaced_page(page, vma, target_nid);
+ migrated = migrate_misplaced_page(page, vmf, target_nid);
if (migrated) {
page_nid = target_nid;
flags |= TNF_MIGRATED;
diff --git a/mm/migrate.c b/mm/migrate.c
index 33224b92db98..6e1ae62501da 100644
--- a/mm/migrate.c
+++ b/mm/migrate.c
@@ -1900,7 +1900,7 @@ bool pmd_trans_migrating(pmd_t pmd)
* node. Caller is expected to have an elevated reference count on
* the page that will be dropped by this function before returning.
*/
-int migrate_misplaced_page(struct page *page, struct vm_area_struct *vma,
+int migrate_misplaced_page(struct page *page, struct vm_fault *vmf,
int node)
{
pg_data_t *pgdat = NODE_DATA(node);
@@ -1913,7 +1913,7 @@ int migrate_misplaced_page(struct page *page, struct vm_area_struct *vma,
* with execute permissions as they are probably shared libraries.
*/
if (page_mapcount(page) != 1 && page_is_file_cache(page) &&
- (vma->vm_flags & VM_EXEC))
+ (vmf->vma_flags & VM_EXEC))
goto out;
/*
--
2.7.4
^ permalink raw reply related
* [PATCH v6 10/24] mm: Cache some VMA fields in the vm_fault structure
From: Laurent Dufour @ 2018-01-12 17:25 UTC (permalink / raw)
To: paulmck, peterz, akpm, kirill, ak, mhocko, dave, jack,
Matthew Wilcox, benh, mpe, paulus, Thomas Gleixner, Ingo Molnar,
hpa, Will Deacon, Sergey Senozhatsky, Andrea Arcangeli,
Alexei Starovoitov, kemi.wang, sergey.senozhatsky.work
Cc: linux-kernel, linux-mm, haren, khandual, npiggin, bsingharora,
Tim Chen, linuxppc-dev, x86
In-Reply-To: <1515777968-867-1-git-send-email-ldufour@linux.vnet.ibm.com>
When handling speculative page fault, the vma->vm_flags and
vma->vm_page_prot fields are read once the page table lock is released. So
there is no more guarantee that these fields would not change in our back.
They will be saved in the vm_fault structure before the VMA is checked for
changes.
This patch also set the fields in hugetlb_no_page() and
__collapse_huge_page_swapin even if it is not need for the callee.
Signed-off-by: Laurent Dufour <ldufour@linux.vnet.ibm.com>
---
include/linux/mm.h | 6 ++++++
mm/hugetlb.c | 2 ++
mm/khugepaged.c | 2 ++
mm/memory.c | 38 ++++++++++++++++++++------------------
4 files changed, 30 insertions(+), 18 deletions(-)
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 61a2b63eccad..f14a73a8d420 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -361,6 +361,12 @@ struct vm_fault {
* page table to avoid allocation from
* atomic context.
*/
+ /*
+ * These entries are required when handling speculative page fault.
+ * This way the page handling is done using consistent field values.
+ */
+ unsigned long vma_flags;
+ pgprot_t vma_page_prot;
};
/* page entry size for vm->huge_fault() */
diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index ffcae114ceed..3b163ecc80e6 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -3717,6 +3717,8 @@ static int hugetlb_no_page(struct mm_struct *mm, struct vm_area_struct *vma,
.vma = vma,
.address = address,
.flags = flags,
+ .vma_flags = vma->vm_flags,
+ .vma_page_prot = vma->vm_page_prot,
/*
* Hard to debug if it ends up being
* used by a callee that assumes
diff --git a/mm/khugepaged.c b/mm/khugepaged.c
index 32314e9e48dd..a946d5306160 100644
--- a/mm/khugepaged.c
+++ b/mm/khugepaged.c
@@ -882,6 +882,8 @@ static bool __collapse_huge_page_swapin(struct mm_struct *mm,
.flags = FAULT_FLAG_ALLOW_RETRY,
.pmd = pmd,
.pgoff = linear_page_index(vma, address),
+ .vma_flags = vma->vm_flags,
+ .vma_page_prot = vma->vm_page_prot,
};
/* we only decide to swapin, if there is enough young ptes */
diff --git a/mm/memory.c b/mm/memory.c
index 3ac54a65b0f9..79dfd2a60224 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -2595,7 +2595,7 @@ static int wp_page_copy(struct vm_fault *vmf)
* Don't let another task, with possibly unlocked vma,
* keep the mlocked page.
*/
- if (page_copied && (vma->vm_flags & VM_LOCKED)) {
+ if (page_copied && (vmf->vma_flags & VM_LOCKED)) {
lock_page(old_page); /* LRU manipulation */
if (PageMlocked(old_page))
munlock_vma_page(old_page);
@@ -2629,7 +2629,7 @@ static int wp_page_copy(struct vm_fault *vmf)
*/
int finish_mkwrite_fault(struct vm_fault *vmf)
{
- WARN_ON_ONCE(!(vmf->vma->vm_flags & VM_SHARED));
+ WARN_ON_ONCE(!(vmf->vma_flags & VM_SHARED));
if (!pte_map_lock(vmf))
return VM_FAULT_RETRY;
/*
@@ -2731,7 +2731,7 @@ static int do_wp_page(struct vm_fault *vmf)
* We should not cow pages in a shared writeable mapping.
* Just mark the pages writable and/or call ops->pfn_mkwrite.
*/
- if ((vma->vm_flags & (VM_WRITE|VM_SHARED)) ==
+ if ((vmf->vma_flags & (VM_WRITE|VM_SHARED)) ==
(VM_WRITE|VM_SHARED))
return wp_pfn_shared(vmf);
@@ -2778,7 +2778,7 @@ static int do_wp_page(struct vm_fault *vmf)
return VM_FAULT_WRITE;
}
unlock_page(vmf->page);
- } else if (unlikely((vma->vm_flags & (VM_WRITE|VM_SHARED)) ==
+ } else if (unlikely((vmf->vma_flags & (VM_WRITE|VM_SHARED)) ==
(VM_WRITE|VM_SHARED))) {
return wp_page_shared(vmf);
}
@@ -3065,7 +3065,7 @@ int do_swap_page(struct vm_fault *vmf)
inc_mm_counter_fast(vma->vm_mm, MM_ANONPAGES);
dec_mm_counter_fast(vma->vm_mm, MM_SWAPENTS);
- pte = mk_pte(page, vma->vm_page_prot);
+ pte = mk_pte(page, vmf->vma_page_prot);
if ((vmf->flags & FAULT_FLAG_WRITE) && reuse_swap_page(page, NULL)) {
pte = maybe_mkwrite(pte_mkdirty(pte), vma);
vmf->flags &= ~FAULT_FLAG_WRITE;
@@ -3091,7 +3091,7 @@ int do_swap_page(struct vm_fault *vmf)
swap_free(entry);
if (mem_cgroup_swap_full(page) ||
- (vma->vm_flags & VM_LOCKED) || PageMlocked(page))
+ (vmf->vma_flags & VM_LOCKED) || PageMlocked(page))
try_to_free_swap(page);
unlock_page(page);
if (page != swapcache && swapcache) {
@@ -3148,7 +3148,7 @@ static int do_anonymous_page(struct vm_fault *vmf)
pte_t entry;
/* File mapping without ->vm_ops ? */
- if (vma->vm_flags & VM_SHARED)
+ if (vmf->vma_flags & VM_SHARED)
return VM_FAULT_SIGBUS;
/*
@@ -3172,7 +3172,7 @@ static int do_anonymous_page(struct vm_fault *vmf)
if (!(vmf->flags & FAULT_FLAG_WRITE) &&
!mm_forbids_zeropage(vma->vm_mm)) {
entry = pte_mkspecial(pfn_pte(my_zero_pfn(vmf->address),
- vma->vm_page_prot));
+ vmf->vma_page_prot));
if (!pte_map_lock(vmf))
return VM_FAULT_RETRY;
if (!pte_none(*vmf->pte))
@@ -3205,8 +3205,8 @@ static int do_anonymous_page(struct vm_fault *vmf)
*/
__SetPageUptodate(page);
- entry = mk_pte(page, vma->vm_page_prot);
- if (vma->vm_flags & VM_WRITE)
+ entry = mk_pte(page, vmf->vma_page_prot);
+ if (vmf->vma_flags & VM_WRITE)
entry = pte_mkwrite(pte_mkdirty(entry));
if (!pte_map_lock(vmf)) {
@@ -3402,7 +3402,7 @@ static int do_set_pmd(struct vm_fault *vmf, struct page *page)
for (i = 0; i < HPAGE_PMD_NR; i++)
flush_icache_page(vma, page + i);
- entry = mk_huge_pmd(page, vma->vm_page_prot);
+ entry = mk_huge_pmd(page, vmf->vma_page_prot);
if (write)
entry = maybe_pmd_mkwrite(pmd_mkdirty(entry), vma);
@@ -3476,11 +3476,11 @@ int alloc_set_pte(struct vm_fault *vmf, struct mem_cgroup *memcg,
return VM_FAULT_NOPAGE;
flush_icache_page(vma, page);
- entry = mk_pte(page, vma->vm_page_prot);
+ entry = mk_pte(page, vmf->vma_page_prot);
if (write)
entry = maybe_mkwrite(pte_mkdirty(entry), vma);
/* copy-on-write page */
- if (write && !(vma->vm_flags & VM_SHARED)) {
+ if (write && !(vmf->vma_flags & VM_SHARED)) {
inc_mm_counter_fast(vma->vm_mm, MM_ANONPAGES);
page_add_new_anon_rmap(page, vma, vmf->address, false);
mem_cgroup_commit_charge(page, memcg, false, false);
@@ -3519,7 +3519,7 @@ int finish_fault(struct vm_fault *vmf)
/* Did we COW the page? */
if ((vmf->flags & FAULT_FLAG_WRITE) &&
- !(vmf->vma->vm_flags & VM_SHARED))
+ !(vmf->vma_flags & VM_SHARED))
page = vmf->cow_page;
else
page = vmf->page;
@@ -3773,7 +3773,7 @@ static int do_fault(struct vm_fault *vmf)
ret = VM_FAULT_SIGBUS;
else if (!(vmf->flags & FAULT_FLAG_WRITE))
ret = do_read_fault(vmf);
- else if (!(vma->vm_flags & VM_SHARED))
+ else if (!(vmf->vma_flags & VM_SHARED))
ret = do_cow_fault(vmf);
else
ret = do_shared_fault(vmf);
@@ -3830,7 +3830,7 @@ static int do_numa_page(struct vm_fault *vmf)
* accessible ptes, some can allow access by kernel mode.
*/
pte = ptep_modify_prot_start(vma->vm_mm, vmf->address, vmf->pte);
- pte = pte_modify(pte, vma->vm_page_prot);
+ pte = pte_modify(pte, vmf->vma_page_prot);
pte = pte_mkyoung(pte);
if (was_writable)
pte = pte_mkwrite(pte);
@@ -3864,7 +3864,7 @@ static int do_numa_page(struct vm_fault *vmf)
* Flag if the page is shared between multiple address spaces. This
* is later used when determining whether to group tasks together
*/
- if (page_mapcount(page) > 1 && (vma->vm_flags & VM_SHARED))
+ if (page_mapcount(page) > 1 && (vmf->vma_flags & VM_SHARED))
flags |= TNF_SHARED;
last_cpupid = page_cpupid_last(page);
@@ -3909,7 +3909,7 @@ static inline int wp_huge_pmd(struct vm_fault *vmf, pmd_t orig_pmd)
return vmf->vma->vm_ops->huge_fault(vmf, PE_SIZE_PMD);
/* COW handled on pte level: split pmd */
- VM_BUG_ON_VMA(vmf->vma->vm_flags & VM_SHARED, vmf->vma);
+ VM_BUG_ON_VMA(vmf->vma_flags & VM_SHARED, vmf->vma);
__split_huge_pmd(vmf->vma, vmf->pmd, vmf->address, false, NULL);
return VM_FAULT_FALLBACK;
@@ -4056,6 +4056,8 @@ static int __handle_mm_fault(struct vm_area_struct *vma, unsigned long address,
.flags = flags,
.pgoff = linear_page_index(vma, address),
.gfp_mask = __get_fault_gfp_mask(vma),
+ .vma_flags = vma->vm_flags,
+ .vma_page_prot = vma->vm_page_prot,
};
unsigned int dirty = flags & FAULT_FLAG_WRITE;
struct mm_struct *mm = vma->vm_mm;
--
2.7.4
^ permalink raw reply related
* [PATCH v6 09/24] mm: Protect SPF handler against anon_vma changes
From: Laurent Dufour @ 2018-01-12 17:25 UTC (permalink / raw)
To: paulmck, peterz, akpm, kirill, ak, mhocko, dave, jack,
Matthew Wilcox, benh, mpe, paulus, Thomas Gleixner, Ingo Molnar,
hpa, Will Deacon, Sergey Senozhatsky, Andrea Arcangeli,
Alexei Starovoitov, kemi.wang, sergey.senozhatsky.work
Cc: linux-kernel, linux-mm, haren, khandual, npiggin, bsingharora,
Tim Chen, linuxppc-dev, x86
In-Reply-To: <1515777968-867-1-git-send-email-ldufour@linux.vnet.ibm.com>
The speculative page fault handler must be protected against anon_vma
changes. This is because page_add_new_anon_rmap() is called during the
speculative path.
In addition, don't try speculative page fault if the VMA don't have an
anon_vma structure allocated because its allocation should be
protected by the mmap_sem.
In __vma_adjust() when importer->anon_vma is set, there is no need to
protect against speculative page faults since speculative page fault
is aborted if the vma->anon_vma is not set.
When calling page_add_new_anon_rmap() vma->anon_vma is necessarily
valid since we checked for it when locking the pte and the anon_vma is
removed once the pte is unlocked. So even if the speculative page
fault handler is running concurrently with do_unmap(), as the pte is
locked in unmap_region() - through unmap_vmas() - and the anon_vma
unlinked later, because we check for the vma sequence counter which is
updated in unmap_page_range() before locking the pte, and then in
free_pgtables() so when locking the pte the change will be detected.
Signed-off-by: Laurent Dufour <ldufour@linux.vnet.ibm.com>
---
mm/memory.c | 4 ++++
1 file changed, 4 insertions(+)
diff --git a/mm/memory.c b/mm/memory.c
index 22bdc5c6c5ee..3ac54a65b0f9 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -624,7 +624,9 @@ void free_pgtables(struct mmu_gather *tlb, struct vm_area_struct *vma,
* Hide vma from rmap and truncate_pagecache before freeing
* pgtables
*/
+ vm_write_begin(vma);
unlink_anon_vmas(vma);
+ vm_write_end(vma);
unlink_file_vma(vma);
if (is_vm_hugetlb_page(vma)) {
@@ -638,7 +640,9 @@ void free_pgtables(struct mmu_gather *tlb, struct vm_area_struct *vma,
&& !is_vm_hugetlb_page(next)) {
vma = next;
next = vma->vm_next;
+ vm_write_begin(vma);
unlink_anon_vmas(vma);
+ vm_write_end(vma);
unlink_file_vma(vma);
}
free_pgd_range(tlb, addr, vma->vm_end,
--
2.7.4
^ permalink raw reply related
* [PATCH v6 08/24] mm: protect mremap() against SPF hanlder
From: Laurent Dufour @ 2018-01-12 17:25 UTC (permalink / raw)
To: paulmck, peterz, akpm, kirill, ak, mhocko, dave, jack,
Matthew Wilcox, benh, mpe, paulus, Thomas Gleixner, Ingo Molnar,
hpa, Will Deacon, Sergey Senozhatsky, Andrea Arcangeli,
Alexei Starovoitov, kemi.wang, sergey.senozhatsky.work
Cc: linux-kernel, linux-mm, haren, khandual, npiggin, bsingharora,
Tim Chen, linuxppc-dev, x86
In-Reply-To: <1515777968-867-1-git-send-email-ldufour@linux.vnet.ibm.com>
If a thread is remapping an area while another one is faulting on the
destination area, the SPF handler may fetch the vma from the RB tree before
the pte has been moved by the other thread. This means that the moved ptes
will overwrite those create by the page fault handler leading to page
leaked.
CPU 1 CPU2
enter mremap()
unmap the dest area
copy_vma() Enter speculative page fault handler
>> at this time the dest area is present in the RB tree
fetch the vma matching dest area
create a pte as the VMA matched
Exit the SPF handler
<data written in the new page>
move_ptes()
> it is assumed that the dest area is empty,
> the move ptes overwrite the page mapped by the CPU2.
To prevent that, when the VMA matching the dest area is extended or created
by copy_vma(), it should be marked as non available to the SPF handler.
The usual way to so is to rely on vm_write_begin()/end().
This is already in __vma_adjust() called by copy_vma() (through
vma_merge()). But __vma_adjust() is calling vm_write_end() before returning
which create a window for another thread.
This patch adds a new parameter to vma_merge() which is passed down to
vma_adjust().
The assumption is that copy_vma() is returning a vma which should be
released by calling vm_raw_write_end() by the callee once the ptes have
been moved.
Signed-off-by: Laurent Dufour <ldufour@linux.vnet.ibm.com>
---
include/linux/mm.h | 16 ++++++++++++----
mm/mmap.c | 47 ++++++++++++++++++++++++++++++++++++-----------
mm/mremap.c | 13 +++++++++++++
3 files changed, 61 insertions(+), 15 deletions(-)
diff --git a/include/linux/mm.h b/include/linux/mm.h
index ca7ceba84292..61a2b63eccad 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -2186,16 +2186,24 @@ void anon_vma_interval_tree_verify(struct anon_vma_chain *node);
extern int __vm_enough_memory(struct mm_struct *mm, long pages, int cap_sys_admin);
extern int __vma_adjust(struct vm_area_struct *vma, unsigned long start,
unsigned long end, pgoff_t pgoff, struct vm_area_struct *insert,
- struct vm_area_struct *expand);
+ struct vm_area_struct *expand, bool keep_locked);
static inline int vma_adjust(struct vm_area_struct *vma, unsigned long start,
unsigned long end, pgoff_t pgoff, struct vm_area_struct *insert)
{
- return __vma_adjust(vma, start, end, pgoff, insert, NULL);
+ return __vma_adjust(vma, start, end, pgoff, insert, NULL, false);
}
-extern struct vm_area_struct *vma_merge(struct mm_struct *,
+extern struct vm_area_struct *__vma_merge(struct mm_struct *,
struct vm_area_struct *prev, unsigned long addr, unsigned long end,
unsigned long vm_flags, struct anon_vma *, struct file *, pgoff_t,
- struct mempolicy *, struct vm_userfaultfd_ctx);
+ struct mempolicy *, struct vm_userfaultfd_ctx, bool keep_locked);
+static inline struct vm_area_struct *vma_merge(struct mm_struct *vma,
+ struct vm_area_struct *prev, unsigned long addr, unsigned long end,
+ unsigned long vm_flags, struct anon_vma *anon, struct file *file,
+ pgoff_t off, struct mempolicy *pol, struct vm_userfaultfd_ctx uff)
+{
+ return __vma_merge(vma, prev, addr, end, vm_flags, anon, file, off,
+ pol, uff, false);
+}
extern struct anon_vma *find_mergeable_anon_vma(struct vm_area_struct *);
extern int __split_vma(struct mm_struct *, struct vm_area_struct *,
unsigned long addr, int new_below);
diff --git a/mm/mmap.c b/mm/mmap.c
index 73e740291a3a..960e2f16ffcf 100644
--- a/mm/mmap.c
+++ b/mm/mmap.c
@@ -684,7 +684,7 @@ static inline void __vma_unlink_prev(struct mm_struct *mm,
*/
int __vma_adjust(struct vm_area_struct *vma, unsigned long start,
unsigned long end, pgoff_t pgoff, struct vm_area_struct *insert,
- struct vm_area_struct *expand)
+ struct vm_area_struct *expand, bool keep_locked)
{
struct mm_struct *mm = vma->vm_mm;
struct vm_area_struct *next = vma->vm_next, *orig_vma = vma;
@@ -996,7 +996,8 @@ int __vma_adjust(struct vm_area_struct *vma, unsigned long start,
if (next && next != vma)
vm_raw_write_end(next);
- vm_raw_write_end(vma);
+ if (!keep_locked)
+ vm_raw_write_end(vma);
validate_mm(mm);
@@ -1132,12 +1133,13 @@ can_vma_merge_after(struct vm_area_struct *vma, unsigned long vm_flags,
* parameter) may establish ptes with the wrong permissions of NNNN
* instead of the right permissions of XXXX.
*/
-struct vm_area_struct *vma_merge(struct mm_struct *mm,
+struct vm_area_struct *__vma_merge(struct mm_struct *mm,
struct vm_area_struct *prev, unsigned long addr,
unsigned long end, unsigned long vm_flags,
struct anon_vma *anon_vma, struct file *file,
pgoff_t pgoff, struct mempolicy *policy,
- struct vm_userfaultfd_ctx vm_userfaultfd_ctx)
+ struct vm_userfaultfd_ctx vm_userfaultfd_ctx,
+ bool keep_locked)
{
pgoff_t pglen = (end - addr) >> PAGE_SHIFT;
struct vm_area_struct *area, *next;
@@ -1185,10 +1187,11 @@ struct vm_area_struct *vma_merge(struct mm_struct *mm,
/* cases 1, 6 */
err = __vma_adjust(prev, prev->vm_start,
next->vm_end, prev->vm_pgoff, NULL,
- prev);
+ prev, keep_locked);
} else /* cases 2, 5, 7 */
err = __vma_adjust(prev, prev->vm_start,
- end, prev->vm_pgoff, NULL, prev);
+ end, prev->vm_pgoff, NULL, prev,
+ keep_locked);
if (err)
return NULL;
khugepaged_enter_vma_merge(prev, vm_flags);
@@ -1205,10 +1208,12 @@ struct vm_area_struct *vma_merge(struct mm_struct *mm,
vm_userfaultfd_ctx)) {
if (prev && addr < prev->vm_end) /* case 4 */
err = __vma_adjust(prev, prev->vm_start,
- addr, prev->vm_pgoff, NULL, next);
+ addr, prev->vm_pgoff, NULL, next,
+ keep_locked);
else { /* cases 3, 8 */
err = __vma_adjust(area, addr, next->vm_end,
- next->vm_pgoff - pglen, NULL, next);
+ next->vm_pgoff - pglen, NULL, next,
+ keep_locked);
/*
* In case 3 area is already equal to next and
* this is a noop, but in case 8 "area" has
@@ -3163,9 +3168,20 @@ struct vm_area_struct *copy_vma(struct vm_area_struct **vmap,
if (find_vma_links(mm, addr, addr + len, &prev, &rb_link, &rb_parent))
return NULL; /* should never get here */
- new_vma = vma_merge(mm, prev, addr, addr + len, vma->vm_flags,
- vma->anon_vma, vma->vm_file, pgoff, vma_policy(vma),
- vma->vm_userfaultfd_ctx);
+
+ /* There is 3 cases to manage here in
+ * AAAA AAAA AAAA AAAA
+ * PPPP.... PPPP......NNNN PPPP....NNNN PP........NN
+ * PPPPPPPP(A) PPPP..NNNNNNNN(B) PPPPPPPPPPPP(1) NULL
+ * PPPPPPPPNNNN(2)
+ * PPPPNNNNNNNN(3)
+ *
+ * new_vma == prev in case A,1,2
+ * new_vma == next in case B,3
+ */
+ new_vma = __vma_merge(mm, prev, addr, addr + len, vma->vm_flags,
+ vma->anon_vma, vma->vm_file, pgoff,
+ vma_policy(vma), vma->vm_userfaultfd_ctx, true);
if (new_vma) {
/*
* Source vma may have been merged into new_vma
@@ -3205,6 +3221,15 @@ struct vm_area_struct *copy_vma(struct vm_area_struct **vmap,
get_file(new_vma->vm_file);
if (new_vma->vm_ops && new_vma->vm_ops->open)
new_vma->vm_ops->open(new_vma);
+ /*
+ * As the VMA is linked right now, it may be hit by the
+ * speculative page fault handler. But we don't want it to
+ * to start mapping page in this area until the caller has
+ * potentially move the pte from the moved VMA. To prevent
+ * that we protect it right now, and let the caller unprotect
+ * it once the move is done.
+ */
+ vm_raw_write_begin(new_vma);
vma_link(mm, new_vma, prev, rb_link, rb_parent);
*need_rmap_locks = false;
}
diff --git a/mm/mremap.c b/mm/mremap.c
index 049470aa1e3e..8ed1a1d6eaed 100644
--- a/mm/mremap.c
+++ b/mm/mremap.c
@@ -302,6 +302,14 @@ static unsigned long move_vma(struct vm_area_struct *vma,
if (!new_vma)
return -ENOMEM;
+ /* new_vma is returned protected by copy_vma, to prevent speculative
+ * page fault to be done in the destination area before we move the pte.
+ * Now, we must also protect the source VMA since we don't want pages
+ * to be mapped in our back while we are copying the PTEs.
+ */
+ if (vma != new_vma)
+ vm_raw_write_begin(vma);
+
moved_len = move_page_tables(vma, old_addr, new_vma, new_addr, old_len,
need_rmap_locks);
if (moved_len < old_len) {
@@ -318,6 +326,8 @@ static unsigned long move_vma(struct vm_area_struct *vma,
*/
move_page_tables(new_vma, new_addr, vma, old_addr, moved_len,
true);
+ if (vma != new_vma)
+ vm_raw_write_end(vma);
vma = new_vma;
old_len = new_len;
old_addr = new_addr;
@@ -326,7 +336,10 @@ static unsigned long move_vma(struct vm_area_struct *vma,
mremap_userfaultfd_prep(new_vma, uf);
arch_remap(mm, old_addr, old_addr + old_len,
new_addr, new_addr + new_len);
+ if (vma != new_vma)
+ vm_raw_write_end(vma);
}
+ vm_raw_write_end(new_vma);
/* Conceal VM_ACCOUNT so old reservation is not undone */
if (vm_flags & VM_ACCOUNT) {
--
2.7.4
^ permalink raw reply related
* [PATCH v6 07/24] mm: Protect VMA modifications using VMA sequence count
From: Laurent Dufour @ 2018-01-12 17:25 UTC (permalink / raw)
To: paulmck, peterz, akpm, kirill, ak, mhocko, dave, jack,
Matthew Wilcox, benh, mpe, paulus, Thomas Gleixner, Ingo Molnar,
hpa, Will Deacon, Sergey Senozhatsky, Andrea Arcangeli,
Alexei Starovoitov, kemi.wang, sergey.senozhatsky.work
Cc: linux-kernel, linux-mm, haren, khandual, npiggin, bsingharora,
Tim Chen, linuxppc-dev, x86
In-Reply-To: <1515777968-867-1-git-send-email-ldufour@linux.vnet.ibm.com>
The VMA sequence count has been introduced to allow fast detection of
VMA modification when running a page fault handler without holding
the mmap_sem.
This patch provides protection against the VMA modification done in :
- madvise()
- mpol_rebind_policy()
- vma_replace_policy()
- change_prot_numa()
- mlock(), munlock()
- mprotect()
- mmap_region()
- collapse_huge_page()
- userfaultd registering services
In addition, VMA fields which will be read during the speculative fault
path needs to be written using WRITE_ONCE to prevent write to be split
and intermediate values to be pushed to other CPUs.
Signed-off-by: Laurent Dufour <ldufour@linux.vnet.ibm.com>
---
fs/proc/task_mmu.c | 5 ++++-
fs/userfaultfd.c | 17 +++++++++++++----
mm/khugepaged.c | 3 +++
mm/madvise.c | 6 +++++-
mm/mempolicy.c | 51 ++++++++++++++++++++++++++++++++++-----------------
mm/mlock.c | 13 ++++++++-----
mm/mmap.c | 17 ++++++++++-------
mm/mprotect.c | 4 +++-
mm/swap_state.c | 8 ++++++--
9 files changed, 86 insertions(+), 38 deletions(-)
diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index ec6d2983a5cb..e312d67e0297 100644
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -1155,8 +1155,11 @@ static ssize_t clear_refs_write(struct file *file, const char __user *buf,
goto out_mm;
}
for (vma = mm->mmap; vma; vma = vma->vm_next) {
- vma->vm_flags &= ~VM_SOFTDIRTY;
+ vm_write_begin(vma);
+ WRITE_ONCE(vma->vm_flags,
+ vma->vm_flags & ~VM_SOFTDIRTY);
vma_set_page_prot(vma);
+ vm_write_end(vma);
}
downgrade_write(&mm->mmap_sem);
break;
diff --git a/fs/userfaultfd.c b/fs/userfaultfd.c
index 87a13a7c8270..1da1ba63c7dd 100644
--- a/fs/userfaultfd.c
+++ b/fs/userfaultfd.c
@@ -659,8 +659,11 @@ int dup_userfaultfd(struct vm_area_struct *vma, struct list_head *fcs)
octx = vma->vm_userfaultfd_ctx.ctx;
if (!octx || !(octx->features & UFFD_FEATURE_EVENT_FORK)) {
+ vm_write_begin(vma);
vma->vm_userfaultfd_ctx = NULL_VM_UFFD_CTX;
- vma->vm_flags &= ~(VM_UFFD_WP | VM_UFFD_MISSING);
+ WRITE_ONCE(vma->vm_flags,
+ vma->vm_flags & ~(VM_UFFD_WP | VM_UFFD_MISSING));
+ vm_write_end(vma);
return 0;
}
@@ -885,8 +888,10 @@ static int userfaultfd_release(struct inode *inode, struct file *file)
vma = prev;
else
prev = vma;
- vma->vm_flags = new_flags;
+ vm_write_begin(vma);
+ WRITE_ONCE(vma->vm_flags, new_flags);
vma->vm_userfaultfd_ctx = NULL_VM_UFFD_CTX;
+ vm_write_end(vma);
}
up_write(&mm->mmap_sem);
mmput(mm);
@@ -1434,8 +1439,10 @@ static int userfaultfd_register(struct userfaultfd_ctx *ctx,
* the next vma was merged into the current one and
* the current one has not been updated yet.
*/
- vma->vm_flags = new_flags;
+ vm_write_begin(vma);
+ WRITE_ONCE(vma->vm_flags, new_flags);
vma->vm_userfaultfd_ctx.ctx = ctx;
+ vm_write_end(vma);
skip:
prev = vma;
@@ -1592,8 +1599,10 @@ static int userfaultfd_unregister(struct userfaultfd_ctx *ctx,
* the next vma was merged into the current one and
* the current one has not been updated yet.
*/
- vma->vm_flags = new_flags;
+ vm_write_begin(vma);
+ WRITE_ONCE(vma->vm_flags, new_flags);
vma->vm_userfaultfd_ctx = NULL_VM_UFFD_CTX;
+ vm_write_end(vma);
skip:
prev = vma;
diff --git a/mm/khugepaged.c b/mm/khugepaged.c
index b7e2268dfc9a..32314e9e48dd 100644
--- a/mm/khugepaged.c
+++ b/mm/khugepaged.c
@@ -1006,6 +1006,7 @@ static void collapse_huge_page(struct mm_struct *mm,
if (mm_find_pmd(mm, address) != pmd)
goto out;
+ vm_write_begin(vma);
anon_vma_lock_write(vma->anon_vma);
pte = pte_offset_map(pmd, address);
@@ -1041,6 +1042,7 @@ static void collapse_huge_page(struct mm_struct *mm,
pmd_populate(mm, pmd, pmd_pgtable(_pmd));
spin_unlock(pmd_ptl);
anon_vma_unlock_write(vma->anon_vma);
+ vm_write_end(vma);
result = SCAN_FAIL;
goto out;
}
@@ -1075,6 +1077,7 @@ static void collapse_huge_page(struct mm_struct *mm,
set_pmd_at(mm, address, pmd, _pmd);
update_mmu_cache_pmd(vma, address, pmd);
spin_unlock(pmd_ptl);
+ vm_write_end(vma);
*hpage = NULL;
diff --git a/mm/madvise.c b/mm/madvise.c
index 751e97aa2210..78774076a9ac 100644
--- a/mm/madvise.c
+++ b/mm/madvise.c
@@ -184,7 +184,9 @@ static long madvise_behavior(struct vm_area_struct *vma,
/*
* vm_flags is protected by the mmap_sem held in write mode.
*/
- vma->vm_flags = new_flags;
+ vm_write_begin(vma);
+ WRITE_ONCE(vma->vm_flags, new_flags);
+ vm_write_end(vma);
out:
return error;
}
@@ -450,9 +452,11 @@ static void madvise_free_page_range(struct mmu_gather *tlb,
.private = tlb,
};
+ vm_write_begin(vma);
tlb_start_vma(tlb, vma);
walk_page_range(addr, end, &free_walk);
tlb_end_vma(tlb, vma);
+ vm_write_end(vma);
}
static int madvise_free_single_vma(struct vm_area_struct *vma,
diff --git a/mm/mempolicy.c b/mm/mempolicy.c
index 30e68da64873..d95ce3d8480d 100644
--- a/mm/mempolicy.c
+++ b/mm/mempolicy.c
@@ -380,8 +380,11 @@ void mpol_rebind_mm(struct mm_struct *mm, nodemask_t *new)
struct vm_area_struct *vma;
down_write(&mm->mmap_sem);
- for (vma = mm->mmap; vma; vma = vma->vm_next)
+ for (vma = mm->mmap; vma; vma = vma->vm_next) {
+ vm_write_begin(vma);
mpol_rebind_policy(vma->vm_policy, new);
+ vm_write_end(vma);
+ }
up_write(&mm->mmap_sem);
}
@@ -554,9 +557,11 @@ unsigned long change_prot_numa(struct vm_area_struct *vma,
{
int nr_updated;
+ vm_write_begin(vma);
nr_updated = change_protection(vma, addr, end, PAGE_NONE, 0, 1);
if (nr_updated)
count_vm_numa_events(NUMA_PTE_UPDATES, nr_updated);
+ vm_write_end(vma);
return nr_updated;
}
@@ -657,6 +662,7 @@ static int vma_replace_policy(struct vm_area_struct *vma,
if (IS_ERR(new))
return PTR_ERR(new);
+ vm_write_begin(vma);
if (vma->vm_ops && vma->vm_ops->set_policy) {
err = vma->vm_ops->set_policy(vma, new);
if (err)
@@ -664,11 +670,17 @@ static int vma_replace_policy(struct vm_area_struct *vma,
}
old = vma->vm_policy;
- vma->vm_policy = new; /* protected by mmap_sem */
+ /*
+ * The speculative page fault handler access this field without
+ * hodling the mmap_sem.
+ */
+ WRITE_ONCE(vma->vm_policy, new);
+ vm_write_end(vma);
mpol_put(old);
return 0;
err_out:
+ vm_write_end(vma);
mpol_put(new);
return err;
}
@@ -1551,23 +1563,28 @@ COMPAT_SYSCALL_DEFINE6(mbind, compat_ulong_t, start, compat_ulong_t, len,
struct mempolicy *__get_vma_policy(struct vm_area_struct *vma,
unsigned long addr)
{
- struct mempolicy *pol = NULL;
+ struct mempolicy *pol;
- if (vma) {
- if (vma->vm_ops && vma->vm_ops->get_policy) {
- pol = vma->vm_ops->get_policy(vma, addr);
- } else if (vma->vm_policy) {
- pol = vma->vm_policy;
+ if (!vma)
+ return NULL;
- /*
- * shmem_alloc_page() passes MPOL_F_SHARED policy with
- * a pseudo vma whose vma->vm_ops=NULL. Take a reference
- * count on these policies which will be dropped by
- * mpol_cond_put() later
- */
- if (mpol_needs_cond_ref(pol))
- mpol_get(pol);
- }
+ if (vma->vm_ops && vma->vm_ops->get_policy)
+ return vma->vm_ops->get_policy(vma, addr);
+
+ /*
+ * This could be called without holding the mmap_sem in the
+ * speculative page fault handler's path.
+ */
+ pol = READ_ONCE(vma->vm_policy);
+ if (pol) {
+ /*
+ * shmem_alloc_page() passes MPOL_F_SHARED policy with
+ * a pseudo vma whose vma->vm_ops=NULL. Take a reference
+ * count on these policies which will be dropped by
+ * mpol_cond_put() later
+ */
+ if (mpol_needs_cond_ref(pol))
+ mpol_get(pol);
}
return pol;
diff --git a/mm/mlock.c b/mm/mlock.c
index 16fc7411bd81..bdb311dd01f8 100644
--- a/mm/mlock.c
+++ b/mm/mlock.c
@@ -445,7 +445,9 @@ static unsigned long __munlock_pagevec_fill(struct pagevec *pvec,
void munlock_vma_pages_range(struct vm_area_struct *vma,
unsigned long start, unsigned long end)
{
- vma->vm_flags &= VM_LOCKED_CLEAR_MASK;
+ vm_write_begin(vma);
+ WRITE_ONCE(vma->vm_flags, vma->vm_flags & VM_LOCKED_CLEAR_MASK);
+ vm_write_end(vma);
while (start < end) {
struct page *page;
@@ -568,10 +570,11 @@ static int mlock_fixup(struct vm_area_struct *vma, struct vm_area_struct **prev,
* It's okay if try_to_unmap_one unmaps a page just after we
* set VM_LOCKED, populate_vma_page_range will bring it back.
*/
-
- if (lock)
- vma->vm_flags = newflags;
- else
+ if (lock) {
+ vm_write_begin(vma);
+ WRITE_ONCE(vma->vm_flags, newflags);
+ vm_write_end(vma);
+ } else
munlock_vma_pages_range(vma, start, end);
out:
diff --git a/mm/mmap.c b/mm/mmap.c
index 1dc5397fbd59..73e740291a3a 100644
--- a/mm/mmap.c
+++ b/mm/mmap.c
@@ -847,17 +847,18 @@ int __vma_adjust(struct vm_area_struct *vma, unsigned long start,
}
if (start != vma->vm_start) {
- vma->vm_start = start;
+ WRITE_ONCE(vma->vm_start, start);
start_changed = true;
}
if (end != vma->vm_end) {
- vma->vm_end = end;
+ WRITE_ONCE(vma->vm_end, end);
end_changed = true;
}
- vma->vm_pgoff = pgoff;
+ WRITE_ONCE(vma->vm_pgoff, pgoff);
if (adjust_next) {
- next->vm_start += adjust_next << PAGE_SHIFT;
- next->vm_pgoff += adjust_next;
+ WRITE_ONCE(next->vm_start,
+ next->vm_start + (adjust_next << PAGE_SHIFT));
+ WRITE_ONCE(next->vm_pgoff, next->vm_pgoff + adjust_next);
}
if (root) {
@@ -1781,6 +1782,7 @@ unsigned long mmap_region(struct file *file, unsigned long addr,
out:
perf_event_mmap(vma);
+ vm_write_begin(vma);
vm_stat_account(mm, vm_flags, len >> PAGE_SHIFT);
if (vm_flags & VM_LOCKED) {
if (!((vm_flags & VM_SPECIAL) || is_vm_hugetlb_page(vma) ||
@@ -1803,6 +1805,7 @@ unsigned long mmap_region(struct file *file, unsigned long addr,
vma->vm_flags |= VM_SOFTDIRTY;
vma_set_page_prot(vma);
+ vm_write_end(vma);
return addr;
@@ -2431,8 +2434,8 @@ int expand_downwards(struct vm_area_struct *vma,
mm->locked_vm += grow;
vm_stat_account(mm, vma->vm_flags, grow);
anon_vma_interval_tree_pre_update_vma(vma);
- vma->vm_start = address;
- vma->vm_pgoff -= grow;
+ WRITE_ONCE(vma->vm_start, address);
+ WRITE_ONCE(vma->vm_pgoff, vma->vm_pgoff - grow);
anon_vma_interval_tree_post_update_vma(vma);
vma_gap_update(vma);
spin_unlock(&mm->page_table_lock);
diff --git a/mm/mprotect.c b/mm/mprotect.c
index 58b629bb70de..3b68a3bdb57c 100644
--- a/mm/mprotect.c
+++ b/mm/mprotect.c
@@ -361,7 +361,8 @@ mprotect_fixup(struct vm_area_struct *vma, struct vm_area_struct **pprev,
* vm_flags and vm_page_prot are protected by the mmap_sem
* held in write mode.
*/
- vma->vm_flags = newflags;
+ vm_write_begin(vma);
+ WRITE_ONCE(vma->vm_flags, newflags);
dirty_accountable = vma_wants_writenotify(vma, vma->vm_page_prot);
vma_set_page_prot(vma);
@@ -376,6 +377,7 @@ mprotect_fixup(struct vm_area_struct *vma, struct vm_area_struct **pprev,
(newflags & VM_WRITE)) {
populate_vma_page_range(vma, start, end, NULL);
}
+ vm_write_end(vma);
vm_stat_account(mm, oldflags, -nrpages);
vm_stat_account(mm, newflags, nrpages);
diff --git a/mm/swap_state.c b/mm/swap_state.c
index 39ae7cfad90f..eeef59c2cd76 100644
--- a/mm/swap_state.c
+++ b/mm/swap_state.c
@@ -550,6 +550,10 @@ static unsigned long swapin_nr_pages(unsigned long offset)
* the readahead.
*
* Caller must hold down_read on the vma->vm_mm if vma is not NULL.
+ * This is needed to ensure the VMA will not be freed in our back. In the case
+ * of the speculative page fault handler, this cannot happen, even if we don't
+ * hold the mmap_sem. Callees are assumed to take care of reading VMA's fields
+ * using READ_ONCE() to read consistent values.
*/
struct page *swapin_readahead(swp_entry_t entry, gfp_t gfp_mask,
struct vm_area_struct *vma, unsigned long addr)
@@ -643,9 +647,9 @@ static inline void swap_ra_clamp_pfn(struct vm_area_struct *vma,
unsigned long *start,
unsigned long *end)
{
- *start = max3(lpfn, PFN_DOWN(vma->vm_start),
+ *start = max3(lpfn, PFN_DOWN(READ_ONCE(vma->vm_start)),
PFN_DOWN(faddr & PMD_MASK));
- *end = min3(rpfn, PFN_DOWN(vma->vm_end),
+ *end = min3(rpfn, PFN_DOWN(READ_ONCE(vma->vm_end)),
PFN_DOWN((faddr & PMD_MASK) + PMD_SIZE));
}
--
2.7.4
^ permalink raw reply related
* [PATCH v6 06/24] mm: VMA sequence count
From: Laurent Dufour @ 2018-01-12 17:25 UTC (permalink / raw)
To: paulmck, peterz, akpm, kirill, ak, mhocko, dave, jack,
Matthew Wilcox, benh, mpe, paulus, Thomas Gleixner, Ingo Molnar,
hpa, Will Deacon, Sergey Senozhatsky, Andrea Arcangeli,
Alexei Starovoitov, kemi.wang, sergey.senozhatsky.work
Cc: linux-kernel, linux-mm, haren, khandual, npiggin, bsingharora,
Tim Chen, linuxppc-dev, x86
In-Reply-To: <1515777968-867-1-git-send-email-ldufour@linux.vnet.ibm.com>
From: Peter Zijlstra <peterz@infradead.org>
Wrap the VMA modifications (vma_adjust/unmap_page_range) with sequence
counts such that we can easily test if a VMA is changed.
The unmap_page_range() one allows us to make assumptions about
page-tables; when we find the seqcount hasn't changed we can assume
page-tables are still valid.
The flip side is that we cannot distinguish between a vma_adjust() and
the unmap_page_range() -- where with the former we could have
re-checked the vma bounds against the address.
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
[Port to 4.12 kernel]
[Build depends on CONFIG_SPF]
[Introduce vm_write_* inline function depending on CONFIG_SPF]
[Fix lock dependency between mapping->i_mmap_rwsem and vma->vm_sequence by
using vm_raw_write* functions]
Signed-off-by: Laurent Dufour <ldufour@linux.vnet.ibm.com>
---
include/linux/mm.h | 41 +++++++++++++++++++++++++++++++++++++++++
include/linux/mm_types.h | 3 +++
mm/memory.c | 2 ++
mm/mmap.c | 35 +++++++++++++++++++++++++++++++++++
4 files changed, 81 insertions(+)
diff --git a/include/linux/mm.h b/include/linux/mm.h
index ad299ed7b85c..ca7ceba84292 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -1369,6 +1369,47 @@ static inline void unmap_shared_mapping_range(struct address_space *mapping,
unmap_mapping_range(mapping, holebegin, holelen, 0);
}
+#ifdef CONFIG_SPF
+static inline void vm_write_begin(struct vm_area_struct *vma)
+{
+ write_seqcount_begin(&vma->vm_sequence);
+}
+static inline void vm_write_begin_nested(struct vm_area_struct *vma,
+ int subclass)
+{
+ write_seqcount_begin_nested(&vma->vm_sequence, subclass);
+}
+static inline void vm_write_end(struct vm_area_struct *vma)
+{
+ write_seqcount_end(&vma->vm_sequence);
+}
+static inline void vm_raw_write_begin(struct vm_area_struct *vma)
+{
+ raw_write_seqcount_begin(&vma->vm_sequence);
+}
+static inline void vm_raw_write_end(struct vm_area_struct *vma)
+{
+ raw_write_seqcount_end(&vma->vm_sequence);
+}
+#else
+static inline void vm_write_begin(struct vm_area_struct *vma)
+{
+}
+static inline void vm_write_begin_nested(struct vm_area_struct *vma,
+ int subclass)
+{
+}
+static inline void vm_write_end(struct vm_area_struct *vma)
+{
+}
+static inline void vm_raw_write_begin(struct vm_area_struct *vma)
+{
+}
+static inline void vm_raw_write_end(struct vm_area_struct *vma)
+{
+}
+#endif /* CONFIG_SPF */
+
extern int access_process_vm(struct task_struct *tsk, unsigned long addr,
void *buf, int len, unsigned int gup_flags);
extern int access_remote_vm(struct mm_struct *mm, unsigned long addr,
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index fd1af6b9591d..e0e3df3b9641 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -333,6 +333,9 @@ struct vm_area_struct {
struct mempolicy *vm_policy; /* NUMA policy for the VMA */
#endif
struct vm_userfaultfd_ctx vm_userfaultfd_ctx;
+#ifdef CONFIG_SPF
+ seqcount_t vm_sequence;
+#endif
} __randomize_layout;
struct core_thread {
diff --git a/mm/memory.c b/mm/memory.c
index 6b2c4732e49d..22bdc5c6c5ee 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -1503,6 +1503,7 @@ void unmap_page_range(struct mmu_gather *tlb,
unsigned long next;
BUG_ON(addr >= end);
+ vm_write_begin(vma);
tlb_start_vma(tlb, vma);
pgd = pgd_offset(vma->vm_mm, addr);
do {
@@ -1512,6 +1513,7 @@ void unmap_page_range(struct mmu_gather *tlb,
next = zap_p4d_range(tlb, vma, pgd, addr, next, details);
} while (pgd++, addr = next, addr != end);
tlb_end_vma(tlb, vma);
+ vm_write_end(vma);
}
diff --git a/mm/mmap.c b/mm/mmap.c
index 4bb038e7984b..1dc5397fbd59 100644
--- a/mm/mmap.c
+++ b/mm/mmap.c
@@ -558,6 +558,10 @@ void __vma_link_rb(struct mm_struct *mm, struct vm_area_struct *vma,
else
mm->highest_vm_end = vm_end_gap(vma);
+#ifdef CONFIG_SPF
+ seqcount_init(&vma->vm_sequence);
+#endif
+
/*
* vma->vm_prev wasn't known when we followed the rbtree to find the
* correct insertion point for that vma. As a result, we could not
@@ -692,6 +696,30 @@ int __vma_adjust(struct vm_area_struct *vma, unsigned long start,
long adjust_next = 0;
int remove_next = 0;
+ /*
+ * Why using vm_raw_write*() functions here to avoid lockdep's warning ?
+ *
+ * Locked is complaining about a theoretical lock dependency, involving
+ * 3 locks:
+ * mapping->i_mmap_rwsem --> vma->vm_sequence --> fs_reclaim
+ *
+ * Here are the major path leading to this dependency :
+ * 1. __vma_adjust() mmap_sem -> vm_sequence -> i_mmap_rwsem
+ * 2. move_vmap() mmap_sem -> vm_sequence -> fs_reclaim
+ * 3. __alloc_pages_nodemask() fs_reclaim -> i_mmap_rwsem
+ * 4. unmap_mapping_range() i_mmap_rwsem -> vm_sequence
+ *
+ * So there is no way to solve this easily, especially because in
+ * unmap_mapping_range() the i_mmap_rwsem is grab while the impacted
+ * VMAs are not yet known.
+ * However, the way the vm_seq is used is guarantying that we will
+ * never block on it since we just check for its value and never wait
+ * for it to move, see vma_has_changed() and handle_speculative_fault().
+ */
+ vm_raw_write_begin(vma);
+ if (next)
+ vm_raw_write_begin(next);
+
if (next && !insert) {
struct vm_area_struct *exporter = NULL, *importer = NULL;
@@ -902,6 +930,7 @@ int __vma_adjust(struct vm_area_struct *vma, unsigned long start,
anon_vma_merge(vma, next);
mm->map_count--;
mpol_put(vma_policy(next));
+ vm_raw_write_end(next);
kmem_cache_free(vm_area_cachep, next);
/*
* In mprotect's case 6 (see comments on vma_merge),
@@ -916,6 +945,8 @@ int __vma_adjust(struct vm_area_struct *vma, unsigned long start,
* "vma->vm_next" gap must be updated.
*/
next = vma->vm_next;
+ if (next)
+ vm_raw_write_begin(next);
} else {
/*
* For the scope of the comment "next" and
@@ -962,6 +993,10 @@ int __vma_adjust(struct vm_area_struct *vma, unsigned long start,
if (insert && file)
uprobe_mmap(insert);
+ if (next && next != vma)
+ vm_raw_write_end(next);
+ vm_raw_write_end(vma);
+
validate_mm(mm);
return 0;
--
2.7.4
^ permalink raw reply related
* [PATCH v6 05/24] mm: Introduce pte_spinlock for FAULT_FLAG_SPECULATIVE
From: Laurent Dufour @ 2018-01-12 17:25 UTC (permalink / raw)
To: paulmck, peterz, akpm, kirill, ak, mhocko, dave, jack,
Matthew Wilcox, benh, mpe, paulus, Thomas Gleixner, Ingo Molnar,
hpa, Will Deacon, Sergey Senozhatsky, Andrea Arcangeli,
Alexei Starovoitov, kemi.wang, sergey.senozhatsky.work
Cc: linux-kernel, linux-mm, haren, khandual, npiggin, bsingharora,
Tim Chen, linuxppc-dev, x86
In-Reply-To: <1515777968-867-1-git-send-email-ldufour@linux.vnet.ibm.com>
When handling page fault without holding the mmap_sem the fetch of the
pte lock pointer and the locking will have to be done while ensuring
that the VMA is not touched in our back.
So move the fetch and locking operations in a dedicated function.
Signed-off-by: Laurent Dufour <ldufour@linux.vnet.ibm.com>
---
mm/memory.c | 15 +++++++++++----
1 file changed, 11 insertions(+), 4 deletions(-)
diff --git a/mm/memory.c b/mm/memory.c
index 868424ab850c..6b2c4732e49d 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -2438,6 +2438,13 @@ static inline void wp_page_reuse(struct vm_fault *vmf)
pte_unmap_unlock(vmf->pte, vmf->ptl);
}
+static bool pte_spinlock(struct vm_fault *vmf)
+{
+ vmf->ptl = pte_lockptr(vmf->vma->vm_mm, vmf->pmd);
+ spin_lock(vmf->ptl);
+ return true;
+}
+
static bool pte_map_lock(struct vm_fault *vmf)
{
vmf->pte = pte_offset_map_lock(vmf->vma->vm_mm, vmf->pmd,
@@ -3805,8 +3812,8 @@ static int do_numa_page(struct vm_fault *vmf)
* validation through pte_unmap_same(). It's of NUMA type but
* the pfn may be screwed if the read is non atomic.
*/
- vmf->ptl = pte_lockptr(vma->vm_mm, vmf->pmd);
- spin_lock(vmf->ptl);
+ if (!pte_spinlock(vmf))
+ return VM_FAULT_RETRY;
if (unlikely(!pte_same(*vmf->pte, vmf->orig_pte))) {
pte_unmap_unlock(vmf->pte, vmf->ptl);
goto out;
@@ -3999,8 +4006,8 @@ static int handle_pte_fault(struct vm_fault *vmf)
if (pte_protnone(vmf->orig_pte) && vma_is_accessible(vmf->vma))
return do_numa_page(vmf);
- vmf->ptl = pte_lockptr(vmf->vma->vm_mm, vmf->pmd);
- spin_lock(vmf->ptl);
+ if (!pte_spinlock(vmf))
+ return VM_FAULT_RETRY;
entry = vmf->orig_pte;
if (unlikely(!pte_same(*vmf->pte, entry)))
goto unlock;
--
2.7.4
^ permalink raw reply related
* [PATCH v6 04/24] mm: Prepare for FAULT_FLAG_SPECULATIVE
From: Laurent Dufour @ 2018-01-12 17:25 UTC (permalink / raw)
To: paulmck, peterz, akpm, kirill, ak, mhocko, dave, jack,
Matthew Wilcox, benh, mpe, paulus, Thomas Gleixner, Ingo Molnar,
hpa, Will Deacon, Sergey Senozhatsky, Andrea Arcangeli,
Alexei Starovoitov, kemi.wang, sergey.senozhatsky.work
Cc: linux-kernel, linux-mm, haren, khandual, npiggin, bsingharora,
Tim Chen, linuxppc-dev, x86
In-Reply-To: <1515777968-867-1-git-send-email-ldufour@linux.vnet.ibm.com>
From: Peter Zijlstra <peterz@infradead.org>
When speculating faults (without holding mmap_sem) we need to validate
that the vma against which we loaded pages is still valid when we're
ready to install the new PTE.
Therefore, replace the pte_offset_map_lock() calls that (re)take the
PTL with pte_map_lock() which can fail in case we find the VMA changed
since we started the fault.
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
[Port to 4.12 kernel]
[Remove the comment about the fault_env structure which has been
implemented as the vm_fault structure in the kernel]
Signed-off-by: Laurent Dufour <ldufour@linux.vnet.ibm.com>
---
include/linux/mm.h | 1 +
mm/memory.c | 56 ++++++++++++++++++++++++++++++++++++++----------------
2 files changed, 41 insertions(+), 16 deletions(-)
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 63f7ba111f64..ad299ed7b85c 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -302,6 +302,7 @@ extern pgprot_t protection_map[16];
#define FAULT_FLAG_USER 0x40 /* The fault originated in userspace */
#define FAULT_FLAG_REMOTE 0x80 /* faulting for non current tsk/mm */
#define FAULT_FLAG_INSTRUCTION 0x100 /* The fault was during an instruction fetch */
+#define FAULT_FLAG_SPECULATIVE 0x200 /* Speculative fault, not holding mmap_sem */
#define FAULT_FLAG_TRACE \
{ FAULT_FLAG_WRITE, "WRITE" }, \
diff --git a/mm/memory.c b/mm/memory.c
index 259f621345b2..868424ab850c 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -2438,6 +2438,13 @@ static inline void wp_page_reuse(struct vm_fault *vmf)
pte_unmap_unlock(vmf->pte, vmf->ptl);
}
+static bool pte_map_lock(struct vm_fault *vmf)
+{
+ vmf->pte = pte_offset_map_lock(vmf->vma->vm_mm, vmf->pmd,
+ vmf->address, &vmf->ptl);
+ return true;
+}
+
/*
* Handle the case of a page which we actually need to copy to a new page.
*
@@ -2465,6 +2472,7 @@ static int wp_page_copy(struct vm_fault *vmf)
const unsigned long mmun_start = vmf->address & PAGE_MASK;
const unsigned long mmun_end = mmun_start + PAGE_SIZE;
struct mem_cgroup *memcg;
+ int ret = VM_FAULT_OOM;
if (unlikely(anon_vma_prepare(vma)))
goto oom;
@@ -2492,7 +2500,11 @@ static int wp_page_copy(struct vm_fault *vmf)
/*
* Re-check the pte - we dropped the lock
*/
- vmf->pte = pte_offset_map_lock(mm, vmf->pmd, vmf->address, &vmf->ptl);
+ if (!pte_map_lock(vmf)) {
+ mem_cgroup_cancel_charge(new_page, memcg, false);
+ ret = VM_FAULT_RETRY;
+ goto oom_free_new;
+ }
if (likely(pte_same(*vmf->pte, vmf->orig_pte))) {
if (old_page) {
if (!PageAnon(old_page)) {
@@ -2584,7 +2596,7 @@ static int wp_page_copy(struct vm_fault *vmf)
oom:
if (old_page)
put_page(old_page);
- return VM_FAULT_OOM;
+ return ret;
}
/**
@@ -2605,8 +2617,8 @@ static int wp_page_copy(struct vm_fault *vmf)
int finish_mkwrite_fault(struct vm_fault *vmf)
{
WARN_ON_ONCE(!(vmf->vma->vm_flags & VM_SHARED));
- vmf->pte = pte_offset_map_lock(vmf->vma->vm_mm, vmf->pmd, vmf->address,
- &vmf->ptl);
+ if (!pte_map_lock(vmf))
+ return VM_FAULT_RETRY;
/*
* We might have raced with another page fault while we released the
* pte_offset_map_lock.
@@ -2724,8 +2736,11 @@ static int do_wp_page(struct vm_fault *vmf)
get_page(vmf->page);
pte_unmap_unlock(vmf->pte, vmf->ptl);
lock_page(vmf->page);
- vmf->pte = pte_offset_map_lock(vma->vm_mm, vmf->pmd,
- vmf->address, &vmf->ptl);
+ if (!pte_map_lock(vmf)) {
+ unlock_page(vmf->page);
+ put_page(vmf->page);
+ return VM_FAULT_RETRY;
+ }
if (!pte_same(*vmf->pte, vmf->orig_pte)) {
unlock_page(vmf->page);
pte_unmap_unlock(vmf->pte, vmf->ptl);
@@ -2953,8 +2968,10 @@ int do_swap_page(struct vm_fault *vmf)
* Back out if somebody else faulted in this pte
* while we released the pte lock.
*/
- vmf->pte = pte_offset_map_lock(vma->vm_mm, vmf->pmd,
- vmf->address, &vmf->ptl);
+ if (!pte_map_lock(vmf)) {
+ delayacct_clear_flag(DELAYACCT_PF_SWAPIN);
+ return VM_FAULT_RETRY;
+ }
if (likely(pte_same(*vmf->pte, vmf->orig_pte)))
ret = VM_FAULT_OOM;
delayacct_clear_flag(DELAYACCT_PF_SWAPIN);
@@ -3010,8 +3027,11 @@ int do_swap_page(struct vm_fault *vmf)
/*
* Back out if somebody else already faulted in this pte.
*/
- vmf->pte = pte_offset_map_lock(vma->vm_mm, vmf->pmd, vmf->address,
- &vmf->ptl);
+ if (!pte_map_lock(vmf)) {
+ ret = VM_FAULT_RETRY;
+ mem_cgroup_cancel_charge(page, memcg, false);
+ goto out_page;
+ }
if (unlikely(!pte_same(*vmf->pte, vmf->orig_pte)))
goto out_nomap;
@@ -3140,8 +3160,8 @@ static int do_anonymous_page(struct vm_fault *vmf)
!mm_forbids_zeropage(vma->vm_mm)) {
entry = pte_mkspecial(pfn_pte(my_zero_pfn(vmf->address),
vma->vm_page_prot));
- vmf->pte = pte_offset_map_lock(vma->vm_mm, vmf->pmd,
- vmf->address, &vmf->ptl);
+ if (!pte_map_lock(vmf))
+ return VM_FAULT_RETRY;
if (!pte_none(*vmf->pte))
goto unlock;
ret = check_stable_address_space(vma->vm_mm);
@@ -3176,8 +3196,11 @@ static int do_anonymous_page(struct vm_fault *vmf)
if (vma->vm_flags & VM_WRITE)
entry = pte_mkwrite(pte_mkdirty(entry));
- vmf->pte = pte_offset_map_lock(vma->vm_mm, vmf->pmd, vmf->address,
- &vmf->ptl);
+ if (!pte_map_lock(vmf)) {
+ mem_cgroup_cancel_charge(page, memcg, false);
+ put_page(page);
+ return VM_FAULT_RETRY;
+ }
if (!pte_none(*vmf->pte))
goto release;
@@ -3301,8 +3324,9 @@ static int pte_alloc_one_map(struct vm_fault *vmf)
* pte_none() under vmf->ptl protection when we return to
* alloc_set_pte().
*/
- vmf->pte = pte_offset_map_lock(vma->vm_mm, vmf->pmd, vmf->address,
- &vmf->ptl);
+ if (!pte_map_lock(vmf))
+ return VM_FAULT_RETRY;
+
return 0;
}
--
2.7.4
^ permalink raw reply related
* [PATCH v6 03/24] mm: Dont assume page-table invariance during faults
From: Laurent Dufour @ 2018-01-12 17:25 UTC (permalink / raw)
To: paulmck, peterz, akpm, kirill, ak, mhocko, dave, jack,
Matthew Wilcox, benh, mpe, paulus, Thomas Gleixner, Ingo Molnar,
hpa, Will Deacon, Sergey Senozhatsky, Andrea Arcangeli,
Alexei Starovoitov, kemi.wang, sergey.senozhatsky.work
Cc: linux-kernel, linux-mm, haren, khandual, npiggin, bsingharora,
Tim Chen, linuxppc-dev, x86
In-Reply-To: <1515777968-867-1-git-send-email-ldufour@linux.vnet.ibm.com>
From: Peter Zijlstra <peterz@infradead.org>
One of the side effects of speculating on faults (without holding
mmap_sem) is that we can race with free_pgtables() and therefore we
cannot assume the page-tables will stick around.
Remove the reliance on the pte pointer.
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
[Remove only if !CONFIG_SPF]
Signed-off-by: Laurent Dufour <ldufour@linux.vnet.ibm.com>
---
mm/memory.c | 4 ++++
1 file changed, 4 insertions(+)
diff --git a/mm/memory.c b/mm/memory.c
index 8a80986fff48..259f621345b2 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -2274,6 +2274,7 @@ int apply_to_page_range(struct mm_struct *mm, unsigned long addr,
}
EXPORT_SYMBOL_GPL(apply_to_page_range);
+#ifndef CONFIG_SPF
/*
* handle_pte_fault chooses page fault handler according to an entry which was
* read non-atomically. Before making any commitment, on those architectures
@@ -2297,6 +2298,7 @@ static inline int pte_unmap_same(struct mm_struct *mm, pmd_t *pmd,
pte_unmap(page_table);
return same;
}
+#endif /* CONFIG_SPF */
static inline void cow_user_page(struct page *dst, struct page *src, unsigned long va, struct vm_area_struct *vma)
{
@@ -2884,11 +2886,13 @@ int do_swap_page(struct vm_fault *vmf)
swapcache = page;
}
+#ifndef CONFIG_SPF
if (!pte_unmap_same(vma->vm_mm, vmf->pmd, vmf->pte, vmf->orig_pte)) {
if (page)
put_page(page);
goto out;
}
+#endif
entry = pte_to_swp_entry(vmf->orig_pte);
if (unlikely(non_swap_entry(entry))) {
--
2.7.4
^ permalink raw reply related
* [PATCH v6 01/24] x86/mm: Define CONFIG_SPF
From: Laurent Dufour @ 2018-01-12 17:25 UTC (permalink / raw)
To: paulmck, peterz, akpm, kirill, ak, mhocko, dave, jack,
Matthew Wilcox, benh, mpe, paulus, Thomas Gleixner, Ingo Molnar,
hpa, Will Deacon, Sergey Senozhatsky, Andrea Arcangeli,
Alexei Starovoitov, kemi.wang, sergey.senozhatsky.work
Cc: linux-kernel, linux-mm, haren, khandual, npiggin, bsingharora,
Tim Chen, linuxppc-dev, x86
In-Reply-To: <1515777968-867-1-git-send-email-ldufour@linux.vnet.ibm.com>
Introduce CONFIG_SPF which turns on the Speculative Page Fault handler when
building for 64bits with SMP.
Signed-off-by: Laurent Dufour <ldufour@linux.vnet.ibm.com>
---
arch/x86/Kconfig | 4 ++++
1 file changed, 4 insertions(+)
diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
index a317d5594b6a..d74353b85aaf 100644
--- a/arch/x86/Kconfig
+++ b/arch/x86/Kconfig
@@ -2882,6 +2882,10 @@ config X86_DMA_REMAP
config HAVE_GENERIC_GUP
def_bool y
+config SPF
+ def_bool y
+ depends on X86_64 && SMP
+
source "net/Kconfig"
source "drivers/Kconfig"
--
2.7.4
^ permalink raw reply related
* [PATCH v6 02/24] powerpc/mm: Define CONFIG_SPF
From: Laurent Dufour @ 2018-01-12 17:25 UTC (permalink / raw)
To: paulmck, peterz, akpm, kirill, ak, mhocko, dave, jack,
Matthew Wilcox, benh, mpe, paulus, Thomas Gleixner, Ingo Molnar,
hpa, Will Deacon, Sergey Senozhatsky, Andrea Arcangeli,
Alexei Starovoitov, kemi.wang, sergey.senozhatsky.work
Cc: linux-kernel, linux-mm, haren, khandual, npiggin, bsingharora,
Tim Chen, linuxppc-dev, x86
In-Reply-To: <1515777968-867-1-git-send-email-ldufour@linux.vnet.ibm.com>
Define CONFIG_SPF for BOOK3S_64 and SMP. This enables the Speculative Page
Fault handler.
Support is only provide for BOOK3S_64 currently because:
- require CONFIG_PPC_STD_MMU because checks done in
set_access_flags_filter()
- require BOOK3S because we can't support for book3e_hugetlb_preload()
called by update_mmu_cache()
Signed-off-by: Laurent Dufour <ldufour@linux.vnet.ibm.com>
---
arch/powerpc/Kconfig | 4 ++++
1 file changed, 4 insertions(+)
diff --git a/arch/powerpc/Kconfig b/arch/powerpc/Kconfig
index d99250d9185d..31be1d69b350 100644
--- a/arch/powerpc/Kconfig
+++ b/arch/powerpc/Kconfig
@@ -1209,6 +1209,10 @@ endif
config ARCH_RANDOM
def_bool n
+config SPF
+ def_bool y
+ depends on PPC_BOOK3S_64 && SMP
+
source "net/Kconfig"
source "drivers/Kconfig"
--
2.7.4
^ permalink raw reply related
* [PATCH v6 00/24] Speculative page faults
From: Laurent Dufour @ 2018-01-12 17:25 UTC (permalink / raw)
To: paulmck, peterz, akpm, kirill, ak, mhocko, dave, jack,
Matthew Wilcox, benh, mpe, paulus, Thomas Gleixner, Ingo Molnar,
hpa, Will Deacon, Sergey Senozhatsky, Andrea Arcangeli,
Alexei Starovoitov, kemi.wang, sergey.senozhatsky.work
Cc: linux-kernel, linux-mm, haren, khandual, npiggin, bsingharora,
Tim Chen, linuxppc-dev, x86
This is a port on kernel 4.15 of the work done by Peter Zijlstra to handle
page fault without holding the mm semaphore [1].
The idea is to try to handle user space page faults without holding the
mmap_sem. This should allow better concurrency for massively threaded
process since the page fault handler will not wait for other threads memory
layout change to be done, assuming that this change is done in another part
of the process's memory space. This type page fault is named speculative
page fault. If the speculative page fault fails because of a concurrency is
detected or because underlying PMD or PTE tables are not yet allocating, it
is failing its processing and a classic page fault is then tried.
The speculative page fault (SPF) has to look for the VMA matching the fault
address without holding the mmap_sem, this is done by introducing a rwlock
which protects the access to the mm_rb tree. Previously this was done using
SRCU but it was introducing a lot of scheduling to process the VMA's
freeing operation which was hitting the performance by 20% as reported by
Kemi Wang [2].Using a rwlock to protect access to the mm_rb tree is
limiting the locking contention to these operations which are expected to
be in a O(log n) order. In addition to ensure that the VMA is not freed in
our back a reference count is added and 2 services (get_vma() and
put_vma()) are introduced to handle the reference count. When a VMA is
fetch from the RB tree using get_vma() is must be later freeed using
put_vma(). Furthermore, to allow the VMA to be used again by the classic
page fault handler a service is introduced can_reuse_spf_vma(). This
service is expected to be called with the mmap_sem hold. It checked that
the VMA is still matching the specified address and is releasing its
reference count as the mmap_sem is hold it is ensure that it will not be
freed in our back. In general, the VMA's reference count could be
decremented when holding the mmap_sem but it should not be increased as
holding the mmap_sem is ensuring that the VMA is stable. I can't see
anymore the overhead I got while will-it-scale benchmark anymore.
The VMA's attributes checked during the speculative page fault processing
have to be protected against parallel changes. This is done by using a per
VMA sequence lock. This sequence lock allows the speculative page fault
handler to fast check for parallel changes in progress and to abort the
speculative page fault in that case.
Once the VMA is found, the speculative page fault handler would check for
the VMA's attributes to verify that the page fault has to be handled
correctly or not. Thus the VMA is protected through a sequence lock which
allows fast detection of concurrent VMA changes. If such a change is
detected, the speculative page fault is aborted and a *classic* page fault
is tried. VMA sequence lockings are added when VMA attributes which are
checked during the page fault are modified.
When the PTE is fetched, the VMA is checked to see if it has been changed,
so once the page table is locked, the VMA is valid, so any other changes
leading to touching this PTE will need to lock the page table, so no
parallel change is possible at this time.
The locking of the PTE is done with interrupts disabled, this allows to
check for the PMD to ensure that there is not an ongoing collapsing
operation. Since khugepaged is firstly set the PMD to pmd_none and then is
waiting for the other CPU to have catch the IPI interrupt, if the pmd is
valid at the time the PTE is locked, we have the guarantee that the
collapsing opertion will have to wait on the PTE lock to move foward. This
allows the SPF handler to map the PTE safely. If the PMD value is different
than the one recorded at the beginning of the SPF operation, the classic
page fault handler will be called to handle the operation while holding the
mmap_sem. As the PTE lock is done with the interrupts disabled, the lock is
done using spin_trylock() to avoid dead lock when handling a page fault
while a TLB invalidate is requested by an other CPU holding the PTE.
Support for THP is not done because when checking for the PMD, we can be
confused by an in progress collapsing operation done by khugepaged. The
issue is that pmd_none() could be true either if the PMD is not already
populate or if the underlying PTE are in the way to be collapsed. So we
cannot safely allocate a PMD if pmd_none() is true.
This series builds on top of v4.14-rc5 and is functional on x86 and
PowerPC.
------------------
Benchmarks results
Base kernel is 4.15-rc6-mmotm-2018-01-04-16-19
SPF is BASE + this series
Kernbench:
----------
Here are the results on a 16 CPUs X86 guest using kernbench on a 4.13-rc4
kernel (kernel is build 5 times):
Average Optimal load -j 8
Base SPF
Run (std deviation)
Elapsed Time 148.04 (0.62446) 150.31 (0.940585) 1.53%
User Time 1017.27 (1.23567) 1029.14 (4.43995) 1.17%
System Time 112.53 (0.888285) 118.62 (0.712215) 5.41%
Percent CPU 762.6 (2.30217) 763 (2.64575) 0.05%
Context Switches 46394.2 (792.6) 46880.2 (812.688) 1.05%
Sleeps 85207.4 (659.075) 85525.2 (663.924) 0.37%
Average Maximal load -j 16
Base SPF
Run (std deviation)
Elapsed Time 71.102 (0.424347) 72.438 (0.650054) 1.88%
User Time 945.085 (76.0995) 957.76 (75.2979) 1.34%
System Time 98.828 (14.4599) 104.596 (14.7918) 5.84%
Percent CPU 1054.8 (308.054) 1055.7 (308.63) 0.09%
Context Switches 65134.6 (19763.6) 65487 (19626.2) 0.54%
Sleeps 90760.7 (5896.06) 90821.1 (5611.64) 0.07%
The elapsed time is in the same order, a bit larger in the case of the spf
release, but that seems to be in the error margin. Context switches are now
in the same order.
Here are the kerbench results on a 80 CPUs Power8 system :
Average Maximal load -j 40
Base SPF
Run (std deviation)
Elapsed Time 108.37 (0.544885) 109.2 (0.454037) 0.77%
User Time 4111.38 (13.7343) 4129.09 (13.6466) 0.43%
System Time 99.098 (0.364925) 99.856 (0.386109) 0.76%
Percent CPU 3884.6 (9.31665) 3871.8 (12.0706) -0.33%
Context Switches 71962.2 (206.129) 72009.8 (185.303) 0.07%
Sleeps 156369 (850.193) 155912 (1099.63) -0.29%
Average Maximal load -j 80
Base SPF
Run (std deviation)
Elapsed Time 98.886 (0.629031) 99.726 (0.871854) 0.85%
User Time 5408.5 (1367.35) 5416.23 (1356.89) 0.14%
System Time 115.364 (17.161) 115.923 (16.939) 0.48%
Percent CPU 5399.2 (1596.95) 5362.9 (1572.71) -0.67%
Context Switches 138892 (70610.1) 138321 (69920.2) -0.41%
Sleeps 159509 (6171.69) 158354 (3595.75) -0.72%
We can't see any impact, neither performance improvement, but this is
mostly mono threaded processes and the SPF handler is not activated.
Ebizzy:
-------
The test is counting the number of records per second it can manage, the
higher is the best. I run it like this 'ebizzy -mTRp'. To get consistent
result I repeated the test 100 times and measure the average result. The
number is the record processes per second, the higher is the best.
- 16 CPUs x86 VM
BASE SPF delta
16 CPUs x86 VM 11485.14 60902.26 430.27%
80 CPUs P8 node 37648.73 83078.01 120.67%
Here the delta is big, as this test is triggering the SPF handler
massively.
Will-It-Scale [6]
-----------------
I got a lot of deviation in the results returned by this benchmark,
especially when running a high number of CPUs. However while the series v5
was showing a performance degradation, despite the deviations, I can't see
it anymore with this series. This being said, it's hard to produce numbers
of such a benchmark as deviation is really too high.
------------------
Changes since V5:
- use rwlock agains the mm RB tree in place of SRCU
- add a VMA's reference count to protect VMA while using it without
holding the mmap_sem.
- check PMD value to detect collapsing operation
- don't try speculative page fault for mono threaded processes
- try to reuse the fetched VMA if VM_RETRY is returned
- go directly to the error path if an error is detected during the SPF
path
- fix race window when moving VMA in move_vma()
Changes since v4:
- As requested by Andrew Morton, use CONFIG_SPF and define it earlier in
the series to ease bisection.
Changes since v3:
- Don't build when CONFIG_SMP is not set
- Fixed a lock dependency warning in __vma_adjust()
- Use READ_ONCE to access p*d values in handle_speculative_fault()
- Call memcp_oom() service in handle_speculative_fault()
Changes since v2:
- Perf event is renamed in PERF_COUNT_SW_SPF
- On Power handle do_page_fault()'s cleaning
- On Power if the VM_FAULT_ERROR is returned by
handle_speculative_fault(), do not retry but jump to the error path
- If VMA's flags are not matching the fault, directly returns
VM_FAULT_SIGSEGV and not VM_FAULT_RETRY
- Check for pud_trans_huge() to avoid speculative path
- Handles _vm_normal_page()'s introduced by 6f16211df3bf
("mm/device-public-memory: device memory cache coherent with CPU")
- add and review few comments in the code
Changes since v1:
- Remove PERF_COUNT_SW_SPF_FAILED perf event.
- Add tracing events to details speculative page fault failures.
- Cache VMA fields values which are used once the PTE is unlocked at the
end of the page fault events.
- Ensure that fields read during the speculative path are written and read
using WRITE_ONCE and READ_ONCE.
- Add checks at the beginning of the speculative path to abort it if the
VMA is known to not be supported.
Changes since RFC V5 [5]
- Port to 4.13 kernel
- Merging patch fixing lock dependency into the original patch
- Replace the 2 parameters of vma_has_changed() with the vmf pointer
- In patch 7, don't call __do_fault() in the speculative path as it may
want to unlock the mmap_sem.
- In patch 11-12, don't check for vma boundaries when
page_add_new_anon_rmap() is called during the spf path and protect against
anon_vma pointer's update.
- In patch 13-16, add performance events to report number of successful
and failed speculative events.
[1] http://linux-kernel.2935.n7.nabble.com/RFC-PATCH-0-6-Another-go-at-speculative-page-faults-tt965642.html#none
[2] https://patchwork.kernel.org/patch/9999687/
[3] http://ebizzy.sourceforge.net/
[4] http://ck.kolivas.org/apps/kernbench/kernbench-0.50/
[5] https://lwn.net/Articles/725607/
[6] https://github.com/antonblanchard/will-it-scale.git
Laurent Dufour (19):
x86/mm: Define CONFIG_SPF
powerpc/mm: Define CONFIG_SPF
mm: Introduce pte_spinlock for FAULT_FLAG_SPECULATIVE
mm: Protect VMA modifications using VMA sequence count
mm: protect mremap() against SPF hanlder
mm: Protect SPF handler against anon_vma changes
mm: Cache some VMA fields in the vm_fault structure
mm/migrate: Pass vm_fault pointer to migrate_misplaced_page()
mm: Introduce __lru_cache_add_active_or_unevictable
mm: Introduce __maybe_mkwrite()
mm: Introduce __vm_normal_page()
mm: Introduce __page_add_new_anon_rmap()
mm: Protect mm_rb tree with a rwlock
mm: Try spin lock in speculative path
mm: Adding speculative page fault failure trace events
perf: Add a speculative page fault sw event
perf tools: Add support for the SPF perf event
mm: Speculative page fault handler return VMA
powerpc/mm: Add speculative page fault
Peter Zijlstra (5):
mm: Dont assume page-table invariance during faults
mm: Prepare for FAULT_FLAG_SPECULATIVE
mm: VMA sequence count
mm: Provide speculative fault infrastructure
x86/mm: Add speculative pagefault handling
arch/powerpc/Kconfig | 4 +
arch/powerpc/mm/fault.c | 31 +-
arch/x86/Kconfig | 4 +
arch/x86/mm/fault.c | 38 ++-
fs/proc/task_mmu.c | 5 +-
fs/userfaultfd.c | 17 +-
include/linux/hugetlb_inline.h | 2 +-
include/linux/migrate.h | 4 +-
include/linux/mm.h | 91 +++++-
include/linux/mm_types.h | 7 +
include/linux/pagemap.h | 4 +-
include/linux/rmap.h | 12 +-
include/linux/swap.h | 10 +-
include/trace/events/pagefault.h | 87 ++++++
include/uapi/linux/perf_event.h | 1 +
kernel/fork.c | 3 +
mm/hugetlb.c | 2 +
mm/init-mm.c | 3 +
mm/internal.h | 20 ++
mm/khugepaged.c | 5 +
mm/madvise.c | 6 +-
mm/memory.c | 563 ++++++++++++++++++++++++++++++----
mm/mempolicy.c | 51 ++-
mm/migrate.c | 4 +-
mm/mlock.c | 13 +-
mm/mmap.c | 209 ++++++++++---
mm/mprotect.c | 4 +-
mm/mremap.c | 13 +
mm/rmap.c | 5 +-
mm/swap.c | 6 +-
mm/swap_state.c | 8 +-
tools/include/uapi/linux/perf_event.h | 1 +
tools/perf/util/evsel.c | 1 +
tools/perf/util/parse-events.c | 4 +
tools/perf/util/parse-events.l | 1 +
tools/perf/util/python.c | 1 +
36 files changed, 1076 insertions(+), 164 deletions(-)
create mode 100644 include/trace/events/pagefault.h
--
2.7.4
^ permalink raw reply
* Re: [PATCH V2] powerpc/kernel: Add 'ibm,thread-groups' property for CPU allocation
From: Nathan Fontenot @ 2018-01-12 17:16 UTC (permalink / raw)
To: Michael Bringmann, linuxppc-dev
In-Reply-To: <aeffc542-db28-7d1f-3263-52919b2d07c2@linux.vnet.ibm.com>
On 01/08/2018 11:19 AM, Michael Bringmann wrote:
> Add code to parse the new property 'ibm,thread-groups" when it is
> present. The content of this property explicitly defines the number
> of threads per core as well as the PowerPC 'threads_core_mask'.
> The design provides a common device-tree for both P9 normal core and
> P9 fused core systems. The new property has been observed to be
> available on P9 pHyp systems, but it is not always present on
> OpenPower BMC systems.
>
> The property updates the kernel to know which CPUs/threads of each
> core are actually present, and then use the map when adding cores
> to the system at boot, or during hotplug operations.
>
> * Previously, the information about the number of threads per core
> was inferred solely from the "ibm,ppc-interrupt-server#s" property
> in the system device tree.
> * Also previous to this property, The mask of threads per CPU was
> inferred to be a strict linear series from 0..(nthreads-1).
> * After reading the "ibm,thread-group" property, we can determine
> the number of threads per core to be the 'bitmask weight' of the
> CPU thread mask.
> * Also after reading the property, we can determine which of the
> possible threads we are allowed to online for each CPU. It is no
> longer a simple linear sequence, but may be discontinuous e.g.
> activate threads 1,2,3,5,6,7 on a core instead of 0-5 sequentially.
>
> Implementation of the "ibm,thread-groups" property is spread across
> a few files in the powerpc specific code:
>
> * prom.c: Parse the property and create 'ppc_thread_group_mask'.
> Use the mask in operation of early_init_dt_scan_cpus().
> * setup-common.c: Import 'ppc_thread_group_mask' and use the value
> in the operation of cpu_init_thread_core_maps(), and
> smp_setup_cpu_maps.
> * hotplug-cpu.c: Use 'ppc_thread_group_mask' in several locations
> where the code previously expected to iterate over a
> linear series of active threads (0..nthreads-1).
>
> Note that the "ibm,thread-groups" property also includes semantics
> of 'thread-group' i.e. define one or more subgroups of the available
> threads, each group of threads to be used for a specific class of
> task. Translating thread group semantics into Linux kernel features
> is TBD.
One thing I don't see addressed in the comments or in the code is
migration support. I think we need to update the thread group mask
post-migration to reflect the threads per core on the new system.
-Nathan
>
> Signed-off-by: Michael Bringmann <mwb@linux.vnet.ibm.com>
> ---
> Changes in V2:
> -- Add more information and examples to the patch description.
> -- Rename 'pseries_thread_group_mask' to 'ppc_thread_group_mask'
> -- Remove unnecessary debug message complaining about absence of
> property.
> -- Reduce indent complexity of early_init_dt_scan_cpus().
> ---
> arch/powerpc/include/asm/cputhreads.h | 2 +
> arch/powerpc/kernel/prom.c | 74 ++++++++++++++++++++++++++
> arch/powerpc/kernel/setup-common.c | 30 +++++++----
> arch/powerpc/platforms/pseries/hotplug-cpu.c | 13 ++++-
> 4 files changed, 107 insertions(+), 12 deletions(-)
>
> diff --git a/arch/powerpc/include/asm/cputhreads.h b/arch/powerpc/include/asm/cputhreads.h
> index d71a909..8e444d4 100644
> --- a/arch/powerpc/include/asm/cputhreads.h
> +++ b/arch/powerpc/include/asm/cputhreads.h
> @@ -31,6 +31,8 @@
> #define threads_core_mask (*get_cpu_mask(0))
> #endif
>
> +extern cpumask_t ppc_thread_group_mask;
> +
> /* cpu_thread_mask_to_cores - Return a cpumask of one per cores
> * hit by the argument
> *
> diff --git a/arch/powerpc/kernel/prom.c b/arch/powerpc/kernel/prom.c
> index b15bae2..0a49231 100644
> --- a/arch/powerpc/kernel/prom.c
> +++ b/arch/powerpc/kernel/prom.c
> @@ -68,6 +68,9 @@
> #define DBG(fmt...)
> #endif
>
> +cpumask_t ppc_thread_group_mask;
> +EXPORT_SYMBOL(ppc_thread_group_mask);
> +
> #ifdef CONFIG_PPC64
> int __initdata iommu_is_off;
> int __initdata iommu_force_on;
> @@ -303,6 +306,71 @@ static void __init check_cpu_feature_properties(unsigned long node)
> }
> }
>
> +static void __init early_init_setup_thread_group_mask(unsigned long node,
> + cpumask_t *thread_group_mask)
> +{
> + const __be32 *thrgrp;
> + int len, rc = 0;
> + u32 cc_type = 0, no_split = 0, thr_per_split = 0;
> + int j, k;
> +
> + cpumask_clear(thread_group_mask);
> +
> + thrgrp = of_get_flat_dt_prop(node, "ibm,thread-groups", &len);
> + if (!thrgrp)
> + return;
> +
> + /* Process the thread groups for the Core thread mask */
> + /* Characteristic type per table */
> + cc_type = of_read_number(thrgrp++, 1);
> +
> + /*
> + * 1 : Group shares common L1, translation cache, and
> + * instruction data flow
> + * >1 : Reserved
> + */
> + if (cc_type != 1) {
> + rc = -EINVAL;
> + goto endit;
> + }
> +
> + /* No. splits */
> + no_split = of_read_number(thrgrp++, 1);
> + if (no_split == 0) {
> + rc = -EINVAL;
> + goto endit;
> + }
> +
> + /* Threads per split */
> + thr_per_split = of_read_number(thrgrp++, 1);
> + if (thr_per_split == 0) {
> + rc = -EINVAL;
> + goto endit;
> + }
> +
> + DBG("INFO: Node %d; ibm,thread-group "
> + "(cc_t=%d, no_spl=%d, thr_p_spl=%d)\n",
> + (int)node, (int)cc_type, (int)no_split,
> + (int)thr_per_split);
> +
> + for (j = 0; j < no_split; j++) {
> + for (k = 0; k < thr_per_split; k++) {
> + u32 t = of_read_number(thrgrp++, 1);
> +
> + cpumask_set_cpu(t, thread_group_mask);
> + DBG("INFO: Node %d; enable thread %d\n",
> + (int)node, (int)t);
> + }
> + }
> +
> +endit:
> + if (rc) {
> + DBG("WARNING: Node %d; error processing "
> + "ibm,thread-group property\n", (int)node);
> + cpumask_setall(thread_group_mask);
> + }
> +}
> +
> static int __init early_init_dt_scan_cpus(unsigned long node,
> const char *uname, int depth,
> void *data)
> @@ -326,11 +394,17 @@ static int __init early_init_dt_scan_cpus(unsigned long node,
>
> nthreads = len / sizeof(int);
>
> + /* Figure out the thread subset */
> + early_init_setup_thread_group_mask(node, &ppc_thread_group_mask);
> +
> /*
> * Now see if any of these threads match our boot cpu.
> * NOTE: This must match the parsing done in smp_setup_cpu_maps.
> */
> for (i = 0; i < nthreads; i++) {
> + if (!cpumask_test_cpu(i % nthreads, &ppc_thread_group_mask))
> + continue;
> +
> /*
> * version 2 of the kexec param format adds the phys cpuid of
> * booted proc.
> diff --git a/arch/powerpc/kernel/setup-common.c b/arch/powerpc/kernel/setup-common.c
> index 2075322..53cadcd 100644
> --- a/arch/powerpc/kernel/setup-common.c
> +++ b/arch/powerpc/kernel/setup-common.c
> @@ -427,13 +427,16 @@ void __init check_for_initrd(void)
> EXPORT_SYMBOL_GPL(threads_shift);
> EXPORT_SYMBOL_GPL(threads_core_mask);
>
> -static void __init cpu_init_thread_core_maps(int tpc)
> +static void __init cpu_init_thread_core_maps(int tpc,
> + cpumask_t *thread_group_mask)
> {
> + cpumask_t work_mask;
> int i;
>
> threads_per_core = tpc;
> threads_per_subcore = tpc;
> cpumask_clear(&threads_core_mask);
> + cpumask_clear(&work_mask);
>
> /* This implementation only supports power of 2 number of threads
> * for simplicity and performance
> @@ -442,14 +445,14 @@ static void __init cpu_init_thread_core_maps(int tpc)
> BUG_ON(tpc != (1 << threads_shift));
>
> for (i = 0; i < tpc; i++)
> - cpumask_set_cpu(i, &threads_core_mask);
> + cpumask_set_cpu(i, &work_mask);
> + cpumask_and(&threads_core_mask, &work_mask, thread_group_mask);
>
> printk(KERN_INFO "CPU maps initialized for %d thread%s per core\n",
> tpc, tpc > 1 ? "s" : "");
> printk(KERN_DEBUG " (thread shift is %d)\n", threads_shift);
> }
>
> -
> /**
> * setup_cpu_maps - initialize the following cpu maps:
> * cpu_possible_mask
> @@ -503,17 +506,24 @@ void __init smp_setup_cpu_maps(void)
> for (j = 0; j < nthreads && cpu < nr_cpu_ids; j++) {
> bool avail;
>
> - DBG(" thread %d -> cpu %d (hard id %d)\n",
> - j, cpu, be32_to_cpu(intserv[j]));
> -
> avail = of_device_is_available(dn);
> if (!avail)
> avail = !of_property_match_string(dn,
> "enable-method", "spin-table");
>
> - set_cpu_present(cpu, avail);
> - set_hard_smp_processor_id(cpu, be32_to_cpu(intserv[j]));
> - set_cpu_possible(cpu, true);
> + DBG(" thread %d -> cpu %d (hard id %d)\n",
> + j, cpu, be32_to_cpu(intserv[j]));
> +
> + if (cpumask_test_cpu(cpu % nthreads,
> + &ppc_thread_group_mask)) {
> + set_cpu_present(cpu, avail);
> + set_hard_smp_processor_id(cpu,
> + be32_to_cpu(intserv[j]));
> + set_cpu_possible(cpu, true);
> + } else {
> + set_cpu_present(cpu, false);
> + set_cpu_possible(cpu, false);
> + }
> cpu++;
> }
> }
> @@ -572,7 +582,7 @@ void __init smp_setup_cpu_maps(void)
> * every CPU in the system. If that is not the case, then some code
> * here will have to be reworked
> */
> - cpu_init_thread_core_maps(nthreads);
> + cpu_init_thread_core_maps(nthreads, &ppc_thread_group_mask);
>
> /* Now that possible cpus are set, set nr_cpu_ids for later use */
> setup_nr_cpu_ids();
> diff --git a/arch/powerpc/platforms/pseries/hotplug-cpu.c b/arch/powerpc/platforms/pseries/hotplug-cpu.c
> index a7d14aa7..4125eaa 100644
> --- a/arch/powerpc/platforms/pseries/hotplug-cpu.c
> +++ b/arch/powerpc/platforms/pseries/hotplug-cpu.c
> @@ -36,6 +36,7 @@
> #include <asm/xics.h>
> #include <asm/xive.h>
> #include <asm/plpar_wrappers.h>
> +#include <asm/cputhreads.h>
>
> #include "pseries.h"
> #include "offline_states.h"
> @@ -258,8 +259,10 @@ static int pseries_add_processor(struct device_node *np)
> zalloc_cpumask_var(&tmp, GFP_KERNEL);
>
> nthreads = len / sizeof(u32);
> - for (i = 0; i < nthreads; i++)
> - cpumask_set_cpu(i, tmp);
> + for (i = 0; i < nthreads; i++) {
> + if (cpumask_test_cpu(i % nthreads, &ppc_thread_group_mask))
> + cpumask_set_cpu(i, tmp);
> + }
>
> cpu_maps_update_begin();
>
> @@ -324,6 +327,8 @@ static void pseries_remove_processor(struct device_node *np)
>
> cpu_maps_update_begin();
> for (i = 0; i < nthreads; i++) {
> + if (!cpumask_test_cpu(i % nthreads, &ppc_thread_group_mask))
> + continue;
> thread = be32_to_cpu(intserv[i]);
> for_each_present_cpu(cpu) {
> if (get_hard_smp_processor_id(cpu) != thread)
> @@ -356,6 +361,8 @@ static int dlpar_online_cpu(struct device_node *dn)
>
> cpu_maps_update_begin();
> for (i = 0; i < nthreads; i++) {
> + if (!cpumask_test_cpu(i % nthreads, &ppc_thread_group_mask))
> + continue;
> thread = be32_to_cpu(intserv[i]);
> for_each_present_cpu(cpu) {
> if (get_hard_smp_processor_id(cpu) != thread)
> @@ -522,6 +529,8 @@ static int dlpar_offline_cpu(struct device_node *dn)
>
> cpu_maps_update_begin();
> for (i = 0; i < nthreads; i++) {
> + if (!cpumask_test_cpu(i % nthreads, &ppc_thread_group_mask))
> + continue;
> thread = be32_to_cpu(intserv[i]);
> for_each_present_cpu(cpu) {
> if (get_hard_smp_processor_id(cpu) != thread)
>
^ permalink raw reply
* Re: [cryptodev:master 130/134] aes_generic.c:undefined reference to `_restgpr_31_x'
From: Segher Boessenkool @ 2018-01-12 16:39 UTC (permalink / raw)
To: Arnd Bergmann
Cc: kbuild test robot, Herbert Xu, linuxppc-dev, kbuild-all,
open list:HARDWARE RANDOM NUMBER GENERATOR CORE
In-Reply-To: <CAK8P3a0Rfbo=wJgEAm3vVFY1MpPWLE3HMGcUdoOXxqOVm8jRyw@mail.gmail.com>
Hi!
On Fri, Jan 12, 2018 at 03:55:47PM +0100, Arnd Bergmann wrote:
> > crypto/aes_generic.o: In function `crypto_aes_set_key':
> >>> aes_generic.c:(.text+0x4e0): undefined reference to `_restgpr_31_x'
>
> adding linuxpcc-dev to Cc, maybe someone knows a way out of this.
> It appears related to https://gcc.gnu.org/bugzilla/show_bug.cgi?id=43810
It is not.
> but I don't know what _restgpr_31_x actually does,
It restores GPR31 from stack, restores LR from stack, and returns
(_x is "exit").
> why it's not provided by the kernel
Because the kernel refuses to use libgcc. Let's, uh, not start that
again? :-)
> or why the aes_generic implementation needs this on
> powerpc when built with 'gcc -Os'. FWIW, the -Os change was needed
> to work around a possible kernel stack overflow that can happen with
> gcc-7.2, see https://patchwork.kernel.org/patch/10143607/ and
> https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83356
The _x versions are smaller but slower; that's why they are used with -Os.
Apparently nothing else was built with -Os (and the other needed flags)
before.
Segher
^ permalink raw reply
* Re: DPAA Ethernet problems with mainstream Linux kernels
From: Jamie Krueger @ 2018-01-12 16:35 UTC (permalink / raw)
To: Madalin-cristian Bucur, linuxppc-dev@lists.ozlabs.org
Cc: netdev@vger.kernel.org
In-Reply-To: <DB3PR0402MB3849C70D5760C3F21F881074EC170@DB3PR0402MB3849.eurprd04.prod.outlook.com>
[-- Attachment #1: Type: text/plain, Size: 29823 bytes --]
On 01/12/2018 08:22 AM, Madalin-cristian Bucur wrote:
>> -----Original Message-----
>> From: Linuxppc-dev [mailto:linuxppc-dev-
>> bounces+madalin.bucur=nxp.com@lists.ozlabs.org] On Behalf Of Jamie Krueger
>> Sent: Wednesday, January 10, 2018 5:57 PM
>> To: linuxppc-dev@lists.ozlabs.org
>> Subject: DPAA Ethernet problems with mainstream Linux kernels
>>
>> Hello all @ linuxppc-dev,
>>
>> I have been working with a team of people maintaining PowerPC
>> Linux for the new AmigaONE X5000/20 (a Freescale p5020 SoC based
>> machine).
>>
>> We are trying to determine why the submitted Data Path Acceleration
>> Architecture (DPAA) Ethernet Driver is not fully functional with
>> the mainstream Linux kernels.
> Hi Jamie,
Hi Madalin,
> We are testing the DPAA driver on several DS and RDB platforms and it
> is working properly. The issues you encounter with it on the X5000/20
> are likely caused by some issues specific to that particular platform.
It is good to hear that the DPAA driver is functioning correctly
on the reference platforms. I am positive you are correct that
the issue is the difference in implementation on the X5000/20
(Cyrus) motherboard, as compared to the reference boards.
Can you verify which Linux Kernel sources your tests are being
performed on? We have been testing using the mainstream
Linux sources up to linux-4.15-rc6 thus far.
> The device tree that you mention, cyrus_p5020.eth.dts is not found in
> the Linux kernel sources. The cyrus_p5020.dts file from the fsl ppc
> device tree folder does not include the PHY information for the DPAA
> interfaces. The problems that you experience may be caused by some
> issues with the PHY configuration (i.e. internal delay).
The cyrus_p5020.eth.dts is a modified version of the cyrus_p5020.dts,
which of course was based off the original p5020ds.dts file. As you
noted, the current cyrus_p5020.dts file is incomplete, and does not
map the Ethernet connections properly.
The cyrus_p5020.eth.dts file, along with it's cyrus-pre.dtsi dependent
file, are an attempt to correctly define the Ethernet hardware, as it is
implemented on the X5000/20.
** I have attached both the cyrus_p5020.eth.dts and cyrus-pre.dtsi
files with this email for comparison. Please let me know if you see
any corrections that should be made to either file.
I am not sure what PHY hardware/configuration you are using on the
DS and RDB platforms, but I can confirm that AmigaONE X5000/20
(Cyrus Motherboard with p5020 SoC), has dTSEC 4 and dTSEC 5
wired to two Micrel KSZ9021RN Gigabit Ethernet PHYs, using the
RGMII protocol.
> I suggest
> that you connect the DPAA interface to a traffic analyzer or directly
> to another device on which you can capture the incoming traffic and
> check that the received frames are correct.
I have started testing along that line, using Wireshark to view the
traffic on the X5000/20 itself, and from another machine connected
on the same subnet. So far (as indicated by some details of in my
initial email), I can see outgoing broadcast requests (for DHCP)
being sent out from the X5000/20, and these requests are correctly
constructed and visible outside the X5000/20.
However, no responses to the DHCP broadcasts appear to reach
to X5000/20's DPAA Ethernet. I will need to setup some further
tests to determine if the DHCP server saw the requests and responded
to them. (I assume the DHCP server is getting them, and responding,
as I can always get a successful DHCP response to the X5000/20
when using an add-on Ethernet PICe card on the same subnet).
I will setup some more direct machine-to-machine testing to
see what else I can glean from the network traffic.
Please have a look at the attached dts files, maybe there is something
obvious there we are not seeing.
Also, given that the X5000/20 uses Micrel KSZ9021RN PHYs in RGMII
mode, what changes to the DPAA hardware configuration should we
expect to see so that the DPAA is configured to talk to them?
> Madalin
>
--
Best Regards,
Jamie Krueger
BITbyBIT Software Group LLC
>> Here is the results from my latest tests. They were performed using
>> the linux-4.10.17 ppc64, since that represents when the DPAA Ethernet
>> code was introduced.
>>
>> Similar tests, with similar results, were also performed
>> using the latest Linux kernels:
>>
>> linux-4.15-rc5
>> linux-4.15-rc6
>> linux-4.15-rc7
>>
>> (Hence the reason for falling back to test the kernel right
>> after the introduction of the DPAA Ethernet driver sources)
>>
>> ---
>>
>> All Kernel builds had the DPAA Ethernet enabled in the kernel,
>> and are using the correct cyrus_p5020.eth.dtb device tree file
>> (for use on the X5000/20).
>>
>> The results are quite similar for all kernels in regards to the DPAA
>> Ethernet.
>>
>> All tested kernels setup the two Ethernet interfaces correctly
>> as eth0 and eth1, and pull the correct MAC addresses from U-Boot
>> environment variables ethaddr and eth1addr respectively.
>>
>> So at this point Linux has what it believes is fully configured
>> hardware, waiting to have an IP Address/Netmask/Gateway
>> to be set and to bring the interface online.
>>
>> However, all attempts to communicate with the outside world
>> do not make it out the physical (PHY) hardware - or do they?
>>
>> ** The following results were captured under linux-4.10.17 **
>>
>> When I bring the interface up using a static address, in this case
>> 192.168.1.21, I see the following (NOTE TX bytes says 154.0 KB,
>> while RX bytes says 0.0 B):
>>
>> jamie@X5000-Linux:$ ifconfig
>> eth0 Link encap:Ethernet HWaddr 00:80:10:11:11:11
>> inet addr:192.168.1.21 Bcast:192.168.1.255 Mask:255.255.255.0
>> inet6 addr: fe80::280:10ff:fe11:1111/64 Scope:Link
>> UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
>> RX packets:0 errors:0 dropped:0 overruns:0 frame:0
>> TX packets:1428 errors:0 dropped:0 overruns:0 carrier:0
>> collisions:0 txqueuelen:1000
>> RX bytes:0 (0.0 B) TX bytes:154066 (154.0 KB)
>> Memory:fe4e6000-fe4e6fff
>>
>> eth1 Link encap:Ethernet HWaddr 00:80:10:22:22:22
>> UP BROADCAST MULTICAST MTU:1500 Metric:1
>> RX packets:0 errors:0 dropped:0 overruns:0 frame:0
>> TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
>> collisions:0 txqueuelen:1000
>> RX bytes:0 (0.0 B) TX bytes:0 (0.0 B)
>> Memory:fe4e8000-fe4e8fff
>>
>> lo Link encap:Local Loopback
>> inet addr:127.0.0.1 Mask:255.0.0.0
>> inet6 addr: ::1/128 Scope:Host
>> UP LOOPBACK RUNNING MTU:65536 Metric:1
>> RX packets:1869 errors:0 dropped:0 overruns:0 frame:0
>> TX packets:1869 errors:0 dropped:0 overruns:0 carrier:0
>> collisions:0 txqueuelen:1000
>> RX bytes:156932 (156.9 KB) TX bytes:156932 (156.9 KB)
>>
>> Checking the routing table, everything looks fine there:
>>
>> jamie@X5000-Linux:$ netstat -r
>> Kernel IP routing table
>> Destination Gateway Genmask Flags MSS Window irtt
>> Iface
>> default 192.168.1.1 0.0.0.0 UG 0 0 0
>> eth0
>> link-local * 255.255.0.0 U 0 0 0
>> eth0
>> 192.168.1.0 * 255.255.255.0 U 0 0 0
>> eth0
>>
>> Attempting to PING the interface itself works:
>>
>> jamie@X5000-Linux:$ ping 192.168.1.21
>> PING 192.168.1.21 (192.168.1.21) 56(84) bytes of data.
>> 64 bytes from 192.168.1.21: icmp_seq=1 ttl=64 time=0.037 ms
>> 64 bytes from 192.168.1.21: icmp_seq=2 ttl=64 time=0.045 ms
>> 64 bytes from 192.168.1.21: icmp_seq=3 ttl=64 time=0.033 ms
>> ^C
>> --- 192.168.1.21 ping statistics ---
>> 3 packets transmitted, 3 received, 0% packet loss, time 2043ms
>>
>> However, attempts to PING the gateway (192.168.1.1) fail as unreachable:
>>
>> jamie@X5000-Linux:$ ping 192.168.1.1
>> PING 192.168.1.1 (192.168.1.1) 56(84) bytes of data.
>> From 192.168.1.21 icmp_seq=1 Destination Host Unreachable
>> From 192.168.1.21 icmp_seq=2 Destination Host Unreachable
>> From 192.168.1.21 icmp_seq=3 Destination Host Unreachable
>> ^C
>> --- 192.168.1.1 ping statistics ---
>> 7 packets transmitted, 0 received, +3 errors, 100% packet loss, time
>> 6077ms
>>
>> In order to take a closer look at what is going on I installed Wireshark
>> both on my test X5000/20 Linux install (Ubuntu 16.04.3 LTS), and on
>> another Linux box connected to the same network switch (in this case
>> at IP address 192.168.1.210)
>>
>> In this test I start the capture on eth0 (X5000/20) before it is put
>> online,
>> and attempt to bring it up using DHCP to obtain it's address.
>>
>> What I found was that network traffic *was* being attempted over eth0.
>> Here is a plain text export of the transmit side (the X5000/20) that
>> was captured using Wireshark.
>>
>> (There were more network packets being sent from the X5000/20,
>> however, I am only showing DHCP traffic to save space in this post):
>>
>> ---
>> No. Time Source Destination Protocol Length
>> Info
>> 2 0.042259843 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x655d91e8
>>
>> Frame 2: 342 bytes on wire (2736 bits), 342 bytes captured (2736 bits)
>> on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 16 3.830001152 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x655d91e8
>>
>> Frame 16: 342 bytes on wire (2736 bits), 342 bytes captured (2736 bits)
>> on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 21 9.308914533 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x655d91e8
>>
>> Frame 21: 342 bytes on wire (2736 bits), 342 bytes captured (2736 bits)
>> on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 23 18.906405343 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x655d91e8
>>
>> Frame 23: 342 bytes on wire (2736 bits), 342 bytes captured (2736 bits)
>> on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 25 36.390926450 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x655d91e8
>>
>> Frame 25: 342 bytes on wire (2736 bits), 342 bytes captured (2736 bits)
>> on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 26 44.048328412 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x655d91e8
>>
>> Frame 26: 342 bytes on wire (2736 bits), 342 bytes captured (2736 bits)
>> on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 30 44.889049203 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x421bade3
>>
>> Frame 30: 342 bytes on wire (2736 bits), 342 bytes captured (2736 bits)
>> on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 44 48.254495304 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x421bade3
>>
>> Frame 44: 342 bytes on wire (2736 bits), 342 bytes captured (2736 bits)
>> on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 49 54.299052732 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x421bade3
>>
>> Frame 49: 342 bytes on wire (2736 bits), 342 bytes captured (2736 bits)
>> on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 51 62.672007482 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x421bade3
>>
>> Frame 51: 342 bytes on wire (2736 bits), 342 bytes captured (2736 bits)
>> on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 52 77.485896202 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x421bade3
>>
>> Frame 52: 342 bytes on wire (2736 bits), 342 bytes captured (2736 bits)
>> on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 56 89.895304152 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x5df47c84
>>
>> Frame 56: 342 bytes on wire (2736 bits), 342 bytes captured (2736 bits)
>> on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 71 93.828837008 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x5df47c84
>>
>> Frame 71: 342 bytes on wire (2736 bits), 342 bytes captured (2736 bits)
>> on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 74 97.948453158 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x5df47c84
>>
>> Frame 74: 342 bytes on wire (2736 bits), 342 bytes captured (2736 bits)
>> on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>> ---
>>
>> Now, over on the external Linux machine (192.168.1.210), I setup a
>> Wireshark capture
>> which filtered for any traffic to/from the MAC address of the X5000/20's
>> eth0, in this case
>> shown as Commodor_11:11:11 (00:80:10:11:11:11) below:
>>
>> This export shows only the DHCP traffic seen from outside the X5000/20,
>> and as you can see, a matching set of DHCP requests *do in fact* make
>> it to the outside network.
>>
>> ---
>> No. Time Source Destination Protocol Length
>> Info
>> 39 5.671762509 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x655d91e8
>>
>> Frame 39: 342 bytes on wire (2736 bits), 342 bytes captured (2736 bits)
>> on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Destination: Broadcast (ff:ff:ff:ff:ff:ff)
>> Source: Commodor_11:11:11 (00:80:10:11:11:11)
>> Type: IPv4 (0x0800)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 73 9.451895404 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x655d91e8
>>
>> Frame 73: 342 bytes on wire (2736 bits), 342 bytes captured (2736 bits)
>> on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Destination: Broadcast (ff:ff:ff:ff:ff:ff)
>> Source: Commodor_11:11:11 (00:80:10:11:11:11)
>> Type: IPv4 (0x0800)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 154 14.919944480 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x655d91e8
>>
>> Frame 154: 342 bytes on wire (2736 bits), 342 bytes captured (2736 bits)
>> on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Destination: Broadcast (ff:ff:ff:ff:ff:ff)
>> Source: Commodor_11:11:11 (00:80:10:11:11:11)
>> Type: IPv4 (0x0800)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 269 24.498335996 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x655d91e8
>>
>> Frame 269: 342 bytes on wire (2736 bits), 342 bytes captured (2736 bits)
>> on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Destination: Broadcast (ff:ff:ff:ff:ff:ff)
>> Source: Commodor_11:11:11 (00:80:10:11:11:11)
>> Type: IPv4 (0x0800)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 630 41.948018648 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x655d91e8
>>
>> Frame 630: 342 bytes on wire (2736 bits), 342 bytes captured (2736 bits)
>> on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Destination: Broadcast (ff:ff:ff:ff:ff:ff)
>> Source: Commodor_11:11:11 (00:80:10:11:11:11)
>> Type: IPv4 (0x0800)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 701 49.590211264 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x655d91e8
>>
>> Frame 701: 342 bytes on wire (2736 bits), 342 bytes captured (2736 bits)
>> on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Destination: Broadcast (ff:ff:ff:ff:ff:ff)
>> Source: Commodor_11:11:11 (00:80:10:11:11:11)
>> Type: IPv4 (0x0800)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 706 50.429265938 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x421bade3
>>
>> Frame 706: 342 bytes on wire (2736 bits), 342 bytes captured (2736 bits)
>> on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Destination: Broadcast (ff:ff:ff:ff:ff:ff)
>> Source: Commodor_11:11:11 (00:80:10:11:11:11)
>> Type: IPv4 (0x0800)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 744 53.788035317 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x421bade3
>>
>> Frame 744: 342 bytes on wire (2736 bits), 342 bytes captured (2736 bits)
>> on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Destination: Broadcast (ff:ff:ff:ff:ff:ff)
>> Source: Commodor_11:11:11 (00:80:10:11:11:11)
>> Type: IPv4 (0x0800)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 797 59.820568614 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x421bade3
>>
>> Frame 797: 342 bytes on wire (2736 bits), 342 bytes captured (2736 bits)
>> on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Destination: Broadcast (ff:ff:ff:ff:ff:ff)
>> Source: Commodor_11:11:11 (00:80:10:11:11:11)
>> Type: IPv4 (0x0800)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 852 68.176833686 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x421bade3
>>
>> Frame 852: 342 bytes on wire (2736 bits), 342 bytes captured (2736 bits)
>> on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Destination: Broadcast (ff:ff:ff:ff:ff:ff)
>> Source: Commodor_11:11:11 (00:80:10:11:11:11)
>> Type: IPv4 (0x0800)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 990 82.961224895 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x421bade3
>>
>> Frame 990: 342 bytes on wire (2736 bits), 342 bytes captured (2736 bits)
>> on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Destination: Broadcast (ff:ff:ff:ff:ff:ff)
>> Source: Commodor_11:11:11 (00:80:10:11:11:11)
>> Type: IPv4 (0x0800)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 3827 95.345964418 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x5df47c84
>>
>> Frame 3827: 342 bytes on wire (2736 bits), 342 bytes captured (2736
>> bits) on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Destination: Broadcast (ff:ff:ff:ff:ff:ff)
>> Source: Commodor_11:11:11 (00:80:10:11:11:11)
>> Type: IPv4 (0x0800)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 3887 99.271668572 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x5df47c84
>>
>> Frame 3887: 342 bytes on wire (2736 bits), 342 bytes captured (2736
>> bits) on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Destination: Broadcast (ff:ff:ff:ff:ff:ff)
>> Source: Commodor_11:11:11 (00:80:10:11:11:11)
>> Type: IPv4 (0x0800)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>>
>> No. Time Source Destination Protocol Length
>> Info
>> 3943 103.383072429 0.0.0.0 255.255.255.255 DHCP
>> 342 DHCP Discover - Transaction ID 0x5df47c84
>>
>> Frame 3943: 342 bytes on wire (2736 bits), 342 bytes captured (2736
>> bits) on interface 0
>> Ethernet II, Src: Commodor_11:11:11 (00:80:10:11:11:11), Dst: Broadcast
>> (ff:ff:ff:ff:ff:ff)
>> Destination: Broadcast (ff:ff:ff:ff:ff:ff)
>> Source: Commodor_11:11:11 (00:80:10:11:11:11)
>> Type: IPv4 (0x0800)
>> Internet Protocol Version 4, Src: 0.0.0.0, Dst: 255.255.255.255
>> User Datagram Protocol, Src Port: 68, Dst Port: 67
>> Bootstrap Protocol (Discover)
>> ---
>>
>> The odd thing here is that while the DHCP requests were broadcast to the
>> outside network (confirming that at least the transmit to the PHY is
>> working),
>> I could see no responses from my network's DHCP server to answer these
>> requests.
>>
>> It is not a physical networking or routing issue, as I always get a
>> successful
>> DHCP response to the X5000/20 when I enable the Realtek 8169 interface
>> (also
>> installed [PCIe card] in the X5000/20).
>>
>> Since initial outgoing traffic *appears* to be working from the DPAA
>> Ethernet
>> on the X5000/20, is it possible we are missing an interrupt mapping from
>> the
>> Frame Manager to catch the received data?
>>
>> Any help would be appreciated. Thanks.
>>
>> --
>> Best Regards,
>>
>> Jamie Krueger
>> BITbyBIT Software Group LLC
[-- Attachment #2: cyrus-pre.dtsi --]
[-- Type: text/plain, Size: 3260 bytes --]
/*
* P5020/P5010 Silicon/SoC Device Tree Source (pre include)
*
* Copyright 2011 - 2015 Freescale Semiconductor Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of Freescale Semiconductor nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
*
* ALTERNATIVELY, this software may be distributed under the terms of the
* GNU General Public License ("GPL") as published by the Free Software
* Foundation, either version 2 of that License or (at your option) any
* later version.
*
* THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL Freescale Semiconductor BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/dts-v1/;
/include/ "e5500_power_isa.dtsi"
/ {
compatible = "fsl,P5020";
#address-cells = <2>;
#size-cells = <2>;
interrupt-parent = <&mpic>;
aliases {
ccsr = &soc;
dcsr = &dcsr;
serial0 = &serial0;
serial1 = &serial1;
serial2 = &serial2;
serial3 = &serial3;
pci0 = &pci0;
pci1 = &pci1;
pci2 = &pci2;
pci3 = &pci3;
usb0 = &usb0;
usb1 = &usb1;
dma0 = &dma0;
dma1 = &dma1;
sdhc = &sdhc;
msi0 = &msi0;
msi1 = &msi1;
msi2 = &msi2;
crypto = &crypto;
sec_jr0 = &sec_jr0;
sec_jr1 = &sec_jr1;
sec_jr2 = &sec_jr2;
sec_jr3 = &sec_jr3;
rtic_a = &rtic_a;
rtic_b = &rtic_b;
rtic_c = &rtic_c;
rtic_d = &rtic_d;
sec_mon = &sec_mon;
raideng = &raideng;
raideng_jr0 = &raideng_jr0;
raideng_jr1 = &raideng_jr1;
raideng_jr2 = &raideng_jr2;
raideng_jr3 = &raideng_jr3;
fman0 = &fman0;
ethernet0 = &enet3;
ethernet1 = &enet4;
};
cpus {
#address-cells = <1>;
#size-cells = <0>;
cpu0: PowerPC,e5500@0 {
device_type = "cpu";
reg = <0>;
clocks = <&mux0>;
next-level-cache = <&L2_0>;
fsl,portid-mapping = <0x80000000>;
L2_0: l2-cache {
next-level-cache = <&cpc>;
};
};
cpu1: PowerPC,e5500@1 {
device_type = "cpu";
reg = <1>;
clocks = <&mux1>;
next-level-cache = <&L2_1>;
fsl,portid-mapping = <0x40000000>;
L2_1: l2-cache {
next-level-cache = <&cpc>;
};
};
};
};
[-- Attachment #3: cyrus_p5020.eth.dts --]
[-- Type: text/plain, Size: 3807 bytes --]
/*
* Cyrus 5020 Device Tree Source, based on p5020ds.dts
*
* Copyright 2015 Andy Fleming
*
* p5020ds.dts copyright:
* Copyright 2010 - 2014 Freescale Semiconductor Inc.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*/
/include/ "cyrus-pre.dtsi"
/ {
model = "varisys,CYRUS";
compatible = "varisys,CYRUS";
#address-cells = <2>;
#size-cells = <2>;
interrupt-parent = <&mpic>;
aliases {
phy_rgmii_3 = &phy_rgmii_3;
phy_rgmii_7 = &phy_rgmii_7;
};
memory {
device_type = "memory";
};
reserved-memory {
#address-cells = <2>;
#size-cells = <2>;
ranges;
bman_fbpr: bman-fbpr {
size = <0 0x1000000>;
alignment = <0 0x1000000>;
};
qman_fqd: qman-fqd {
size = <0 0x400000>;
alignment = <0 0x400000>;
};
qman_pfdr: qman-pfdr {
size = <0 0x2000000>;
alignment = <0 0x2000000>;
};
};
dcsr: dcsr@f00000000 {
ranges = <0x00000000 0xf 0x00000000 0x01008000>;
};
bportals: bman-portals@ff4000000 {
ranges = <0x0 0xf 0xf4000000 0x200000>;
};
qportals: qman-portals@ff4200000 {
ranges = <0x0 0xf 0xf4200000 0x200000>;
};
soc: soc@ffe000000 {
ranges = <0x00000000 0xf 0xfe000000 0x1000000>;
reg = <0xf 0xfe000000 0 0x00001000>;
spi@110000 {
};
i2c@118100 {
};
i2c@119100 {
rtc@6f {
compatible = "microchip,mcp7941x";
reg = <0x6f>;
};
};
fman@400000 {
mdio@e1120 {
phy_rgmii_3: ethernet-phy@3 {
reg = <0x3>;
};
phy_rgmii_7: ethernet-phy@7 {
reg = <0x7>;
};
};
ethernet@e6000 {
phy-handle = <&phy_rgmii_3>;
phy-connection-type = "rgmii";
};
ethernet@e8000 {
phy-handle = <&phy_rgmii_7>;
phy-connection-type = "rgmii";
};
};
};
rio: rapidio@ffe0c0000 {
reg = <0xf 0xfe0c0000 0 0x11000>;
port1 {
ranges = <0 0 0xc 0x20000000 0 0x10000000>;
};
port2 {
ranges = <0 0 0xc 0x30000000 0 0x10000000>;
};
};
lbc: localbus@ffe124000 {
reg = <0xf 0xfe124000 0 0x1000>;
ranges = <0 0 0xf 0xe8000000 0x08000000
2 0 0xf 0xffa00000 0x00040000
3 0 0xf 0xffdf0000 0x00008000>;
};
pci0: pcie@ffe200000 {
reg = <0xf 0xfe200000 0 0x1000>;
ranges = <0x02000000 0 0xe0000000 0xc 0x00000000 0x0 0x20000000
0x01000000 0 0x00000000 0xf 0xf8000000 0x0 0x00010000>;
pcie@0 {
ranges = <0x02000000 0 0xe0000000
0x02000000 0 0xe0000000
0 0x20000000
0x01000000 0 0x00000000
0x01000000 0 0x00000000
0 0x00010000>;
};
};
pci1: pcie@ffe201000 {
reg = <0xf 0xfe201000 0 0x1000>;
ranges = <0x02000000 0x0 0xe0000000 0xc 0x20000000 0x0 0x20000000
0x01000000 0x0 0x00000000 0xf 0xf8010000 0x0 0x00010000>;
pcie@0 {
ranges = <0x02000000 0 0xe0000000
0x02000000 0 0xe0000000
0 0x20000000
0x01000000 0 0x00000000
0x01000000 0 0x00000000
0 0x00010000>;
};
};
pci2: pcie@ffe202000 {
reg = <0xf 0xfe202000 0 0x1000>;
ranges = <0x02000000 0 0xe0000000 0xc 0x40000000 0 0x20000000
0x01000000 0 0x00000000 0xf 0xf8020000 0 0x00010000>;
pcie@0 {
ranges = <0x02000000 0 0xe0000000
0x02000000 0 0xe0000000
0 0x20000000
0x01000000 0 0x00000000
0x01000000 0 0x00000000
0 0x00010000>;
};
};
pci3: pcie@ffe203000 {
reg = <0xf 0xfe203000 0 0x1000>;
ranges = <0x02000000 0 0xe0000000 0xc 0x60000000 0 0x20000000
0x01000000 0 0x00000000 0xf 0xf8030000 0 0x00010000>;
pcie@0 {
ranges = <0x02000000 0 0xe0000000
0x02000000 0 0xe0000000
0 0x20000000
0x01000000 0 0x00000000
0x01000000 0 0x00000000
0 0x00010000>;
};
};
};
/include/ "p5020si-post.dtsi"
^ permalink raw reply
* Re: [cryptodev:master 130/134] aes_generic.c:undefined reference to `_restgpr_31_x'
From: Arnd Bergmann @ 2018-01-12 14:55 UTC (permalink / raw)
To: kbuild test robot
Cc: kbuild-all, open list:HARDWARE RANDOM NUMBER GENERATOR CORE,
Herbert Xu, linuxppc-dev
In-Reply-To: <201801122249.RHvvGQJ6%fengguang.wu@intel.com>
On Fri, Jan 12, 2018 at 3:11 PM, kbuild test robot
<fengguang.wu@intel.com> wrote:
> tree: https://git.kernel.org/pub/scm/linux/kernel/git/herbert/cryptodev-2.6.git master
> head: b40fa82cd6138350f723aa47b37e3e3e80906b40
> commit: 148b974deea927f5dbb6c468af2707b488bfa2de [130/134] crypto: aes-generic - build with -Os on gcc-7+
> config: powerpc-linkstation_defconfig (attached as .config)
> compiler: powerpc-linux-gnu-gcc (Debian 7.2.0-11) 7.2.0
> reproduce:
> wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
> chmod +x ~/bin/make.cross
> git checkout 148b974deea927f5dbb6c468af2707b488bfa2de
> # save the attached .config to linux build tree
> make.cross ARCH=powerpc
>
> All errors (new ones prefixed by >>):
>
> crypto/aes_generic.o: In function `crypto_aes_set_key':
>>> aes_generic.c:(.text+0x4e0): undefined reference to `_restgpr_31_x'
adding linuxpcc-dev to Cc, maybe someone knows a way out of this.
It appears related to https://gcc.gnu.org/bugzilla/show_bug.cgi?id=43810
but I don't know what _restgpr_31_x actually does, why it's not provided
by the kernel or why the aes_generic implementation needs this on
powerpc when built with 'gcc -Os'. FWIW, the -Os change was needed
to work around a possible kernel stack overflow that can happen with
gcc-7.2, see https://patchwork.kernel.org/patch/10143607/ and
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83356
Arnd
^ permalink raw reply
* RE: DPAA Ethernet problems with mainstream Linux kernels
From: Madalin-cristian Bucur @ 2018-01-12 14:22 UTC (permalink / raw)
To: Jamie Krueger, linuxppc-dev@lists.ozlabs.org; +Cc: netdev@vger.kernel.org
In-Reply-To: <ccafbcca-172b-11ae-7916-8bcd4bfa419c@bitbybitsoftwaregroup.com>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^ permalink raw reply
* Re: [PATCH 06/22] swiotlb: rename swiotlb_free to swiotlb_exit
From: Konrad Rzeszutek Wilk @ 2018-01-12 13:39 UTC (permalink / raw)
To: Christoph Hellwig
Cc: iommu, Michal Simek, Guan Xuetao, Christian König,
linux-arm-kernel, linux-ia64, linux-mips, linuxppc-dev, x86,
linux-arch, linux-kernel
In-Reply-To: <20180110080932.14157-7-hch@lst.de>
On Wed, Jan 10, 2018 at 09:09:16AM +0100, Christoph Hellwig wrote:
OK?
Reviewed-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
> Signed-off-by: Christoph Hellwig <hch@lst.de>
> ---
> arch/powerpc/kernel/dma-swiotlb.c | 2 +-
> arch/x86/kernel/pci-swiotlb.c | 2 +-
> include/linux/swiotlb.h | 4 ++--
> lib/swiotlb.c | 2 +-
> 4 files changed, 5 insertions(+), 5 deletions(-)
>
> diff --git a/arch/powerpc/kernel/dma-swiotlb.c b/arch/powerpc/kernel/dma-swiotlb.c
> index 506ac4fafac5..88f3963ca30f 100644
> --- a/arch/powerpc/kernel/dma-swiotlb.c
> +++ b/arch/powerpc/kernel/dma-swiotlb.c
> @@ -121,7 +121,7 @@ static int __init check_swiotlb_enabled(void)
> if (ppc_swiotlb_enable)
> swiotlb_print_info();
> else
> - swiotlb_free();
> + swiotlb_exit();
>
> return 0;
> }
> diff --git a/arch/x86/kernel/pci-swiotlb.c b/arch/x86/kernel/pci-swiotlb.c
> index 0d77603c2f50..0ee0f8f34251 100644
> --- a/arch/x86/kernel/pci-swiotlb.c
> +++ b/arch/x86/kernel/pci-swiotlb.c
> @@ -120,7 +120,7 @@ void __init pci_swiotlb_late_init(void)
> {
> /* An IOMMU turned us off. */
> if (!swiotlb)
> - swiotlb_free();
> + swiotlb_exit();
> else {
> printk(KERN_INFO "PCI-DMA: "
> "Using software bounce buffering for IO (SWIOTLB)\n");
> diff --git a/include/linux/swiotlb.h b/include/linux/swiotlb.h
> index 24ed817082ee..606375e35d87 100644
> --- a/include/linux/swiotlb.h
> +++ b/include/linux/swiotlb.h
> @@ -115,10 +115,10 @@ extern int
> swiotlb_dma_supported(struct device *hwdev, u64 mask);
>
> #ifdef CONFIG_SWIOTLB
> -extern void __init swiotlb_free(void);
> +extern void __init swiotlb_exit(void);
> unsigned int swiotlb_max_segment(void);
> #else
> -static inline void swiotlb_free(void) { }
> +static inline void swiotlb_exit(void) { }
> static inline unsigned int swiotlb_max_segment(void) { return 0; }
> #endif
>
> diff --git a/lib/swiotlb.c b/lib/swiotlb.c
> index 125c1062119f..cf5311908fa9 100644
> --- a/lib/swiotlb.c
> +++ b/lib/swiotlb.c
> @@ -417,7 +417,7 @@ swiotlb_late_init_with_tbl(char *tlb, unsigned long nslabs)
> return -ENOMEM;
> }
>
> -void __init swiotlb_free(void)
> +void __init swiotlb_exit(void)
> {
> if (!io_tlb_orig_addr)
> return;
> --
> 2.14.2
>
^ permalink raw reply
* Re: [PATCH 05/22] x86: rename swiotlb_dma_ops
From: Konrad Rzeszutek Wilk @ 2018-01-12 13:25 UTC (permalink / raw)
To: Christoph Hellwig
Cc: iommu, Michal Simek, Guan Xuetao, Christian König,
linux-arm-kernel, linux-ia64, linux-mips, linuxppc-dev, x86,
linux-arch, linux-kernel
In-Reply-To: <20180110080932.14157-6-hch@lst.de>
On Wed, Jan 10, 2018 at 09:09:15AM +0100, Christoph Hellwig wrote:
> We'll need that name for a generic implementation soon.
>
> Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
> ---
> arch/x86/kernel/pci-swiotlb.c | 4 ++--
> 1 file changed, 2 insertions(+), 2 deletions(-)
>
> diff --git a/arch/x86/kernel/pci-swiotlb.c b/arch/x86/kernel/pci-swiotlb.c
> index 9d3e35c33d94..0d77603c2f50 100644
> --- a/arch/x86/kernel/pci-swiotlb.c
> +++ b/arch/x86/kernel/pci-swiotlb.c
> @@ -48,7 +48,7 @@ void x86_swiotlb_free_coherent(struct device *dev, size_t size,
> dma_generic_free_coherent(dev, size, vaddr, dma_addr, attrs);
> }
>
> -static const struct dma_map_ops swiotlb_dma_ops = {
> +static const struct dma_map_ops x86_swiotlb_dma_ops = {
> .mapping_error = swiotlb_dma_mapping_error,
> .alloc = x86_swiotlb_alloc_coherent,
> .free = x86_swiotlb_free_coherent,
> @@ -112,7 +112,7 @@ void __init pci_swiotlb_init(void)
> {
> if (swiotlb) {
> swiotlb_init(0);
> - dma_ops = &swiotlb_dma_ops;
> + dma_ops = &x86_swiotlb_dma_ops;
> }
> }
>
> --
> 2.14.2
>
^ permalink raw reply
* Re: [PATCH 04/22] powerpc: rename swiotlb_dma_ops
From: Konrad Rzeszutek Wilk @ 2018-01-12 13:25 UTC (permalink / raw)
To: Christoph Hellwig
Cc: iommu, Michal Simek, Guan Xuetao, Christian König,
linux-arm-kernel, linux-ia64, linux-mips, linuxppc-dev, x86,
linux-arch, linux-kernel
In-Reply-To: <20180110080932.14157-5-hch@lst.de>
On Wed, Jan 10, 2018 at 09:09:14AM +0100, Christoph Hellwig wrote:
> We'll need that name for a generic implementation soon.
>
Reviewed-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
> Signed-off-by: Christoph Hellwig <hch@lst.de>
> ---
> arch/powerpc/include/asm/swiotlb.h | 2 +-
> arch/powerpc/kernel/dma-swiotlb.c | 4 ++--
> arch/powerpc/kernel/dma.c | 2 +-
> arch/powerpc/sysdev/fsl_pci.c | 2 +-
> 4 files changed, 5 insertions(+), 5 deletions(-)
>
> diff --git a/arch/powerpc/include/asm/swiotlb.h b/arch/powerpc/include/asm/swiotlb.h
> index 9341ee804d19..f65ecf57b66c 100644
> --- a/arch/powerpc/include/asm/swiotlb.h
> +++ b/arch/powerpc/include/asm/swiotlb.h
> @@ -13,7 +13,7 @@
>
> #include <linux/swiotlb.h>
>
> -extern const struct dma_map_ops swiotlb_dma_ops;
> +extern const struct dma_map_ops powerpc_swiotlb_dma_ops;
>
> extern unsigned int ppc_swiotlb_enable;
> int __init swiotlb_setup_bus_notifier(void);
> diff --git a/arch/powerpc/kernel/dma-swiotlb.c b/arch/powerpc/kernel/dma-swiotlb.c
> index f1e99b9cee97..506ac4fafac5 100644
> --- a/arch/powerpc/kernel/dma-swiotlb.c
> +++ b/arch/powerpc/kernel/dma-swiotlb.c
> @@ -46,7 +46,7 @@ static u64 swiotlb_powerpc_get_required(struct device *dev)
> * map_page, and unmap_page on highmem, use normal dma_ops
> * for everything else.
> */
> -const struct dma_map_ops swiotlb_dma_ops = {
> +const struct dma_map_ops powerpc_swiotlb_dma_ops = {
> .alloc = __dma_nommu_alloc_coherent,
> .free = __dma_nommu_free_coherent,
> .mmap = dma_nommu_mmap_coherent,
> @@ -89,7 +89,7 @@ static int ppc_swiotlb_bus_notify(struct notifier_block *nb,
>
> /* May need to bounce if the device can't address all of DRAM */
> if ((dma_get_mask(dev) + 1) < memblock_end_of_DRAM())
> - set_dma_ops(dev, &swiotlb_dma_ops);
> + set_dma_ops(dev, &powerpc_swiotlb_dma_ops);
>
> return NOTIFY_DONE;
> }
> diff --git a/arch/powerpc/kernel/dma.c b/arch/powerpc/kernel/dma.c
> index 76079841d3d0..da20569de9d4 100644
> --- a/arch/powerpc/kernel/dma.c
> +++ b/arch/powerpc/kernel/dma.c
> @@ -33,7 +33,7 @@ static u64 __maybe_unused get_pfn_limit(struct device *dev)
> struct dev_archdata __maybe_unused *sd = &dev->archdata;
>
> #ifdef CONFIG_SWIOTLB
> - if (sd->max_direct_dma_addr && dev->dma_ops == &swiotlb_dma_ops)
> + if (sd->max_direct_dma_addr && dev->dma_ops == &powerpc_swiotlb_dma_ops)
> pfn = min_t(u64, pfn, sd->max_direct_dma_addr >> PAGE_SHIFT);
> #endif
>
> diff --git a/arch/powerpc/sysdev/fsl_pci.c b/arch/powerpc/sysdev/fsl_pci.c
> index e4d0133bbeeb..61e07c78d64f 100644
> --- a/arch/powerpc/sysdev/fsl_pci.c
> +++ b/arch/powerpc/sysdev/fsl_pci.c
> @@ -118,7 +118,7 @@ static void setup_swiotlb_ops(struct pci_controller *hose)
> {
> if (ppc_swiotlb_enable) {
> hose->controller_ops.dma_dev_setup = pci_dma_dev_setup_swiotlb;
> - set_pci_dma_ops(&swiotlb_dma_ops);
> + set_pci_dma_ops(&powerpc_swiotlb_dma_ops);
> }
> }
> #else
> --
> 2.14.2
>
^ permalink raw reply
* Re: [PATCH 03/22] ia64: rename swiotlb_dma_ops
From: Konrad Rzeszutek Wilk @ 2018-01-12 13:24 UTC (permalink / raw)
To: Christoph Hellwig
Cc: iommu, Michal Simek, Guan Xuetao, Christian König,
linux-arm-kernel, linux-ia64, linux-mips, linuxppc-dev, x86,
linux-arch, linux-kernel
In-Reply-To: <20180110080932.14157-4-hch@lst.de>
On Wed, Jan 10, 2018 at 09:09:13AM +0100, Christoph Hellwig wrote:
> We'll need that name for a generic implementation soon.
>
> Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
> ---
> arch/ia64/hp/common/hwsw_iommu.c | 4 ++--
> arch/ia64/hp/common/sba_iommu.c | 6 +++---
> arch/ia64/kernel/pci-swiotlb.c | 6 +++---
> 3 files changed, 8 insertions(+), 8 deletions(-)
>
> diff --git a/arch/ia64/hp/common/hwsw_iommu.c b/arch/ia64/hp/common/hwsw_iommu.c
> index 63d8e1d2477f..41279f0442bd 100644
> --- a/arch/ia64/hp/common/hwsw_iommu.c
> +++ b/arch/ia64/hp/common/hwsw_iommu.c
> @@ -19,7 +19,7 @@
> #include <linux/export.h>
> #include <asm/machvec.h>
>
> -extern const struct dma_map_ops sba_dma_ops, swiotlb_dma_ops;
> +extern const struct dma_map_ops sba_dma_ops, ia64_swiotlb_dma_ops;
>
> /* swiotlb declarations & definitions: */
> extern int swiotlb_late_init_with_default_size (size_t size);
> @@ -38,7 +38,7 @@ static inline int use_swiotlb(struct device *dev)
> const struct dma_map_ops *hwsw_dma_get_ops(struct device *dev)
> {
> if (use_swiotlb(dev))
> - return &swiotlb_dma_ops;
> + return &ia64_swiotlb_dma_ops;
> return &sba_dma_ops;
> }
> EXPORT_SYMBOL(hwsw_dma_get_ops);
> diff --git a/arch/ia64/hp/common/sba_iommu.c b/arch/ia64/hp/common/sba_iommu.c
> index aec4a3354abe..8c0a9ae6afec 100644
> --- a/arch/ia64/hp/common/sba_iommu.c
> +++ b/arch/ia64/hp/common/sba_iommu.c
> @@ -2096,7 +2096,7 @@ static int __init acpi_sba_ioc_init_acpi(void)
> /* This has to run before acpi_scan_init(). */
> arch_initcall(acpi_sba_ioc_init_acpi);
>
> -extern const struct dma_map_ops swiotlb_dma_ops;
> +extern const struct dma_map_ops ia64_swiotlb_dma_ops;
>
> static int __init
> sba_init(void)
> @@ -2111,7 +2111,7 @@ sba_init(void)
> * a successful kdump kernel boot is to use the swiotlb.
> */
> if (is_kdump_kernel()) {
> - dma_ops = &swiotlb_dma_ops;
> + dma_ops = &ia64_swiotlb_dma_ops;
> if (swiotlb_late_init_with_default_size(64 * (1<<20)) != 0)
> panic("Unable to initialize software I/O TLB:"
> " Try machvec=dig boot option");
> @@ -2133,7 +2133,7 @@ sba_init(void)
> * If we didn't find something sba_iommu can claim, we
> * need to setup the swiotlb and switch to the dig machvec.
> */
> - dma_ops = &swiotlb_dma_ops;
> + dma_ops = &ia64_swiotlb_dma_ops;
> if (swiotlb_late_init_with_default_size(64 * (1<<20)) != 0)
> panic("Unable to find SBA IOMMU or initialize "
> "software I/O TLB: Try machvec=dig boot option");
> diff --git a/arch/ia64/kernel/pci-swiotlb.c b/arch/ia64/kernel/pci-swiotlb.c
> index 5e50939aa03e..f1ae873a8c35 100644
> --- a/arch/ia64/kernel/pci-swiotlb.c
> +++ b/arch/ia64/kernel/pci-swiotlb.c
> @@ -31,7 +31,7 @@ static void ia64_swiotlb_free_coherent(struct device *dev, size_t size,
> swiotlb_free_coherent(dev, size, vaddr, dma_addr);
> }
>
> -const struct dma_map_ops swiotlb_dma_ops = {
> +const struct dma_map_ops ia64_swiotlb_dma_ops = {
> .alloc = ia64_swiotlb_alloc_coherent,
> .free = ia64_swiotlb_free_coherent,
> .map_page = swiotlb_map_page,
> @@ -48,7 +48,7 @@ const struct dma_map_ops swiotlb_dma_ops = {
>
> void __init swiotlb_dma_init(void)
> {
> - dma_ops = &swiotlb_dma_ops;
> + dma_ops = &ia64_swiotlb_dma_ops;
> swiotlb_init(1);
> }
>
> @@ -60,7 +60,7 @@ void __init pci_swiotlb_init(void)
> printk(KERN_INFO "PCI-DMA: Re-initialize machine vector.\n");
> machvec_init("dig");
> swiotlb_init(1);
> - dma_ops = &swiotlb_dma_ops;
> + dma_ops = &ia64_swiotlb_dma_ops;
> #else
> panic("Unable to find Intel IOMMU");
> #endif
> --
> 2.14.2
>
^ permalink raw reply
* Re: [PATCH 21/33] dma-mapping: add an arch_dma_supported hook
From: Konrad Rzeszutek Wilk @ 2018-01-12 13:17 UTC (permalink / raw)
To: Christoph Hellwig
Cc: iommu, linux-alpha, linux-snps-arc, linux-arm-kernel,
linux-c6x-dev, linux-cris-kernel, linux-hexagon, linux-ia64,
linux-m68k, linux-metag, Michal Simek, linux-mips, linux-parisc,
linuxppc-dev, patches, linux-s390, linux-sh, sparclinux,
Guan Xuetao, x86, linux-arch, linux-kernel
In-Reply-To: <20180110080027.13879-22-hch@lst.de>
On Wed, Jan 10, 2018 at 09:00:15AM +0100, Christoph Hellwig wrote:
> To implement the x86 forbid_dac and iommu_sac_force we want an arch hook
> so that it can apply the global options across all dma_map_ops
> implementations.
>
> Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
> ---
> arch/x86/include/asm/dma-mapping.h | 3 +++
> arch/x86/kernel/pci-dma.c | 19 ++++++++++++-------
> include/linux/dma-mapping.h | 11 +++++++++++
> 3 files changed, 26 insertions(+), 7 deletions(-)
>
> diff --git a/arch/x86/include/asm/dma-mapping.h b/arch/x86/include/asm/dma-mapping.h
> index dfdc9357a349..6277c83c0eb1 100644
> --- a/arch/x86/include/asm/dma-mapping.h
> +++ b/arch/x86/include/asm/dma-mapping.h
> @@ -30,6 +30,9 @@ static inline const struct dma_map_ops *get_arch_dma_ops(struct bus_type *bus)
> return dma_ops;
> }
>
> +int arch_dma_supported(struct device *dev, u64 mask);
> +#define arch_dma_supported arch_dma_supported
> +
> bool arch_dma_alloc_attrs(struct device **dev, gfp_t *gfp);
> #define arch_dma_alloc_attrs arch_dma_alloc_attrs
>
> diff --git a/arch/x86/kernel/pci-dma.c b/arch/x86/kernel/pci-dma.c
> index 61a8f1cb3829..df7ab02f959f 100644
> --- a/arch/x86/kernel/pci-dma.c
> +++ b/arch/x86/kernel/pci-dma.c
> @@ -215,7 +215,7 @@ static __init int iommu_setup(char *p)
> }
> early_param("iommu", iommu_setup);
>
> -int x86_dma_supported(struct device *dev, u64 mask)
> +int arch_dma_supported(struct device *dev, u64 mask)
> {
> #ifdef CONFIG_PCI
> if (mask > 0xffffffff && forbid_dac > 0) {
> @@ -224,12 +224,6 @@ int x86_dma_supported(struct device *dev, u64 mask)
> }
> #endif
>
> - /* Copied from i386. Doesn't make much sense, because it will
> - only work for pci_alloc_coherent.
> - The caller just has to use GFP_DMA in this case. */
> - if (mask < DMA_BIT_MASK(24))
> - return 0;
> -
> /* Tell the device to use SAC when IOMMU force is on. This
> allows the driver to use cheaper accesses in some cases.
>
> @@ -249,6 +243,17 @@ int x86_dma_supported(struct device *dev, u64 mask)
>
> return 1;
> }
> +EXPORT_SYMBOL(arch_dma_supported);
> +
> +int x86_dma_supported(struct device *dev, u64 mask)
> +{
> + /* Copied from i386. Doesn't make much sense, because it will
> + only work for pci_alloc_coherent.
> + The caller just has to use GFP_DMA in this case. */
> + if (mask < DMA_BIT_MASK(24))
> + return 0;
> + return 1;
> +}
>
> static int __init pci_iommu_init(void)
> {
> diff --git a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h
> index 88bcb1a8211d..d67742dad904 100644
> --- a/include/linux/dma-mapping.h
> +++ b/include/linux/dma-mapping.h
> @@ -576,6 +576,14 @@ static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
> return 0;
> }
>
> +/*
> + * This is a hack for the legacy x86 forbid_dac and iommu_sac_force. Please
> + * don't use this is new code.
> + */
> +#ifndef arch_dma_supported
> +#define arch_dma_supported(dev, mask) (1)
> +#endif
> +
> static inline void dma_check_mask(struct device *dev, u64 mask)
> {
> if (sme_active() && (mask < (((u64)sme_get_me_mask() << 1) - 1)))
> @@ -588,6 +596,9 @@ static inline int dma_supported(struct device *dev, u64 mask)
>
> if (!ops)
> return 0;
> + if (!arch_dma_supported(dev, mask))
> + return 0;
> +
> if (!ops->dma_supported)
> return 1;
> return ops->dma_supported(dev, mask);
> --
> 2.14.2
>
^ permalink raw reply
* Re: [PATCH 19/33] dma-mapping: warn when there is no coherent_dma_mask
From: Konrad Rzeszutek Wilk @ 2018-01-12 13:16 UTC (permalink / raw)
To: Christoph Hellwig
Cc: iommu, linux-alpha, linux-snps-arc, linux-arm-kernel,
linux-c6x-dev, linux-cris-kernel, linux-hexagon, linux-ia64,
linux-m68k, linux-metag, Michal Simek, linux-mips, linux-parisc,
linuxppc-dev, patches, linux-s390, linux-sh, sparclinux,
Guan Xuetao, x86, linux-arch, linux-kernel
In-Reply-To: <20180110080027.13879-20-hch@lst.de>
On Wed, Jan 10, 2018 at 09:00:13AM +0100, Christoph Hellwig wrote:
> These days all devices should have a DMA coherent mask, and most dma_ops
> implementations rely on that fact. But just to be sure add an assert to
> ring the warning bell if that is not the case.
>
> Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
> ---
> include/linux/dma-mapping.h | 1 +
> 1 file changed, 1 insertion(+)
>
> diff --git a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h
> index d84951865be7..9f28b2fa329e 100644
> --- a/include/linux/dma-mapping.h
> +++ b/include/linux/dma-mapping.h
> @@ -513,6 +513,7 @@ static inline void *dma_alloc_attrs(struct device *dev, size_t size,
> void *cpu_addr;
>
> BUG_ON(!ops);
> + WARN_ON_ONCE(!dev->coherent_dma_mask);
>
> if (dma_alloc_from_dev_coherent(dev, size, dma_handle, &cpu_addr))
> return cpu_addr;
> --
> 2.14.2
>
^ permalink raw reply
* [PATCH 8/8] powerpc/8xx: Use L1 entry APG to handle _PAGE_ACCESSED for CONFIG_SWAP
From: Christophe Leroy @ 2018-01-12 12:45 UTC (permalink / raw)
To: Benjamin Herrenschmidt, Paul Mackerras, Michael Ellerman,
Scott Wood
Cc: linux-kernel, linuxppc-dev
In-Reply-To: <bb30d80cc985d7307fa1286c9e6824230698919b.1515759812.git.christophe.leroy@c-s.fr>
When CONFIG_SWAP is set, the TLB miss handlers have to also take
into account _PAGE_ACCESSED flag. At the moment it is done by
anding _PAGE_ACCESSED into _PAGE_PRESENT using 3 instructions.
This patch uses APG for handling _PAGE_ACCESSED, allowing to
just copy _PAGE_ACCESSED bit into APG field, hence reducing the
action to a single instruction.
Signed-off-by: Christophe Leroy <christophe.leroy@c-s.fr>
---
arch/powerpc/include/asm/mmu-8xx.h | 34 +++++++++++++++++++++++-----
arch/powerpc/kernel/head_8xx.S | 45 +++++++++++++++-----------------------
arch/powerpc/mm/8xx_mmu.c | 2 +-
3 files changed, 47 insertions(+), 34 deletions(-)
diff --git a/arch/powerpc/include/asm/mmu-8xx.h b/arch/powerpc/include/asm/mmu-8xx.h
index ae68f6c848d3..ee5591fe6efc 100644
--- a/arch/powerpc/include/asm/mmu-8xx.h
+++ b/arch/powerpc/include/asm/mmu-8xx.h
@@ -34,12 +34,20 @@
* respectively NA for All or X for Supervisor and no access for User.
* Then we use the APG to say whether accesses are according to Page rules or
* "all Supervisor" rules (Access to all)
- * Therefore, we define 2 APG groups. lsb is _PMD_USER
- * 0 => No user => 01 (all accesses performed according to page definition)
- * 1 => User => 00 (all accesses performed as supervisor iaw page definition)
+ * We also use the 2nd APG bit for _PAGE_ACCESSED when having SWAP:
+ * When that bit is not set access is done iaw "all user"
+ * which means no access iaw page rules.
+ * Therefore, we define 4 APG groups. lsb is _PMD_USER, 2nd is _PAGE_ACCESSED
+ * 0x => No access => 11 (all accesses performed as user iaw page definition)
+ * 10 => No user => 01 (all accesses performed according to page definition)
+ * 11 => User => 00 (all accesses performed as supervisor iaw page definition)
* We define all 16 groups so that all other bits of APG can take any value
*/
+#ifdef CONFIG_SWAP
+#define MI_APG_INIT 0xf4f4f4f4
+#else
#define MI_APG_INIT 0x44444444
+#endif
/* The effective page number register. When read, contains the information
* about the last instruction TLB miss. When MI_RPN is written, bits in
@@ -107,12 +115,20 @@
* Supervisor and no access for user and NA for ALL.
* Then we use the APG to say whether accesses are according to Page rules or
* "all Supervisor" rules (Access to all)
- * Therefore, we define 2 APG groups. lsb is _PMD_USER
- * 0 => No user => 01 (all accesses performed according to page definition)
- * 1 => User => 00 (all accesses performed as supervisor iaw page definition)
+ * We also use the 2nd APG bit for _PAGE_ACCESSED when having SWAP:
+ * When that bit is not set access is done iaw "all user"
+ * which means no access iaw page rules.
+ * Therefore, we define 4 APG groups. lsb is _PMD_USER, 2nd is _PAGE_ACCESSED
+ * 0x => No access => 11 (all accesses performed as user iaw page definition)
+ * 10 => No user => 01 (all accesses performed according to page definition)
+ * 11 => User => 00 (all accesses performed as supervisor iaw page definition)
* We define all 16 groups so that all other bits of APG can take any value
*/
+#ifdef CONFIG_SWAP
+#define MD_APG_INIT 0xf4f4f4f4
+#else
#define MD_APG_INIT 0x44444444
+#endif
/* The effective page number register. When read, contains the information
* about the last instruction TLB miss. When MD_RPN is written, bits in
@@ -164,6 +180,12 @@
*/
#define SPRN_M_TW 799
+/* APGs */
+#define M_APG0 0x00000000
+#define M_APG1 0x00000020
+#define M_APG2 0x00000040
+#define M_APG3 0x00000060
+
#ifndef __ASSEMBLY__
typedef struct {
unsigned int id;
diff --git a/arch/powerpc/kernel/head_8xx.S b/arch/powerpc/kernel/head_8xx.S
index c3b831bb8bad..d8670a37d70c 100644
--- a/arch/powerpc/kernel/head_8xx.S
+++ b/arch/powerpc/kernel/head_8xx.S
@@ -354,14 +354,13 @@ _ENTRY(ITLBMiss_cmp)
#if defined(ITLB_MISS_KERNEL) || defined(CONFIG_HUGETLB_PAGE)
mtcr r12
#endif
- /* Load the MI_TWC with the attributes for this "segment." */
- mtspr SPRN_MI_TWC, r11 /* Set segment attributes */
#ifdef CONFIG_SWAP
- rlwinm r11, r10, 32-5, _PAGE_PRESENT
- and r11, r11, r10
- rlwimi r10, r11, 0, _PAGE_PRESENT
+ rlwinm r11, r10, 31, _PAGE_ACCESSED >> 1
#endif
+ /* Load the MI_TWC with the attributes for this "segment." */
+ mtspr SPRN_MI_TWC, r11 /* Set segment attributes */
+
li r11, RPN_PATTERN | 0x200
/* The Linux PTE won't go exactly into the MMU TLB.
* Software indicator bits 20 and 23 must be clear.
@@ -472,22 +471,14 @@ _ENTRY(DTLBMiss_jmp)
* above.
*/
rlwimi r11, r10, 0, _PAGE_GUARDED
- mtspr SPRN_MD_TWC, r11
-
- /* Both _PAGE_ACCESSED and _PAGE_PRESENT has to be set.
- * We also need to know if the insn is a load/store, so:
- * Clear _PAGE_PRESENT and load that which will
- * trap into DTLB Error with store bit set accordinly.
- */
- /* PRESENT=0x1, ACCESSED=0x20
- * r11 = ((r10 & PRESENT) & ((r10 & ACCESSED) >> 5));
- * r10 = (r10 & ~PRESENT) | r11;
- */
#ifdef CONFIG_SWAP
- rlwinm r11, r10, 32-5, _PAGE_PRESENT
- and r11, r11, r10
- rlwimi r10, r11, 0, _PAGE_PRESENT
+ /* _PAGE_ACCESSED has to be set. We use second APG bit for that, 0
+ * on that bit will represent a Non Access group
+ */
+ rlwinm r11, r10, 31, _PAGE_ACCESSED >> 1
#endif
+ mtspr SPRN_MD_TWC, r11
+
/* The Linux PTE won't go exactly into the MMU TLB.
* Software indicator bits 24, 25, 26, and 27 must be
* set. All other Linux PTE bits control the behavior
@@ -647,8 +638,8 @@ InstructionBreakpoint:
*/
DTLBMissIMMR:
mtcr r12
- /* Set 512k byte guarded page and mark it valid */
- li r10, MD_PS512K | MD_GUARDED | MD_SVALID
+ /* Set 512k byte guarded page and mark it valid and accessed */
+ li r10, MD_PS512K | MD_GUARDED | MD_SVALID | M_APG2
mtspr SPRN_MD_TWC, r10
mfspr r10, SPRN_IMMR /* Get current IMMR */
rlwinm r10, r10, 0, 0xfff80000 /* Get 512 kbytes boundary */
@@ -666,8 +657,8 @@ _ENTRY(dtlb_miss_exit_2)
DTLBMissLinear:
mtcr r12
- /* Set 8M byte page and mark it valid */
- li r11, MD_PS8MEG | MD_SVALID
+ /* Set 8M byte page and mark it valid and accessed */
+ li r11, MD_PS8MEG | MD_SVALID | M_APG2
mtspr SPRN_MD_TWC, r11
rlwinm r10, r10, 0, 0x0f800000 /* 8xx supports max 256Mb RAM */
ori r10, r10, 0xf0 | MD_SPS16K | _PAGE_PRIVILEGED | _PAGE_DIRTY | \
@@ -685,8 +676,8 @@ _ENTRY(dtlb_miss_exit_3)
#ifndef CONFIG_PIN_TLB_TEXT
ITLBMissLinear:
mtcr r12
- /* Set 8M byte page and mark it valid */
- li r11, MI_PS8MEG | MI_SVALID
+ /* Set 8M byte page and mark it valid,accessed */
+ li r11, MI_PS8MEG | MI_SVALID | M_APG2
mtspr SPRN_MI_TWC, r11
rlwinm r10, r10, 0, 0x0f800000 /* 8xx supports max 256Mb RAM */
ori r10, r10, 0xf0 | MI_SPS16K | _PAGE_PRIVILEGED | _PAGE_DIRTY | \
@@ -969,7 +960,7 @@ initial_mmu:
ori r8, r8, MI_EVALID /* Mark it valid */
mtspr SPRN_MI_EPN, r8
li r8, MI_PS8MEG /* Set 8M byte page */
- ori r8, r8, MI_SVALID /* Make it valid */
+ ori r8, r8, MI_SVALID | M_APG2 /* Make it valid, APG 2 */
mtspr SPRN_MI_TWC, r8
li r8, MI_BOOTINIT /* Create RPN for address 0 */
mtspr SPRN_MI_RPN, r8 /* Store TLB entry */
@@ -996,7 +987,7 @@ initial_mmu:
ori r8, r8, MD_EVALID /* Mark it valid */
mtspr SPRN_MD_EPN, r8
li r8, MD_PS512K | MD_GUARDED /* Set 512k byte page */
- ori r8, r8, MD_SVALID /* Make it valid */
+ ori r8, r8, MD_SVALID | M_APG2 /* Make it valid and accessed */
mtspr SPRN_MD_TWC, r8
mr r8, r9 /* Create paddr for TLB */
ori r8, r8, MI_BOOTINIT|0x2 /* Inhibit cache -- Cort */
diff --git a/arch/powerpc/mm/8xx_mmu.c b/arch/powerpc/mm/8xx_mmu.c
index 5d53684c2ebd..cf77d755246d 100644
--- a/arch/powerpc/mm/8xx_mmu.c
+++ b/arch/powerpc/mm/8xx_mmu.c
@@ -79,7 +79,7 @@ void __init MMU_init_hw(void)
for (; i < 32 && mem >= LARGE_PAGE_SIZE_8M; i++) {
mtspr(SPRN_MD_CTR, ctr | (i << 8));
mtspr(SPRN_MD_EPN, (unsigned long)__va(addr) | MD_EVALID);
- mtspr(SPRN_MD_TWC, MD_PS8MEG | MD_SVALID);
+ mtspr(SPRN_MD_TWC, MD_PS8MEG | MD_SVALID | M_APG2);
mtspr(SPRN_MD_RPN, addr | flags | _PAGE_PRESENT);
addr += LARGE_PAGE_SIZE_8M;
mem -= LARGE_PAGE_SIZE_8M;
--
2.13.3
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox