mirror of
https://github.com/raspberrypi/linux.git
synced 2025-12-19 00:04:18 +00:00
eb0ece1602
Pull MM updates from Andrew Morton: - The series "Enable strict percpu address space checks" from Uros Bizjak uses x86 named address space qualifiers to provide compile-time checking of percpu area accesses. This has caused a small amount of fallout - two or three issues were reported. In all cases the calling code was found to be incorrect. - The series "Some cleanup for memcg" from Chen Ridong implements some relatively monir cleanups for the memcontrol code. - The series "mm: fixes for device-exclusive entries (hmm)" from David Hildenbrand fixes a boatload of issues which David found then using device-exclusive PTE entries when THP is enabled. More work is needed, but this makes thins better - our own HMM selftests now succeed. - The series "mm: zswap: remove z3fold and zbud" from Yosry Ahmed remove the z3fold and zbud implementations. They have been deprecated for half a year and nobody has complained. - The series "mm: further simplify VMA merge operation" from Lorenzo Stoakes implements numerous simplifications in this area. No runtime effects are anticipated. - The series "mm/madvise: remove redundant mmap_lock operations from process_madvise()" from SeongJae Park rationalizes the locking in the madvise() implementation. Performance gains of 20-25% were observed in one MADV_DONTNEED microbenchmark. - The series "Tiny cleanup and improvements about SWAP code" from Baoquan He contains a number of touchups to issues which Baoquan noticed when working on the swap code. - The series "mm: kmemleak: Usability improvements" from Catalin Marinas implements a couple of improvements to the kmemleak user-visible output. - The series "mm/damon/paddr: fix large folios access and schemes handling" from Usama Arif provides a couple of fixes for DAMON's handling of large folios. - The series "mm/damon/core: fix wrong and/or useless damos_walk() behaviors" from SeongJae Park fixes a few issues with the accuracy of kdamond's walking of DAMON regions. - The series "expose mapping wrprotect, fix fb_defio use" from Lorenzo Stoakes changes the interaction between framebuffer deferred-io and core MM. No functional changes are anticipated - this is preparatory work for the future removal of page structure fields. - The series "mm/damon: add support for hugepage_size DAMOS filter" from Usama Arif adds a DAMOS filter which permits the filtering by huge page sizes. - The series "mm: permit guard regions for file-backed/shmem mappings" from Lorenzo Stoakes extends the guard region feature from its present "anon mappings only" state. The feature now covers shmem and file-backed mappings. - The series "mm: batched unmap lazyfree large folios during reclamation" from Barry Song cleans up and speeds up the unmapping for pte-mapped large folios. - The series "reimplement per-vma lock as a refcount" from Suren Baghdasaryan puts the vm_lock back into the vma. Our reasons for pulling it out were largely bogus and that change made the code more messy. This patchset provides small (0-10%) improvements on one microbenchmark. - The series "Docs/mm/damon: misc DAMOS filters documentation fixes and improves" from SeongJae Park does some maintenance work on the DAMON docs. - The series "hugetlb/CMA improvements for large systems" from Frank van der Linden addresses a pile of issues which have been observed when using CMA on large machines. - The series "mm/damon: introduce DAMOS filter type for unmapped pages" from SeongJae Park enables users of DMAON/DAMOS to filter my the page's mapped/unmapped status. - The series "zsmalloc/zram: there be preemption" from Sergey Senozhatsky teaches zram to run its compression and decompression operations preemptibly. - The series "selftests/mm: Some cleanups from trying to run them" from Brendan Jackman fixes a pile of unrelated issues which Brendan encountered while runnimg our selftests. - The series "fs/proc/task_mmu: add guard region bit to pagemap" from Lorenzo Stoakes permits userspace to use /proc/pid/pagemap to determine whether a particular page is a guard page. - The series "mm, swap: remove swap slot cache" from Kairui Song removes the swap slot cache from the allocation path - it simply wasn't being effective. - The series "mm: cleanups for device-exclusive entries (hmm)" from David Hildenbrand implements a number of unrelated cleanups in this code. - The series "mm: Rework generic PTDUMP configs" from Anshuman Khandual implements a number of preparatoty cleanups to the GENERIC_PTDUMP Kconfig logic. - The series "mm/damon: auto-tune aggregation interval" from SeongJae Park implements a feedback-driven automatic tuning feature for DAMON's aggregation interval tuning. - The series "Fix lazy mmu mode" from Ryan Roberts fixes some issues in powerpc, sparc and x86 lazy MMU implementations. Ryan did this in preparation for implementing lazy mmu mode for arm64 to optimize vmalloc. - The series "mm/page_alloc: Some clarifications for migratetype fallback" from Brendan Jackman reworks some commentary to make the code easier to follow. - The series "page_counter cleanup and size reduction" from Shakeel Butt cleans up the page_counter code and fixes a size increase which we accidentally added late last year. - The series "Add a command line option that enables control of how many threads should be used to allocate huge pages" from Thomas Prescher does that. It allows the careful operator to significantly reduce boot time by tuning the parallalization of huge page initialization. - The series "Fix calculations in trace_balance_dirty_pages() for cgwb" from Tang Yizhou fixes the tracing output from the dirty page balancing code. - The series "mm/damon: make allow filters after reject filters useful and intuitive" from SeongJae Park improves the handling of allow and reject filters. Behaviour is made more consistent and the documention is updated accordingly. - The series "Switch zswap to object read/write APIs" from Yosry Ahmed updates zswap to the new object read/write APIs and thus permits the removal of some legacy code from zpool and zsmalloc. - The series "Some trivial cleanups for shmem" from Baolin Wang does as it claims. - The series "fs/dax: Fix ZONE_DEVICE page reference counts" from Alistair Popple regularizes the weird ZONE_DEVICE page refcount handling in DAX, permittig the removal of a number of special-case checks. - The series "refactor mremap and fix bug" from Lorenzo Stoakes is a preparatoty refactoring and cleanup of the mremap() code. - The series "mm: MM owner tracking for large folios (!hugetlb) + CONFIG_NO_PAGE_MAPCOUNT" from David Hildenbrand reworks the manner in which we determine whether a large folio is known to be mapped exclusively into a single MM. - The series "mm/damon: add sysfs dirs for managing DAMOS filters based on handling layers" from SeongJae Park adds a couple of new sysfs directories to ease the management of DAMON/DAMOS filters. - The series "arch, mm: reduce code duplication in mem_init()" from Mike Rapoport consolidates many per-arch implementations of mem_init() into code generic code, where that is practical. - The series "mm/damon/sysfs: commit parameters online via damon_call()" from SeongJae Park continues the cleaning up of sysfs access to DAMON internal data. - The series "mm: page_ext: Introduce new iteration API" from Luiz Capitulino reworks the page_ext initialization to fix a boot-time crash which was observed with an unusual combination of compile and cmdline options. - The series "Buddy allocator like (or non-uniform) folio split" from Zi Yan reworks the code to split a folio into smaller folios. The main benefit is lessened memory consumption: fewer post-split folios are generated. - The series "Minimize xa_node allocation during xarry split" from Zi Yan reduces the number of xarray xa_nodes which are generated during an xarray split. - The series "drivers/base/memory: Two cleanups" from Gavin Shan performs some maintenance work on the drivers/base/memory code. - The series "Add tracepoints for lowmem reserves, watermarks and totalreserve_pages" from Martin Liu adds some more tracepoints to the page allocator code. - The series "mm/madvise: cleanup requests validations and classifications" from SeongJae Park cleans up some warts which SeongJae observed during his earlier madvise work. - The series "mm/hwpoison: Fix regressions in memory failure handling" from Shuai Xue addresses two quite serious regressions which Shuai has observed in the memory-failure implementation. - The series "mm: reliable huge page allocator" from Johannes Weiner makes huge page allocations cheaper and more reliable by reducing fragmentation. - The series "Minor memcg cleanups & prep for memdescs" from Matthew Wilcox is preparatory work for the future implementation of memdescs. - The series "track memory used by balloon drivers" from Nico Pache introduces a way to track memory used by our various balloon drivers. - The series "mm/damon: introduce DAMOS filter type for active pages" from Nhat Pham permits users to filter for active/inactive pages, separately for file and anon pages. - The series "Adding Proactive Memory Reclaim Statistics" from Hao Jia separates the proactive reclaim statistics from the direct reclaim statistics. - The series "mm/vmscan: don't try to reclaim hwpoison folio" from Jinjiang Tu fixes our handling of hwpoisoned pages within the reclaim code. * tag 'mm-stable-2025-03-30-16-52' of git://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm: (431 commits) mm/page_alloc: remove unnecessary __maybe_unused in order_to_pindex() x86/mm: restore early initialization of high_memory for 32-bits mm/vmscan: don't try to reclaim hwpoison folio mm/hwpoison: introduce folio_contain_hwpoisoned_page() helper cgroup: docs: add pswpin and pswpout items in cgroup v2 doc mm: vmscan: split proactive reclaim statistics from direct reclaim statistics selftests/mm: speed up split_huge_page_test selftests/mm: uffd-unit-tests support for hugepages > 2M docs/mm/damon/design: document active DAMOS filter type mm/damon: implement a new DAMOS filter type for active pages fs/dax: don't disassociate zero page entries MM documentation: add "Unaccepted" meminfo entry selftests/mm: add commentary about 9pfs bugs fork: use __vmalloc_node() for stack allocation docs/mm: Physical Memory: Populate the "Zones" section xen: balloon: update the NR_BALLOON_PAGES state hv_balloon: update the NR_BALLOON_PAGES state balloon_compaction: update the NR_BALLOON_PAGES state meminfo: add a per node counter for balloon drivers mm: remove references to folio in __memcg_kmem_uncharge_page() ...
670 lines
23 KiB
C
670 lines
23 KiB
C
/* SPDX-License-Identifier: GPL-2.0 */
|
|
#ifndef _ASM_X86_PERCPU_H
|
|
#define _ASM_X86_PERCPU_H
|
|
|
|
#ifdef CONFIG_X86_64
|
|
# define __percpu_seg gs
|
|
# define __percpu_rel (%rip)
|
|
#else
|
|
# define __percpu_seg fs
|
|
# define __percpu_rel
|
|
#endif
|
|
|
|
#ifdef __ASSEMBLER__
|
|
|
|
#ifdef CONFIG_SMP
|
|
# define __percpu %__percpu_seg:
|
|
#else
|
|
# define __percpu
|
|
#endif
|
|
|
|
#define PER_CPU_VAR(var) __percpu(var)__percpu_rel
|
|
|
|
#else /* !__ASSEMBLY__: */
|
|
|
|
#include <linux/args.h>
|
|
#include <linux/build_bug.h>
|
|
#include <linux/stringify.h>
|
|
#include <asm/asm.h>
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
#ifdef CONFIG_CC_HAS_NAMED_AS
|
|
|
|
#ifdef __CHECKER__
|
|
# define __seg_gs __attribute__((address_space(__seg_gs)))
|
|
# define __seg_fs __attribute__((address_space(__seg_fs)))
|
|
#endif
|
|
|
|
#define __percpu_seg_override CONCATENATE(__seg_, __percpu_seg)
|
|
#define __percpu_prefix ""
|
|
|
|
#else /* !CONFIG_CC_HAS_NAMED_AS: */
|
|
|
|
#define __percpu_seg_override
|
|
#define __percpu_prefix "%%"__stringify(__percpu_seg)":"
|
|
|
|
#endif /* CONFIG_CC_HAS_NAMED_AS */
|
|
|
|
#define __force_percpu_prefix "%%"__stringify(__percpu_seg)":"
|
|
#define __my_cpu_offset this_cpu_read(this_cpu_off)
|
|
|
|
/*
|
|
* Compared to the generic __my_cpu_offset version, the following
|
|
* saves one instruction and avoids clobbering a temp register.
|
|
*
|
|
* arch_raw_cpu_ptr should not be used in 32-bit VDSO for a 64-bit
|
|
* kernel, because games are played with CONFIG_X86_64 there and
|
|
* sizeof(this_cpu_off) becames 4.
|
|
*/
|
|
#ifndef BUILD_VDSO32_64
|
|
#define arch_raw_cpu_ptr(_ptr) \
|
|
({ \
|
|
unsigned long tcp_ptr__ = raw_cpu_read_long(this_cpu_off); \
|
|
\
|
|
tcp_ptr__ += (__force unsigned long)(_ptr); \
|
|
(TYPEOF_UNQUAL(*(_ptr)) __force __kernel *)tcp_ptr__; \
|
|
})
|
|
#else
|
|
#define arch_raw_cpu_ptr(_ptr) \
|
|
({ \
|
|
BUILD_BUG(); \
|
|
(TYPEOF_UNQUAL(*(_ptr)) __force __kernel *)0; \
|
|
})
|
|
#endif
|
|
|
|
#define PER_CPU_VAR(var) %__percpu_seg:(var)__percpu_rel
|
|
|
|
#else /* !CONFIG_SMP: */
|
|
|
|
#define __percpu_seg_override
|
|
#define __percpu_prefix ""
|
|
#define __force_percpu_prefix ""
|
|
|
|
#define PER_CPU_VAR(var) (var)__percpu_rel
|
|
|
|
#endif /* CONFIG_SMP */
|
|
|
|
#if defined(CONFIG_USE_X86_SEG_SUPPORT) && defined(USE_TYPEOF_UNQUAL)
|
|
# define __my_cpu_type(var) typeof(var)
|
|
# define __my_cpu_ptr(ptr) (ptr)
|
|
# define __my_cpu_var(var) (var)
|
|
|
|
# define __percpu_qual __percpu_seg_override
|
|
#else
|
|
# define __my_cpu_type(var) typeof(var) __percpu_seg_override
|
|
# define __my_cpu_ptr(ptr) (__my_cpu_type(*(ptr))*)(__force uintptr_t)(ptr)
|
|
# define __my_cpu_var(var) (*__my_cpu_ptr(&(var)))
|
|
#endif
|
|
|
|
#define __percpu_arg(x) __percpu_prefix "%" #x
|
|
#define __force_percpu_arg(x) __force_percpu_prefix "%" #x
|
|
|
|
/*
|
|
* For arch-specific code, we can use direct single-insn ops (they
|
|
* don't give an lvalue though).
|
|
*/
|
|
|
|
#define __pcpu_type_1 u8
|
|
#define __pcpu_type_2 u16
|
|
#define __pcpu_type_4 u32
|
|
#define __pcpu_type_8 u64
|
|
|
|
#define __pcpu_cast_1(val) ((u8)(((unsigned long) val) & 0xff))
|
|
#define __pcpu_cast_2(val) ((u16)(((unsigned long) val) & 0xffff))
|
|
#define __pcpu_cast_4(val) ((u32)(((unsigned long) val) & 0xffffffff))
|
|
#define __pcpu_cast_8(val) ((u64)(val))
|
|
|
|
#define __pcpu_op_1(op) op "b "
|
|
#define __pcpu_op_2(op) op "w "
|
|
#define __pcpu_op_4(op) op "l "
|
|
#define __pcpu_op_8(op) op "q "
|
|
|
|
#define __pcpu_reg_1(mod, x) mod "q" (x)
|
|
#define __pcpu_reg_2(mod, x) mod "r" (x)
|
|
#define __pcpu_reg_4(mod, x) mod "r" (x)
|
|
#define __pcpu_reg_8(mod, x) mod "r" (x)
|
|
|
|
#define __pcpu_reg_imm_1(x) "qi" (x)
|
|
#define __pcpu_reg_imm_2(x) "ri" (x)
|
|
#define __pcpu_reg_imm_4(x) "ri" (x)
|
|
#define __pcpu_reg_imm_8(x) "re" (x)
|
|
|
|
#ifdef CONFIG_USE_X86_SEG_SUPPORT
|
|
|
|
#define __raw_cpu_read(size, qual, pcp) \
|
|
({ \
|
|
*(qual __my_cpu_type(pcp) *)__my_cpu_ptr(&(pcp)); \
|
|
})
|
|
|
|
#define __raw_cpu_write(size, qual, pcp, val) \
|
|
do { \
|
|
*(qual __my_cpu_type(pcp) *)__my_cpu_ptr(&(pcp)) = (val); \
|
|
} while (0)
|
|
|
|
#define __raw_cpu_read_const(pcp) __raw_cpu_read(, , pcp)
|
|
|
|
#else /* !CONFIG_USE_X86_SEG_SUPPORT: */
|
|
|
|
#define __raw_cpu_read(size, qual, _var) \
|
|
({ \
|
|
__pcpu_type_##size pfo_val__; \
|
|
\
|
|
asm qual (__pcpu_op_##size("mov") \
|
|
__percpu_arg([var]) ", %[val]" \
|
|
: [val] __pcpu_reg_##size("=", pfo_val__) \
|
|
: [var] "m" (__my_cpu_var(_var))); \
|
|
\
|
|
(typeof(_var))(unsigned long) pfo_val__; \
|
|
})
|
|
|
|
#define __raw_cpu_write(size, qual, _var, _val) \
|
|
do { \
|
|
__pcpu_type_##size pto_val__ = __pcpu_cast_##size(_val); \
|
|
\
|
|
if (0) { \
|
|
TYPEOF_UNQUAL(_var) pto_tmp__; \
|
|
pto_tmp__ = (_val); \
|
|
(void)pto_tmp__; \
|
|
} \
|
|
asm qual (__pcpu_op_##size("mov") "%[val], " \
|
|
__percpu_arg([var]) \
|
|
: [var] "=m" (__my_cpu_var(_var)) \
|
|
: [val] __pcpu_reg_imm_##size(pto_val__)); \
|
|
} while (0)
|
|
|
|
/*
|
|
* The generic per-CPU infrastrucutre is not suitable for
|
|
* reading const-qualified variables.
|
|
*/
|
|
#define __raw_cpu_read_const(pcp) ({ BUILD_BUG(); (typeof(pcp))0; })
|
|
|
|
#endif /* CONFIG_USE_X86_SEG_SUPPORT */
|
|
|
|
#define __raw_cpu_read_stable(size, _var) \
|
|
({ \
|
|
__pcpu_type_##size pfo_val__; \
|
|
\
|
|
asm(__pcpu_op_##size("mov") \
|
|
__force_percpu_arg(a[var]) ", %[val]" \
|
|
: [val] __pcpu_reg_##size("=", pfo_val__) \
|
|
: [var] "i" (&(_var))); \
|
|
\
|
|
(typeof(_var))(unsigned long) pfo_val__; \
|
|
})
|
|
|
|
#define percpu_unary_op(size, qual, op, _var) \
|
|
({ \
|
|
asm qual (__pcpu_op_##size(op) __percpu_arg([var]) \
|
|
: [var] "+m" (__my_cpu_var(_var))); \
|
|
})
|
|
|
|
#define percpu_binary_op(size, qual, op, _var, _val) \
|
|
do { \
|
|
__pcpu_type_##size pto_val__ = __pcpu_cast_##size(_val); \
|
|
\
|
|
if (0) { \
|
|
TYPEOF_UNQUAL(_var) pto_tmp__; \
|
|
pto_tmp__ = (_val); \
|
|
(void)pto_tmp__; \
|
|
} \
|
|
asm qual (__pcpu_op_##size(op) "%[val], " __percpu_arg([var]) \
|
|
: [var] "+m" (__my_cpu_var(_var)) \
|
|
: [val] __pcpu_reg_imm_##size(pto_val__)); \
|
|
} while (0)
|
|
|
|
/*
|
|
* Generate a per-CPU add to memory instruction and optimize code
|
|
* if one is added or subtracted.
|
|
*/
|
|
#define percpu_add_op(size, qual, var, val) \
|
|
do { \
|
|
const int pao_ID__ = \
|
|
(__builtin_constant_p(val) && \
|
|
((val) == 1 || \
|
|
(val) == (typeof(val))-1)) ? (int)(val) : 0; \
|
|
\
|
|
if (0) { \
|
|
TYPEOF_UNQUAL(var) pao_tmp__; \
|
|
pao_tmp__ = (val); \
|
|
(void)pao_tmp__; \
|
|
} \
|
|
if (pao_ID__ == 1) \
|
|
percpu_unary_op(size, qual, "inc", var); \
|
|
else if (pao_ID__ == -1) \
|
|
percpu_unary_op(size, qual, "dec", var); \
|
|
else \
|
|
percpu_binary_op(size, qual, "add", var, val); \
|
|
} while (0)
|
|
|
|
/*
|
|
* Add return operation
|
|
*/
|
|
#define percpu_add_return_op(size, qual, _var, _val) \
|
|
({ \
|
|
__pcpu_type_##size paro_tmp__ = __pcpu_cast_##size(_val); \
|
|
\
|
|
asm qual (__pcpu_op_##size("xadd") "%[tmp], " \
|
|
__percpu_arg([var]) \
|
|
: [tmp] __pcpu_reg_##size("+", paro_tmp__), \
|
|
[var] "+m" (__my_cpu_var(_var)) \
|
|
: : "memory"); \
|
|
(typeof(_var))(unsigned long) (paro_tmp__ + _val); \
|
|
})
|
|
|
|
/*
|
|
* raw_cpu_xchg() can use a load-store since
|
|
* it is not required to be IRQ-safe.
|
|
*/
|
|
#define raw_percpu_xchg_op(_var, _nval) \
|
|
({ \
|
|
TYPEOF_UNQUAL(_var) pxo_old__ = raw_cpu_read(_var); \
|
|
\
|
|
raw_cpu_write(_var, _nval); \
|
|
\
|
|
pxo_old__; \
|
|
})
|
|
|
|
/*
|
|
* this_cpu_xchg() is implemented using CMPXCHG without a LOCK prefix.
|
|
* XCHG is expensive due to the implied LOCK prefix. The processor
|
|
* cannot prefetch cachelines if XCHG is used.
|
|
*/
|
|
#define this_percpu_xchg_op(_var, _nval) \
|
|
({ \
|
|
TYPEOF_UNQUAL(_var) pxo_old__ = this_cpu_read(_var); \
|
|
\
|
|
do { } while (!this_cpu_try_cmpxchg(_var, &pxo_old__, _nval)); \
|
|
\
|
|
pxo_old__; \
|
|
})
|
|
|
|
/*
|
|
* CMPXCHG has no such implied lock semantics as a result it is much
|
|
* more efficient for CPU-local operations.
|
|
*/
|
|
#define percpu_cmpxchg_op(size, qual, _var, _oval, _nval) \
|
|
({ \
|
|
__pcpu_type_##size pco_old__ = __pcpu_cast_##size(_oval); \
|
|
__pcpu_type_##size pco_new__ = __pcpu_cast_##size(_nval); \
|
|
\
|
|
asm qual (__pcpu_op_##size("cmpxchg") "%[nval], " \
|
|
__percpu_arg([var]) \
|
|
: [oval] "+a" (pco_old__), \
|
|
[var] "+m" (__my_cpu_var(_var)) \
|
|
: [nval] __pcpu_reg_##size(, pco_new__) \
|
|
: "memory"); \
|
|
\
|
|
(typeof(_var))(unsigned long) pco_old__; \
|
|
})
|
|
|
|
#define percpu_try_cmpxchg_op(size, qual, _var, _ovalp, _nval) \
|
|
({ \
|
|
bool success; \
|
|
__pcpu_type_##size *pco_oval__ = (__pcpu_type_##size *)(_ovalp); \
|
|
__pcpu_type_##size pco_old__ = *pco_oval__; \
|
|
__pcpu_type_##size pco_new__ = __pcpu_cast_##size(_nval); \
|
|
\
|
|
asm qual (__pcpu_op_##size("cmpxchg") "%[nval], " \
|
|
__percpu_arg([var]) \
|
|
CC_SET(z) \
|
|
: CC_OUT(z) (success), \
|
|
[oval] "+a" (pco_old__), \
|
|
[var] "+m" (__my_cpu_var(_var)) \
|
|
: [nval] __pcpu_reg_##size(, pco_new__) \
|
|
: "memory"); \
|
|
if (unlikely(!success)) \
|
|
*pco_oval__ = pco_old__; \
|
|
\
|
|
likely(success); \
|
|
})
|
|
|
|
#if defined(CONFIG_X86_32) && !defined(CONFIG_UML)
|
|
|
|
#define percpu_cmpxchg64_op(size, qual, _var, _oval, _nval) \
|
|
({ \
|
|
union { \
|
|
u64 var; \
|
|
struct { \
|
|
u32 low, high; \
|
|
}; \
|
|
} old__, new__; \
|
|
\
|
|
old__.var = _oval; \
|
|
new__.var = _nval; \
|
|
\
|
|
asm_inline qual ( \
|
|
ALTERNATIVE("call this_cpu_cmpxchg8b_emu", \
|
|
"cmpxchg8b " __percpu_arg([var]), X86_FEATURE_CX8) \
|
|
: ALT_OUTPUT_SP([var] "+m" (__my_cpu_var(_var)), \
|
|
"+a" (old__.low), "+d" (old__.high)) \
|
|
: "b" (new__.low), "c" (new__.high), \
|
|
"S" (&(_var)) \
|
|
: "memory"); \
|
|
\
|
|
old__.var; \
|
|
})
|
|
|
|
#define raw_cpu_cmpxchg64(pcp, oval, nval) percpu_cmpxchg64_op(8, , pcp, oval, nval)
|
|
#define this_cpu_cmpxchg64(pcp, oval, nval) percpu_cmpxchg64_op(8, volatile, pcp, oval, nval)
|
|
|
|
#define percpu_try_cmpxchg64_op(size, qual, _var, _ovalp, _nval) \
|
|
({ \
|
|
bool success; \
|
|
u64 *_oval = (u64 *)(_ovalp); \
|
|
union { \
|
|
u64 var; \
|
|
struct { \
|
|
u32 low, high; \
|
|
}; \
|
|
} old__, new__; \
|
|
\
|
|
old__.var = *_oval; \
|
|
new__.var = _nval; \
|
|
\
|
|
asm_inline qual ( \
|
|
ALTERNATIVE("call this_cpu_cmpxchg8b_emu", \
|
|
"cmpxchg8b " __percpu_arg([var]), X86_FEATURE_CX8) \
|
|
CC_SET(z) \
|
|
: ALT_OUTPUT_SP(CC_OUT(z) (success), \
|
|
[var] "+m" (__my_cpu_var(_var)), \
|
|
"+a" (old__.low), "+d" (old__.high)) \
|
|
: "b" (new__.low), "c" (new__.high), \
|
|
"S" (&(_var)) \
|
|
: "memory"); \
|
|
if (unlikely(!success)) \
|
|
*_oval = old__.var; \
|
|
\
|
|
likely(success); \
|
|
})
|
|
|
|
#define raw_cpu_try_cmpxchg64(pcp, ovalp, nval) percpu_try_cmpxchg64_op(8, , pcp, ovalp, nval)
|
|
#define this_cpu_try_cmpxchg64(pcp, ovalp, nval) percpu_try_cmpxchg64_op(8, volatile, pcp, ovalp, nval)
|
|
|
|
#endif /* defined(CONFIG_X86_32) && !defined(CONFIG_UML) */
|
|
|
|
#ifdef CONFIG_X86_64
|
|
#define raw_cpu_cmpxchg64(pcp, oval, nval) percpu_cmpxchg_op(8, , pcp, oval, nval);
|
|
#define this_cpu_cmpxchg64(pcp, oval, nval) percpu_cmpxchg_op(8, volatile, pcp, oval, nval);
|
|
|
|
#define raw_cpu_try_cmpxchg64(pcp, ovalp, nval) percpu_try_cmpxchg_op(8, , pcp, ovalp, nval);
|
|
#define this_cpu_try_cmpxchg64(pcp, ovalp, nval) percpu_try_cmpxchg_op(8, volatile, pcp, ovalp, nval);
|
|
|
|
#define percpu_cmpxchg128_op(size, qual, _var, _oval, _nval) \
|
|
({ \
|
|
union { \
|
|
u128 var; \
|
|
struct { \
|
|
u64 low, high; \
|
|
}; \
|
|
} old__, new__; \
|
|
\
|
|
old__.var = _oval; \
|
|
new__.var = _nval; \
|
|
\
|
|
asm_inline qual ( \
|
|
ALTERNATIVE("call this_cpu_cmpxchg16b_emu", \
|
|
"cmpxchg16b " __percpu_arg([var]), X86_FEATURE_CX16) \
|
|
: ALT_OUTPUT_SP([var] "+m" (__my_cpu_var(_var)), \
|
|
"+a" (old__.low), "+d" (old__.high)) \
|
|
: "b" (new__.low), "c" (new__.high), \
|
|
"S" (&(_var)) \
|
|
: "memory"); \
|
|
\
|
|
old__.var; \
|
|
})
|
|
|
|
#define raw_cpu_cmpxchg128(pcp, oval, nval) percpu_cmpxchg128_op(16, , pcp, oval, nval)
|
|
#define this_cpu_cmpxchg128(pcp, oval, nval) percpu_cmpxchg128_op(16, volatile, pcp, oval, nval)
|
|
|
|
#define percpu_try_cmpxchg128_op(size, qual, _var, _ovalp, _nval) \
|
|
({ \
|
|
bool success; \
|
|
u128 *_oval = (u128 *)(_ovalp); \
|
|
union { \
|
|
u128 var; \
|
|
struct { \
|
|
u64 low, high; \
|
|
}; \
|
|
} old__, new__; \
|
|
\
|
|
old__.var = *_oval; \
|
|
new__.var = _nval; \
|
|
\
|
|
asm_inline qual ( \
|
|
ALTERNATIVE("call this_cpu_cmpxchg16b_emu", \
|
|
"cmpxchg16b " __percpu_arg([var]), X86_FEATURE_CX16) \
|
|
CC_SET(z) \
|
|
: ALT_OUTPUT_SP(CC_OUT(z) (success), \
|
|
[var] "+m" (__my_cpu_var(_var)), \
|
|
"+a" (old__.low), "+d" (old__.high)) \
|
|
: "b" (new__.low), "c" (new__.high), \
|
|
"S" (&(_var)) \
|
|
: "memory"); \
|
|
if (unlikely(!success)) \
|
|
*_oval = old__.var; \
|
|
\
|
|
likely(success); \
|
|
})
|
|
|
|
#define raw_cpu_try_cmpxchg128(pcp, ovalp, nval) percpu_try_cmpxchg128_op(16, , pcp, ovalp, nval)
|
|
#define this_cpu_try_cmpxchg128(pcp, ovalp, nval) percpu_try_cmpxchg128_op(16, volatile, pcp, ovalp, nval)
|
|
|
|
#endif /* CONFIG_X86_64 */
|
|
|
|
#define raw_cpu_read_1(pcp) __raw_cpu_read(1, , pcp)
|
|
#define raw_cpu_read_2(pcp) __raw_cpu_read(2, , pcp)
|
|
#define raw_cpu_read_4(pcp) __raw_cpu_read(4, , pcp)
|
|
#define raw_cpu_write_1(pcp, val) __raw_cpu_write(1, , pcp, val)
|
|
#define raw_cpu_write_2(pcp, val) __raw_cpu_write(2, , pcp, val)
|
|
#define raw_cpu_write_4(pcp, val) __raw_cpu_write(4, , pcp, val)
|
|
|
|
#define this_cpu_read_1(pcp) __raw_cpu_read(1, volatile, pcp)
|
|
#define this_cpu_read_2(pcp) __raw_cpu_read(2, volatile, pcp)
|
|
#define this_cpu_read_4(pcp) __raw_cpu_read(4, volatile, pcp)
|
|
#define this_cpu_write_1(pcp, val) __raw_cpu_write(1, volatile, pcp, val)
|
|
#define this_cpu_write_2(pcp, val) __raw_cpu_write(2, volatile, pcp, val)
|
|
#define this_cpu_write_4(pcp, val) __raw_cpu_write(4, volatile, pcp, val)
|
|
|
|
#define this_cpu_read_stable_1(pcp) __raw_cpu_read_stable(1, pcp)
|
|
#define this_cpu_read_stable_2(pcp) __raw_cpu_read_stable(2, pcp)
|
|
#define this_cpu_read_stable_4(pcp) __raw_cpu_read_stable(4, pcp)
|
|
|
|
#define raw_cpu_add_1(pcp, val) percpu_add_op(1, , (pcp), val)
|
|
#define raw_cpu_add_2(pcp, val) percpu_add_op(2, , (pcp), val)
|
|
#define raw_cpu_add_4(pcp, val) percpu_add_op(4, , (pcp), val)
|
|
#define raw_cpu_and_1(pcp, val) percpu_binary_op(1, , "and", (pcp), val)
|
|
#define raw_cpu_and_2(pcp, val) percpu_binary_op(2, , "and", (pcp), val)
|
|
#define raw_cpu_and_4(pcp, val) percpu_binary_op(4, , "and", (pcp), val)
|
|
#define raw_cpu_or_1(pcp, val) percpu_binary_op(1, , "or", (pcp), val)
|
|
#define raw_cpu_or_2(pcp, val) percpu_binary_op(2, , "or", (pcp), val)
|
|
#define raw_cpu_or_4(pcp, val) percpu_binary_op(4, , "or", (pcp), val)
|
|
#define raw_cpu_xchg_1(pcp, val) raw_percpu_xchg_op(pcp, val)
|
|
#define raw_cpu_xchg_2(pcp, val) raw_percpu_xchg_op(pcp, val)
|
|
#define raw_cpu_xchg_4(pcp, val) raw_percpu_xchg_op(pcp, val)
|
|
|
|
#define this_cpu_add_1(pcp, val) percpu_add_op(1, volatile, (pcp), val)
|
|
#define this_cpu_add_2(pcp, val) percpu_add_op(2, volatile, (pcp), val)
|
|
#define this_cpu_add_4(pcp, val) percpu_add_op(4, volatile, (pcp), val)
|
|
#define this_cpu_and_1(pcp, val) percpu_binary_op(1, volatile, "and", (pcp), val)
|
|
#define this_cpu_and_2(pcp, val) percpu_binary_op(2, volatile, "and", (pcp), val)
|
|
#define this_cpu_and_4(pcp, val) percpu_binary_op(4, volatile, "and", (pcp), val)
|
|
#define this_cpu_or_1(pcp, val) percpu_binary_op(1, volatile, "or", (pcp), val)
|
|
#define this_cpu_or_2(pcp, val) percpu_binary_op(2, volatile, "or", (pcp), val)
|
|
#define this_cpu_or_4(pcp, val) percpu_binary_op(4, volatile, "or", (pcp), val)
|
|
#define this_cpu_xchg_1(pcp, nval) this_percpu_xchg_op(pcp, nval)
|
|
#define this_cpu_xchg_2(pcp, nval) this_percpu_xchg_op(pcp, nval)
|
|
#define this_cpu_xchg_4(pcp, nval) this_percpu_xchg_op(pcp, nval)
|
|
|
|
#define raw_cpu_add_return_1(pcp, val) percpu_add_return_op(1, , pcp, val)
|
|
#define raw_cpu_add_return_2(pcp, val) percpu_add_return_op(2, , pcp, val)
|
|
#define raw_cpu_add_return_4(pcp, val) percpu_add_return_op(4, , pcp, val)
|
|
#define raw_cpu_cmpxchg_1(pcp, oval, nval) percpu_cmpxchg_op(1, , pcp, oval, nval)
|
|
#define raw_cpu_cmpxchg_2(pcp, oval, nval) percpu_cmpxchg_op(2, , pcp, oval, nval)
|
|
#define raw_cpu_cmpxchg_4(pcp, oval, nval) percpu_cmpxchg_op(4, , pcp, oval, nval)
|
|
#define raw_cpu_try_cmpxchg_1(pcp, ovalp, nval) percpu_try_cmpxchg_op(1, , pcp, ovalp, nval)
|
|
#define raw_cpu_try_cmpxchg_2(pcp, ovalp, nval) percpu_try_cmpxchg_op(2, , pcp, ovalp, nval)
|
|
#define raw_cpu_try_cmpxchg_4(pcp, ovalp, nval) percpu_try_cmpxchg_op(4, , pcp, ovalp, nval)
|
|
|
|
#define this_cpu_add_return_1(pcp, val) percpu_add_return_op(1, volatile, pcp, val)
|
|
#define this_cpu_add_return_2(pcp, val) percpu_add_return_op(2, volatile, pcp, val)
|
|
#define this_cpu_add_return_4(pcp, val) percpu_add_return_op(4, volatile, pcp, val)
|
|
#define this_cpu_cmpxchg_1(pcp, oval, nval) percpu_cmpxchg_op(1, volatile, pcp, oval, nval)
|
|
#define this_cpu_cmpxchg_2(pcp, oval, nval) percpu_cmpxchg_op(2, volatile, pcp, oval, nval)
|
|
#define this_cpu_cmpxchg_4(pcp, oval, nval) percpu_cmpxchg_op(4, volatile, pcp, oval, nval)
|
|
#define this_cpu_try_cmpxchg_1(pcp, ovalp, nval) percpu_try_cmpxchg_op(1, volatile, pcp, ovalp, nval)
|
|
#define this_cpu_try_cmpxchg_2(pcp, ovalp, nval) percpu_try_cmpxchg_op(2, volatile, pcp, ovalp, nval)
|
|
#define this_cpu_try_cmpxchg_4(pcp, ovalp, nval) percpu_try_cmpxchg_op(4, volatile, pcp, ovalp, nval)
|
|
|
|
/*
|
|
* Per-CPU atomic 64-bit operations are only available under 64-bit kernels.
|
|
* 32-bit kernels must fall back to generic operations.
|
|
*/
|
|
#ifdef CONFIG_X86_64
|
|
|
|
#define raw_cpu_read_8(pcp) __raw_cpu_read(8, , pcp)
|
|
#define raw_cpu_write_8(pcp, val) __raw_cpu_write(8, , pcp, val)
|
|
|
|
#define this_cpu_read_8(pcp) __raw_cpu_read(8, volatile, pcp)
|
|
#define this_cpu_write_8(pcp, val) __raw_cpu_write(8, volatile, pcp, val)
|
|
|
|
#define this_cpu_read_stable_8(pcp) __raw_cpu_read_stable(8, pcp)
|
|
|
|
#define raw_cpu_add_8(pcp, val) percpu_add_op(8, , (pcp), val)
|
|
#define raw_cpu_and_8(pcp, val) percpu_binary_op(8, , "and", (pcp), val)
|
|
#define raw_cpu_or_8(pcp, val) percpu_binary_op(8, , "or", (pcp), val)
|
|
#define raw_cpu_add_return_8(pcp, val) percpu_add_return_op(8, , pcp, val)
|
|
#define raw_cpu_xchg_8(pcp, nval) raw_percpu_xchg_op(pcp, nval)
|
|
#define raw_cpu_cmpxchg_8(pcp, oval, nval) percpu_cmpxchg_op(8, , pcp, oval, nval)
|
|
#define raw_cpu_try_cmpxchg_8(pcp, ovalp, nval) percpu_try_cmpxchg_op(8, , pcp, ovalp, nval)
|
|
|
|
#define this_cpu_add_8(pcp, val) percpu_add_op(8, volatile, (pcp), val)
|
|
#define this_cpu_and_8(pcp, val) percpu_binary_op(8, volatile, "and", (pcp), val)
|
|
#define this_cpu_or_8(pcp, val) percpu_binary_op(8, volatile, "or", (pcp), val)
|
|
#define this_cpu_add_return_8(pcp, val) percpu_add_return_op(8, volatile, pcp, val)
|
|
#define this_cpu_xchg_8(pcp, nval) this_percpu_xchg_op(pcp, nval)
|
|
#define this_cpu_cmpxchg_8(pcp, oval, nval) percpu_cmpxchg_op(8, volatile, pcp, oval, nval)
|
|
#define this_cpu_try_cmpxchg_8(pcp, ovalp, nval) percpu_try_cmpxchg_op(8, volatile, pcp, ovalp, nval)
|
|
|
|
#define raw_cpu_read_long(pcp) raw_cpu_read_8(pcp)
|
|
|
|
#else /* !CONFIG_X86_64: */
|
|
|
|
/* There is no generic 64-bit read stable operation for 32-bit targets. */
|
|
#define this_cpu_read_stable_8(pcp) ({ BUILD_BUG(); (typeof(pcp))0; })
|
|
|
|
#define raw_cpu_read_long(pcp) raw_cpu_read_4(pcp)
|
|
|
|
#endif /* CONFIG_X86_64 */
|
|
|
|
#define this_cpu_read_const(pcp) __raw_cpu_read_const(pcp)
|
|
|
|
/*
|
|
* this_cpu_read() makes the compiler load the per-CPU variable every time
|
|
* it is accessed while this_cpu_read_stable() allows the value to be cached.
|
|
* this_cpu_read_stable() is more efficient and can be used if its value
|
|
* is guaranteed to be valid across CPUs. The current users include
|
|
* current_task and cpu_current_top_of_stack, both of which are
|
|
* actually per-thread variables implemented as per-CPU variables and
|
|
* thus stable for the duration of the respective task.
|
|
*/
|
|
#define this_cpu_read_stable(pcp) __pcpu_size_call_return(this_cpu_read_stable_, pcp)
|
|
|
|
#define x86_this_cpu_constant_test_bit(_nr, _var) \
|
|
({ \
|
|
unsigned long __percpu *addr__ = \
|
|
(unsigned long __percpu *)&(_var) + ((_nr) / BITS_PER_LONG); \
|
|
\
|
|
!!((1UL << ((_nr) % BITS_PER_LONG)) & raw_cpu_read(*addr__)); \
|
|
})
|
|
|
|
#define x86_this_cpu_variable_test_bit(_nr, _var) \
|
|
({ \
|
|
bool oldbit; \
|
|
\
|
|
asm volatile("btl %[nr], " __percpu_arg([var]) \
|
|
CC_SET(c) \
|
|
: CC_OUT(c) (oldbit) \
|
|
: [var] "m" (__my_cpu_var(_var)), \
|
|
[nr] "rI" (_nr)); \
|
|
oldbit; \
|
|
})
|
|
|
|
#define x86_this_cpu_test_bit(_nr, _var) \
|
|
(__builtin_constant_p(_nr) \
|
|
? x86_this_cpu_constant_test_bit(_nr, _var) \
|
|
: x86_this_cpu_variable_test_bit(_nr, _var))
|
|
|
|
|
|
#include <asm-generic/percpu.h>
|
|
|
|
/* We can use this directly for local CPU (faster). */
|
|
DECLARE_PER_CPU_CACHE_HOT(unsigned long, this_cpu_off);
|
|
|
|
#endif /* !__ASSEMBLER__ */
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
/*
|
|
* Define the "EARLY_PER_CPU" macros. These are used for some per_cpu
|
|
* variables that are initialized and accessed before there are per_cpu
|
|
* areas allocated.
|
|
*/
|
|
|
|
#define DEFINE_EARLY_PER_CPU(_type, _name, _initvalue) \
|
|
DEFINE_PER_CPU(_type, _name) = _initvalue; \
|
|
__typeof__(_type) _name##_early_map[NR_CPUS] __initdata = \
|
|
{ [0 ... NR_CPUS-1] = _initvalue }; \
|
|
__typeof__(_type) *_name##_early_ptr __refdata = _name##_early_map
|
|
|
|
#define DEFINE_EARLY_PER_CPU_READ_MOSTLY(_type, _name, _initvalue) \
|
|
DEFINE_PER_CPU_READ_MOSTLY(_type, _name) = _initvalue; \
|
|
__typeof__(_type) _name##_early_map[NR_CPUS] __initdata = \
|
|
{ [0 ... NR_CPUS-1] = _initvalue }; \
|
|
__typeof__(_type) *_name##_early_ptr __refdata = _name##_early_map
|
|
|
|
#define EXPORT_EARLY_PER_CPU_SYMBOL(_name) \
|
|
EXPORT_PER_CPU_SYMBOL(_name)
|
|
|
|
#define DECLARE_EARLY_PER_CPU(_type, _name) \
|
|
DECLARE_PER_CPU(_type, _name); \
|
|
extern __typeof__(_type) *_name##_early_ptr; \
|
|
extern __typeof__(_type) _name##_early_map[]
|
|
|
|
#define DECLARE_EARLY_PER_CPU_READ_MOSTLY(_type, _name) \
|
|
DECLARE_PER_CPU_READ_MOSTLY(_type, _name); \
|
|
extern __typeof__(_type) *_name##_early_ptr; \
|
|
extern __typeof__(_type) _name##_early_map[]
|
|
|
|
#define early_per_cpu_ptr(_name) (_name##_early_ptr)
|
|
#define early_per_cpu_map(_name, _idx) (_name##_early_map[_idx])
|
|
|
|
#define early_per_cpu(_name, _cpu) \
|
|
*(early_per_cpu_ptr(_name) ? \
|
|
&early_per_cpu_ptr(_name)[_cpu] : \
|
|
&per_cpu(_name, _cpu))
|
|
|
|
#else /* !CONFIG_SMP: */
|
|
#define DEFINE_EARLY_PER_CPU(_type, _name, _initvalue) \
|
|
DEFINE_PER_CPU(_type, _name) = _initvalue
|
|
|
|
#define DEFINE_EARLY_PER_CPU_READ_MOSTLY(_type, _name, _initvalue) \
|
|
DEFINE_PER_CPU_READ_MOSTLY(_type, _name) = _initvalue
|
|
|
|
#define EXPORT_EARLY_PER_CPU_SYMBOL(_name) \
|
|
EXPORT_PER_CPU_SYMBOL(_name)
|
|
|
|
#define DECLARE_EARLY_PER_CPU(_type, _name) \
|
|
DECLARE_PER_CPU(_type, _name)
|
|
|
|
#define DECLARE_EARLY_PER_CPU_READ_MOSTLY(_type, _name) \
|
|
DECLARE_PER_CPU_READ_MOSTLY(_type, _name)
|
|
|
|
#define early_per_cpu(_name, _cpu) per_cpu(_name, _cpu)
|
|
#define early_per_cpu_ptr(_name) NULL
|
|
/* no early_per_cpu_map() */
|
|
|
|
#endif /* !CONFIG_SMP */
|
|
|
|
#endif /* _ASM_X86_PERCPU_H */
|