leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

powerpc/mm: hand a context_t over to slice_mask_for_size() instead of mm_struct

Browse Source 
slice_mask_for_size() only uses mm->context, so hand directly a
pointer to the context. This will help moving the function in
subarch mmu.h in the next patch by avoiding having to include
the definition of struct mm_struct

Signed-off-by: Christophe Leroy <christophe.leroy@c-s.fr>
Reviewed-by: Aneesh Kumar K.V <aneesh.kumar@linux.ibm.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
This commit is contained in:
Christophe Leroy 2019-04-25 14:29:29 +00:00 committed by Michael Ellerman
parent 02f89aed6b
commit 6f60cc98df
1 changed files with 17 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
arch/powerpc/mm/slice.c
View File

@ -151,32 +151,32 @@ static void slice_mask_for_free(struct mm_struct *mm, struct slice_mask *ret,
} }
#ifdef CONFIG_PPC_BOOK3S_64 #ifdef CONFIG_PPC_BOOK3S_64
static struct slice_mask *slice_mask_for_size(struct mm_struct *mm, int psize) static struct slice_mask *slice_mask_for_size(mm_context_t *ctx, int psize)
{ {
#ifdef CONFIG_PPC_64K_PAGES #ifdef CONFIG_PPC_64K_PAGES
if (psize == MMU_PAGE_64K) if (psize == MMU_PAGE_64K)
return mm_ctx_slice_mask_64k(&mm->context); return mm_ctx_slice_mask_64k(&ctx);
#endif #endif
if (psize == MMU_PAGE_4K) if (psize == MMU_PAGE_4K)
return mm_ctx_slice_mask_4k(&mm->context); return mm_ctx_slice_mask_4k(&ctx);
#ifdef CONFIG_HUGETLB_PAGE #ifdef CONFIG_HUGETLB_PAGE
if (psize == MMU_PAGE_16M) if (psize == MMU_PAGE_16M)
return mm_ctx_slice_mask_16m(&mm->context); return mm_ctx_slice_mask_16m(&ctx);
if (psize == MMU_PAGE_16G) if (psize == MMU_PAGE_16G)
return mm_ctx_slice_mask_16g(&mm->context); return mm_ctx_slice_mask_16g(&ctx);
#endif #endif
BUG(); BUG();
} }
#elif defined(CONFIG_PPC_8xx) #elif defined(CONFIG_PPC_8xx)
static struct slice_mask *slice_mask_for_size(struct mm_struct *mm, int psize) static struct slice_mask *slice_mask_for_size(mm_context_t *ctx, int psize)
{ {
if (psize == mmu_virtual_psize) if (psize == mmu_virtual_psize)
return &mm->context.mask_base_psize; return &ctx->mask_base_psize;
#ifdef CONFIG_HUGETLB_PAGE #ifdef CONFIG_HUGETLB_PAGE
if (psize == MMU_PAGE_512K) if (psize == MMU_PAGE_512K)
return &mm->context.mask_512k; return &ctx->mask_512k;
if (psize == MMU_PAGE_8M) if (psize == MMU_PAGE_8M)
return &mm->context.mask_8m; return &ctx->mask_8m;
#endif #endif
BUG(); BUG();
} }
@ -246,7 +246,7 @@ static void slice_convert(struct mm_struct *mm,
slice_dbg("slice_convert(mm=%p, psize=%d)\n", mm, psize); slice_dbg("slice_convert(mm=%p, psize=%d)\n", mm, psize);
slice_print_mask(" mask", mask); slice_print_mask(" mask", mask);
psize_mask = slice_mask_for_size(mm, psize); psize_mask = slice_mask_for_size(&mm->context, psize);
/* We need to use a spinlock here to protect against /* We need to use a spinlock here to protect against
* concurrent 64k -> 4k demotion ... * concurrent 64k -> 4k demotion ...
@ -263,7 +263,7 @@ static void slice_convert(struct mm_struct *mm,
/* Update the slice_mask */ /* Update the slice_mask */
old_psize = (lpsizes[index] >> (mask_index * 4)) & 0xf; old_psize = (lpsizes[index] >> (mask_index * 4)) & 0xf;
old_mask = slice_mask_for_size(mm, old_psize); old_mask = slice_mask_for_size(&mm->context, old_psize);
old_mask->low_slices &= ~(1u << i); old_mask->low_slices &= ~(1u << i);
psize_mask->low_slices |= 1u << i; psize_mask->low_slices |= 1u << i;
@ -282,7 +282,7 @@ static void slice_convert(struct mm_struct *mm,
/* Update the slice_mask */ /* Update the slice_mask */
old_psize = (hpsizes[index] >> (mask_index * 4)) & 0xf; old_psize = (hpsizes[index] >> (mask_index * 4)) & 0xf;
old_mask = slice_mask_for_size(mm, old_psize); old_mask = slice_mask_for_size(&mm->context, old_psize);
__clear_bit(i, old_mask->high_slices); __clear_bit(i, old_mask->high_slices);
__set_bit(i, psize_mask->high_slices); __set_bit(i, psize_mask->high_slices);
@ -538,7 +538,7 @@ unsigned long slice_get_unmapped_area(unsigned long addr, unsigned long len,
/* First make up a "good" mask of slices that have the right size /* First make up a "good" mask of slices that have the right size
* already * already
*/ */
maskp = slice_mask_for_size(mm, psize); maskp = slice_mask_for_size(&mm->context, psize);
/* /*
* Here "good" means slices that are already the right page size, * Here "good" means slices that are already the right page size,
@ -565,7 +565,7 @@ unsigned long slice_get_unmapped_area(unsigned long addr, unsigned long len,
* a pointer to good mask for the next code to use. * a pointer to good mask for the next code to use.
*/ */
if (IS_ENABLED(CONFIG_PPC_64K_PAGES) && psize == MMU_PAGE_64K) { if (IS_ENABLED(CONFIG_PPC_64K_PAGES) && psize == MMU_PAGE_64K) {
compat_maskp = slice_mask_for_size(mm, MMU_PAGE_4K); compat_maskp = slice_mask_for_size(&mm->context, MMU_PAGE_4K);
if (fixed) if (fixed)
slice_or_mask(&good_mask, maskp, compat_maskp); slice_or_mask(&good_mask, maskp, compat_maskp);
else else
@ -760,7 +760,7 @@ void slice_init_new_context_exec(struct mm_struct *mm)
/* /*
* Slice mask cache starts zeroed, fill the default size cache. * Slice mask cache starts zeroed, fill the default size cache.
*/ */
mask = slice_mask_for_size(mm, psize); mask = slice_mask_for_size(&mm->context, psize);
mask->low_slices = ~0UL; mask->low_slices = ~0UL;
if (SLICE_NUM_HIGH) if (SLICE_NUM_HIGH)
bitmap_fill(mask->high_slices, SLICE_NUM_HIGH); bitmap_fill(mask->high_slices, SLICE_NUM_HIGH);
@ -819,14 +819,14 @@ int slice_is_hugepage_only_range(struct mm_struct *mm, unsigned long addr,
VM_BUG_ON(radix_enabled()); VM_BUG_ON(radix_enabled());
maskp = slice_mask_for_size(mm, psize); maskp = slice_mask_for_size(&mm->context, psize);
#ifdef CONFIG_PPC_64K_PAGES #ifdef CONFIG_PPC_64K_PAGES
/* We need to account for 4k slices too */ /* We need to account for 4k slices too */
if (psize == MMU_PAGE_64K) { if (psize == MMU_PAGE_64K) {
const struct slice_mask *compat_maskp; const struct slice_mask *compat_maskp;
struct slice_mask available; struct slice_mask available;
compat_maskp = slice_mask_for_size(mm, MMU_PAGE_4K); compat_maskp = slice_mask_for_size(&mm->context, MMU_PAGE_4K);
slice_or_mask(&available, maskp, compat_maskp); slice_or_mask(&available, maskp, compat_maskp);
return !slice_check_range_fits(mm, &available, addr, len); return !slice_check_range_fits(mm, &available, addr, len);
} }