FM / asm-generic

/usr/src/kernels/4.18.0-553.121.1.el8_10.x86_64/include/asm-generic/

/usr/src/kernels/4.18.0-553.121.1.el8_10.x86_64/include/asm-generic

Name	Size	Mode	Actions
bitops/	-	0755	rm
vdso/	-	0755	rm
4level-fixup.h	1098	0644	edit dl rm
5level-fixup.h	1273	0644	edit dl rm
asm-offsets.h	35	0644	edit dl rm
asm-prototypes.h	507	0644	edit dl rm
atomic-instrumented.h	13623	0644	edit dl rm
atomic-long.h	8048	0644	edit dl rm
atomic.h	4391	0644	edit dl rm
atomic64.h	1797	0644	edit dl rm
audit_change_attr.h	484	0644	edit dl rm
audit_dir_write.h	528	0644	edit dl rm
audit_read.h	241	0644	edit dl rm
audit_signal.h	36	0644	edit dl rm
audit_write.h	461	0644	edit dl rm
barrier.h	6868	0644	edit dl rm
bitops-instrumented.h	7909	0644	edit dl rm
bitops.h	1119	0644	edit dl rm
bitsperlong.h	592	0644	edit dl rm
bug.h	6720	0644	edit dl rm
bugs.h	267	0644	edit dl rm
cache.h	384	0644	edit dl rm
cacheflush.h	1340	0644	edit dl rm
checksum.h	2329	0644	edit dl rm
cmpxchg-local.h	1464	0644	edit dl rm
cmpxchg.h	2286	0644	edit dl rm
compat.h	658	0644	edit dl rm
current.h	256	0644	edit dl rm
delay.h	1157	0644	edit dl rm
device.h	245	0644	edit dl rm
div64.h	7458	0644	edit dl rm
dma-contiguous.h	238	0644	edit dl rm
dma-mapping.h	248	0644	edit dl rm
dma.h	553	0644	edit dl rm
early_ioremap.h	1696	0644	edit dl rm
emergency-restart.h	248	0644	edit dl rm
error-injection.h	1178	0644	edit dl rm
exec.h	667	0644	edit dl rm
export.h	2002	0644	edit dl rm
extable.h	802	0644	edit dl rm
fb.h	271	0644	edit dl rm
fixmap.h	2904	0644	edit dl rm
ftrace.h	460	0644	edit dl rm
futex.h	2964	0644	edit dl rm
getorder.h	1487	0644	edit dl rm
gpio.h	4558	0644	edit dl rm
hardirq.h	532	0644	edit dl rm
hugetlb.h	1326	0644	edit dl rm
hw_irq.h	270	0644	edit dl rm
hyperv-tlfs.h	20696	0644	edit dl rm
ide_iops.h	791	0644	edit dl rm
int-ll64.h	863	0644	edit dl rm
io.h	24167	0644	edit dl rm
ioctl.h	506	0644	edit dl rm
iomap.h	4033	0644	edit dl rm
irq.h	403	0644	edit dl rm
irqflags.h	1543	0644	edit dl rm
irq_regs.h	980	0644	edit dl rm
irq_work.h	194	0644	edit dl rm
kdebug.h	182	0644	edit dl rm
kmap_size.h	263	0644	edit dl rm
kprobes.h	868	0644	edit dl rm
kvm_para.h	549	0644	edit dl rm
kvm_types.h	113	0644	edit dl rm
linkage.h	225	0644	edit dl rm
local.h	2282	0644	edit dl rm
local64.h	3887	0644	edit dl rm
mcs_spinlock.h	260	0644	edit dl rm
memory_model.h	2209	0644	edit dl rm
mm-arch-hooks.h	388	0644	edit dl rm
mmiowb.h	1731	0644	edit dl rm
mmiowb_types.h	249	0644	edit dl rm
mmu.h	449	0644	edit dl rm
mmu_context.h	881	0644	edit dl rm
mm_hooks.h	854	0644	edit dl rm
module.h	1118	0644	edit dl rm
mshyperv.h	8592	0644	edit dl rm
msi.h	1053	0644	edit dl rm
numa.h	1544	0644	edit dl rm
page.h	2454	0644	edit dl rm
param.h	367	0644	edit dl rm
parport.h	604	0644	edit dl rm
pci.h	401	0644	edit dl rm
pci_iomap.h	1775	0644	edit dl rm
percpu.h	13026	0644	edit dl rm
pgalloc.h	342	0644	edit dl rm
pgtable-nop4d-hack.h	1965	0644	edit dl rm
pgtable-nop4d.h	1772	0644	edit dl rm
pgtable-nopmd.h	1944	0644	edit dl rm
pgtable-nopud.h	2071	0644	edit dl rm
pgtable.h	33765	0644	edit dl rm
pgtable_uffd.h	1052	0644	edit dl rm
preempt.h	1994	0644	edit dl rm
ptrace.h	1615	0644	edit dl rm
qrwlock.h	4315	0644	edit dl rm
qrwlock_types.h	682	0644	edit dl rm
qspinlock.h	3816	0644	edit dl rm
qspinlock_types.h	2590	0644	edit dl rm
resource.h	1100	0644	edit dl rm
seccomp.h	1328	0644	edit dl rm
sections.h	5306	0644	edit dl rm
segment.h	249	0644	edit dl rm
serial.h	345	0644	edit dl rm
set_memory.h	362	0644	edit dl rm
signal.h	308	0644	edit dl rm
simd.h	436	0644	edit dl rm
sizes.h	78	0644	edit dl rm
spinlock.h	329	0644	edit dl rm
statfs.h	169	0644	edit dl rm
string.h	281	0644	edit dl rm
switch_to.h	962	0644	edit dl rm
syscall.h	6389	0644	edit dl rm
syscalls.h	739	0644	edit dl rm
termios-base.h	2164	0644	edit dl rm
termios.h	2877	0644	edit dl rm
timex.h	508	0644	edit dl rm
tlb.h	22153	0644	edit dl rm
tlbflush.h	485	0644	edit dl rm
topology.h	2234	0644	edit dl rm
trace_clock.h	391	0644	edit dl rm
uaccess.h	5272	0644	edit dl rm
unaligned.h	1078	0644	edit dl rm
unistd.h	318	0644	edit dl rm
user.h	242	0644	edit dl rm
vga.h	587	0644	edit dl rm
vmlinux.lds.h	28848	0644	edit dl rm
vtime.h	52	0644	edit dl rm
word-at-a-time.h	2817	0644	edit dl rm
xor.h	13961	0644	edit dl rm

Edit: /usr/src/kernels/4.18.0-553.121.1.el8_10.x86_64/include/asm-generic/bitops-instrumented.h (7909B)

/* SPDX-License-Identifier: GPL-2.0 */

/*
 * This file provides wrappers with sanitizer instrumentation for bit
 * operations.
 *
 * To use this functionality, an arch's bitops.h file needs to define each of
 * the below bit operations with an arch_ prefix (e.g. arch_set_bit(),
 * arch___set_bit(), etc.).
 */
#ifndef _ASM_GENERIC_BITOPS_INSTRUMENTED_H
#define _ASM_GENERIC_BITOPS_INSTRUMENTED_H

#include <linux/kasan-checks.h>

/**
 * set_bit - Atomically set a bit in memory
 * @nr: the bit to set
 * @addr: the address to start counting from
 *
 * This is a relaxed atomic operation (no implied memory barriers).
 *
 * Note that @nr may be almost arbitrarily large; this function is not
 * restricted to acting on a single-word quantity.
 */
static inline void set_bit(long nr, volatile unsigned long *addr)
{
	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));
	arch_set_bit(nr, addr);
}

/**
 * __set_bit - Set a bit in memory
 * @nr: the bit to set
 * @addr: the address to start counting from
 *
 * Unlike set_bit(), this function is non-atomic. If it is called on the same
 * region of memory concurrently, the effect may be that only one operation
 * succeeds.
 */
static inline void __set_bit(long nr, volatile unsigned long *addr)
{
	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));
	arch___set_bit(nr, addr);
}

/**
 * clear_bit - Clears a bit in memory
 * @nr: Bit to clear
 * @addr: Address to start counting from
 *
 * This is a relaxed atomic operation (no implied memory barriers).
 */
static inline void clear_bit(long nr, volatile unsigned long *addr)
{
	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));
	arch_clear_bit(nr, addr);
}

/**
 * __clear_bit - Clears a bit in memory
 * @nr: the bit to clear
 * @addr: the address to start counting from
 *
 * Unlike clear_bit(), this function is non-atomic. If it is called on the same
 * region of memory concurrently, the effect may be that only one operation
 * succeeds.
 */
static inline void __clear_bit(long nr, volatile unsigned long *addr)
{
	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));
	arch___clear_bit(nr, addr);
}

/**
 * clear_bit_unlock - Clear a bit in memory, for unlock
 * @nr: the bit to set
 * @addr: the address to start counting from
 *
 * This operation is atomic and provides release barrier semantics.
 */
static inline void clear_bit_unlock(long nr, volatile unsigned long *addr)
{
	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));
	arch_clear_bit_unlock(nr, addr);
}

/**
 * __clear_bit_unlock - Clears a bit in memory
 * @nr: Bit to clear
 * @addr: Address to start counting from
 *
 * This is a non-atomic operation but implies a release barrier before the
 * memory operation. It can be used for an unlock if no other CPUs can
 * concurrently modify other bits in the word.
 */
static inline void __clear_bit_unlock(long nr, volatile unsigned long *addr)
{
	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));
	arch___clear_bit_unlock(nr, addr);
}

/**
 * change_bit - Toggle a bit in memory
 * @nr: Bit to change
 * @addr: Address to start counting from
 *
 * This is a relaxed atomic operation (no implied memory barriers).
 *
 * Note that @nr may be almost arbitrarily large; this function is not
 * restricted to acting on a single-word quantity.
 */
static inline void change_bit(long nr, volatile unsigned long *addr)
{
	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));
	arch_change_bit(nr, addr);
}

/**
 * __change_bit - Toggle a bit in memory
 * @nr: the bit to change
 * @addr: the address to start counting from
 *
 * Unlike change_bit(), this function is non-atomic. If it is called on the same
 * region of memory concurrently, the effect may be that only one operation
 * succeeds.
 */
static inline void __change_bit(long nr, volatile unsigned long *addr)
{
	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));
	arch___change_bit(nr, addr);
}

/**
 * test_and_set_bit - Set a bit and return its old value
 * @nr: Bit to set
 * @addr: Address to count from
 *
 * This is an atomic fully-ordered operation (implied full memory barrier).
 */
static inline bool test_and_set_bit(long nr, volatile unsigned long *addr)
{
	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));
	return arch_test_and_set_bit(nr, addr);
}

/**
 * __test_and_set_bit - Set a bit and return its old value
 * @nr: Bit to set
 * @addr: Address to count from
 *
 * This operation is non-atomic. If two instances of this operation race, one
 * can appear to succeed but actually fail.
 */
static inline bool __test_and_set_bit(long nr, volatile unsigned long *addr)
{
	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));
	return arch___test_and_set_bit(nr, addr);
}

/**
 * test_and_set_bit_lock - Set a bit and return its old value, for lock
 * @nr: Bit to set
 * @addr: Address to count from
 *
 * This operation is atomic and provides acquire barrier semantics if
 * the returned value is 0.
 * It can be used to implement bit locks.
 */
static inline bool test_and_set_bit_lock(long nr, volatile unsigned long *addr)
{
	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));
	return arch_test_and_set_bit_lock(nr, addr);
}

/**
 * test_and_clear_bit - Clear a bit and return its old value
 * @nr: Bit to clear
 * @addr: Address to count from
 *
 * This is an atomic fully-ordered operation (implied full memory barrier).
 */
static inline bool test_and_clear_bit(long nr, volatile unsigned long *addr)
{
	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));
	return arch_test_and_clear_bit(nr, addr);
}

/**
 * __test_and_clear_bit - Clear a bit and return its old value
 * @nr: Bit to clear
 * @addr: Address to count from
 *
 * This operation is non-atomic. If two instances of this operation race, one
 * can appear to succeed but actually fail.
 */
static inline bool __test_and_clear_bit(long nr, volatile unsigned long *addr)
{
	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));
	return arch___test_and_clear_bit(nr, addr);
}

/**
 * test_and_change_bit - Change a bit and return its old value
 * @nr: Bit to change
 * @addr: Address to count from
 *
 * This is an atomic fully-ordered operation (implied full memory barrier).
 */
static inline bool test_and_change_bit(long nr, volatile unsigned long *addr)
{
	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));
	return arch_test_and_change_bit(nr, addr);
}

/**
 * __test_and_change_bit - Change a bit and return its old value
 * @nr: Bit to change
 * @addr: Address to count from
 *
 * This operation is non-atomic. If two instances of this operation race, one
 * can appear to succeed but actually fail.
 */
static inline bool __test_and_change_bit(long nr, volatile unsigned long *addr)
{
	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));
	return arch___test_and_change_bit(nr, addr);
}

/**
 * test_bit - Determine whether a bit is set
 * @nr: bit number to test
 * @addr: Address to start counting from
 */
static inline bool test_bit(long nr, const volatile unsigned long *addr)
{
	kasan_check_read(addr + BIT_WORD(nr), sizeof(long));
	return arch_test_bit(nr, addr);
}

#if defined(arch_clear_bit_unlock_is_negative_byte)
/**
 * clear_bit_unlock_is_negative_byte - Clear a bit in memory and test if bottom
 *                                     byte is negative, for unlock.
 * @nr: the bit to clear
 * @addr: the address to start counting from
 *
 * This operation is atomic and provides release barrier semantics.
 *
 * This is a bit of a one-trick-pony for the filemap code, which clears
 * PG_locked and tests PG_waiters,
 */
static inline bool
clear_bit_unlock_is_negative_byte(long nr, volatile unsigned long *addr)
{
	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));
	return arch_clear_bit_unlock_is_negative_byte(nr, addr);
}
/* Let everybody know we have it. */
#define clear_bit_unlock_is_negative_byte clear_bit_unlock_is_negative_byte
#endif

#endif /* _ASM_GENERIC_BITOPS_INSTRUMENTED_H */

cmd: