FM / asm

/usr/src/linux-headers-5.15.0-190/arch/s390/include/asm/

/usr/src/linux-headers-5.15.0-190/arch/s390/include/asm

Name	Size	Mode	Actions
fpu/	-	0755	rm
trace/	-	0755	rm
vdso/	-	0755	rm
airq.h	3421	0644	edit dl rm
alternative-asm.h	3148	0644	edit dl rm
alternative.h	5742	0644	edit dl rm
ap.h	13098	0644	edit dl rm
appldata.h	1593	0644	edit dl rm
archrandom.h	1319	0644	edit dl rm
asm-const.h	376	0644	edit dl rm
asm-prototypes.h	227	0644	edit dl rm
atomic.h	4225	0644	edit dl rm
atomic_ops.h	5100	0644	edit dl rm
barrier.h	1892	0644	edit dl rm
bitops.h	10153	0644	edit dl rm
boot_data.h	481	0644	edit dl rm
bug.h	1562	0644	edit dl rm
bugs.h	441	0644	edit dl rm
cache.h	389	0644	edit dl rm
ccwdev.h	8506	0644	edit dl rm
ccwgroup.h	2301	0644	edit dl rm
checksum.h	3352	0644	edit dl rm
chpid.h	979	0644	edit dl rm
chsc.h	1384	0644	edit dl rm
cio.h	9083	0644	edit dl rm
clocksource.h	184	0644	edit dl rm
clp.h	1426	0644	edit dl rm
cmb.h	425	0644	edit dl rm
cmpxchg.h	5195	0644	edit dl rm
compat.h	5333	0644	edit dl rm
cpacf.h	17759	0644	edit dl rm
cpcmd.h	1135	0644	edit dl rm
cpu.h	549	0644	edit dl rm
cpufeature.h	958	0644	edit dl rm
cputime.h	840	0644	edit dl rm
cpu_mcf.h	3064	0644	edit dl rm
cpu_mf-insn.h	478	0644	edit dl rm
cpu_mf.h	9606	0644	edit dl rm
crw.h	1907	0644	edit dl rm
css_chars.h	904	0644	edit dl rm
ctl_reg.h	3715	0644	edit dl rm
current.h	405	0644	edit dl rm
debug.h	14318	0644	edit dl rm
delay.h	647	0644	edit dl rm
diag.h	7017	0644	edit dl rm
dis.h	636	0644	edit dl rm
dma.h	456	0644	edit dl rm
dwarf.h	952	0644	edit dl rm
eadm.h	2082	0644	edit dl rm
ebcdic.h	1442	0644	edit dl rm
elf.h	11210	0644	edit dl rm
entry-common.h	1590	0644	edit dl rm
exec.h	269	0644	edit dl rm
extable.h	2184	0644	edit dl rm
extmem.h	804	0644	edit dl rm
facility.h	2760	0644	edit dl rm
fcx.h	8102	0644	edit dl rm
ftrace.h	1875	0644	edit dl rm
ftrace.lds.h	720	0644	edit dl rm
futex.h	1927	0644	edit dl rm
gmap.h	5760	0644	edit dl rm
hardirq.h	777	0644	edit dl rm
hugetlb.h	2966	0644	edit dl rm
hw_irq.h	210	0644	edit dl rm
idals.h	5317	0644	edit dl rm
idle.h	753	0644	edit dl rm
io.h	2153	0644	edit dl rm
ipl.h	3708	0644	edit dl rm
irq.h	2635	0644	edit dl rm
irqflags.h	1810	0644	edit dl rm
irq_work.h	204	0644	edit dl rm
isc.h	1036	0644	edit dl rm
itcw.h	950	0644	edit dl rm
jump_label.h	1411	0644	edit dl rm
kasan.h	1772	0644	edit dl rm
Kbuild	253	0644	edit dl rm
kdebug.h	386	0644	edit dl rm
kexec.h	2620	0644	edit dl rm
kfence.h	1148	0644	edit dl rm
kprobes.h	2175	0644	edit dl rm
kvm_host.h	27155	0644	edit dl rm
kvm_para.h	3761	0644	edit dl rm
linkage.h	729	0644	edit dl rm
livepatch.h	474	0644	edit dl rm
lowcore.h	6595	0644	edit dl rm
mem_detect.h	2589	0644	edit dl rm
mem_encrypt.h	365	0644	edit dl rm
mmu.h	1515	0644	edit dl rm
mmu_context.h	3491	0644	edit dl rm
mmzone.h	316	0644	edit dl rm
module.h	1209	0644	edit dl rm
nmi.h	3698	0644	edit dl rm
nospec-branch.h	342	0644	edit dl rm
nospec-insn.h	3616	0644	edit dl rm
numa.h	386	0644	edit dl rm
os_info.h	1136	0644	edit dl rm
page-states.h	486	0644	edit dl rm
page.h	5194	0644	edit dl rm
pci.h	8691	0644	edit dl rm
pci_clp.h	5346	0644	edit dl rm
pci_debug.h	608	0644	edit dl rm
pci_dma.h	5541	0644	edit dl rm
pci_insn.h	4089	0644	edit dl rm
pci_io.h	4405	0644	edit dl rm
percpu.h	6638	0644	edit dl rm
perf_event.h	3245	0644	edit dl rm
pgalloc.h	4024	0644	edit dl rm
pgtable.h	51845	0644	edit dl rm
pkey.h	737	0644	edit dl rm
pnet.h	325	0644	edit dl rm
preempt.h	3218	0644	edit dl rm
processor.h	9637	0644	edit dl rm
ptdump.h	255	0644	edit dl rm
ptrace.h	5865	0644	edit dl rm
purgatory.h	329	0644	edit dl rm
qdio.h	10011	0644	edit dl rm
runtime_instr.h	634	0644	edit dl rm
schid.h	525	0644	edit dl rm
sclp.h	4332	0644	edit dl rm
scsw.h	24630	0644	edit dl rm
seccomp.h	808	0644	edit dl rm
sections.h	1357	0644	edit dl rm
serial.h	147	0644	edit dl rm
setup.h	5156	0644	edit dl rm
set_memory.h	989	0644	edit dl rm
shmparam.h	285	0644	edit dl rm
signal.h	644	0644	edit dl rm
sigp.h	1900	0644	edit dl rm
smp.h	1932	0644	edit dl rm
softirq_stack.h	329	0644	edit dl rm
sparsemem.h	214	0644	edit dl rm
spinlock.h	3525	0644	edit dl rm
spinlock_types.h	407	0644	edit dl rm
stacktrace.h	6168	0644	edit dl rm
stp.h	1706	0644	edit dl rm
string.h	5847	0644	edit dl rm
switch_to.h	1400	0644	edit dl rm
syscall.h	4148	0644	edit dl rm
syscall_wrapper.h	5506	0644	edit dl rm
sysinfo.h	4339	0644	edit dl rm
termios.h	685	0644	edit dl rm
thread_info.h	3605	0644	edit dl rm
timex.h	6538	0644	edit dl rm
tlb.h	4296	0644	edit dl rm
tlbflush.h	3233	0644	edit dl rm
topology.h	2876	0644	edit dl rm
tpi.h	736	0644	edit dl rm
types.h	318	0644	edit dl rm
uaccess.h	10049	0644	edit dl rm
unistd.h	1030	0644	edit dl rm
unwind.h	3360	0644	edit dl rm
uprobes.h	588	0644	edit dl rm
user.h	3384	0644	edit dl rm
uv.h	10977	0644	edit dl rm
vdso.h	746	0644	edit dl rm
vga.h	170	0644	edit dl rm
vmalloc.h	90	0644	edit dl rm
vmlinux.lds.h	1167	0644	edit dl rm
vtime.h	718	0644	edit dl rm
vtimer.h	830	0644	edit dl rm
vx-insn.h	13477	0644	edit dl rm
xor.h	454	0644	edit dl rm

Edit: /usr/src/linux-headers-5.15.0-190/arch/s390/include/asm/bitops.h (10153B)

/* SPDX-License-Identifier: GPL-2.0 */
/*
 *    Copyright IBM Corp. 1999,2013
 *
 *    Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com>,
 *
 * The description below was taken in large parts from the powerpc
 * bitops header file:
 * Within a word, bits are numbered LSB first.  Lot's of places make
 * this assumption by directly testing bits with (val & (1<<nr)).
 * This can cause confusion for large (> 1 word) bitmaps on a
 * big-endian system because, unlike little endian, the number of each
 * bit depends on the word size.
 *
 * The bitop functions are defined to work on unsigned longs, so the bits
 * end up numbered:
 *   |63..............0|127............64|191...........128|255...........192|
 *
 * We also have special functions which work with an MSB0 encoding.
 * The bits are numbered:
 *   |0..............63|64............127|128...........191|192...........255|
 *
 * The main difference is that bit 0-63 in the bit number field needs to be
 * reversed compared to the LSB0 encoded bit fields. This can be achieved by
 * XOR with 0x3f.
 *
 */

#ifndef _S390_BITOPS_H
#define _S390_BITOPS_H

#ifndef _LINUX_BITOPS_H
#error only <linux/bitops.h> can be included directly
#endif

#include <linux/typecheck.h>
#include <linux/compiler.h>
#include <linux/types.h>
#include <asm/atomic_ops.h>
#include <asm/barrier.h>

#define __BITOPS_WORDS(bits) (((bits) + BITS_PER_LONG - 1) / BITS_PER_LONG)

static inline unsigned long *
__bitops_word(unsigned long nr, const volatile unsigned long *ptr)
{
	unsigned long addr;

addr = (unsigned long)ptr + ((nr ^ (nr & (BITS_PER_LONG - 1))) >> 3);
	return (unsigned long *)addr;
}

static inline unsigned long __bitops_mask(unsigned long nr)
{
	return 1UL << (nr & (BITS_PER_LONG - 1));
}

static __always_inline void arch_set_bit(unsigned long nr, volatile unsigned long *ptr)
{
	unsigned long *addr = __bitops_word(nr, ptr);
	unsigned long mask = __bitops_mask(nr);

__atomic64_or(mask, (long *)addr);
}

static __always_inline void arch_clear_bit(unsigned long nr, volatile unsigned long *ptr)
{
	unsigned long *addr = __bitops_word(nr, ptr);
	unsigned long mask = __bitops_mask(nr);

__atomic64_and(~mask, (long *)addr);
}

static __always_inline void arch_change_bit(unsigned long nr,
					    volatile unsigned long *ptr)
{
	unsigned long *addr = __bitops_word(nr, ptr);
	unsigned long mask = __bitops_mask(nr);

__atomic64_xor(mask, (long *)addr);
}

static inline bool arch_test_and_set_bit(unsigned long nr,
					 volatile unsigned long *ptr)
{
	unsigned long *addr = __bitops_word(nr, ptr);
	unsigned long mask = __bitops_mask(nr);
	unsigned long old;

old = __atomic64_or_barrier(mask, (long *)addr);
	return old & mask;
}

static inline bool arch_test_and_clear_bit(unsigned long nr,
					   volatile unsigned long *ptr)
{
	unsigned long *addr = __bitops_word(nr, ptr);
	unsigned long mask = __bitops_mask(nr);
	unsigned long old;

old = __atomic64_and_barrier(~mask, (long *)addr);
	return old & mask;
}

static inline bool arch_test_and_change_bit(unsigned long nr,
					    volatile unsigned long *ptr)
{
	unsigned long *addr = __bitops_word(nr, ptr);
	unsigned long mask = __bitops_mask(nr);
	unsigned long old;

old = __atomic64_xor_barrier(mask, (long *)addr);
	return old & mask;
}

static inline void arch___set_bit(unsigned long nr, volatile unsigned long *ptr)
{
	unsigned long *addr = __bitops_word(nr, ptr);
	unsigned long mask = __bitops_mask(nr);

*addr |= mask;
}

static inline void arch___clear_bit(unsigned long nr,
				    volatile unsigned long *ptr)
{
	unsigned long *addr = __bitops_word(nr, ptr);
	unsigned long mask = __bitops_mask(nr);

*addr &= ~mask;
}

static inline void arch___change_bit(unsigned long nr,
				     volatile unsigned long *ptr)
{
	unsigned long *addr = __bitops_word(nr, ptr);
	unsigned long mask = __bitops_mask(nr);

*addr ^= mask;
}

static inline bool arch___test_and_set_bit(unsigned long nr,
					   volatile unsigned long *ptr)
{
	unsigned long *addr = __bitops_word(nr, ptr);
	unsigned long mask = __bitops_mask(nr);
	unsigned long old;

old = *addr;
	*addr |= mask;
	return old & mask;
}

static inline bool arch___test_and_clear_bit(unsigned long nr,
					     volatile unsigned long *ptr)
{
	unsigned long *addr = __bitops_word(nr, ptr);
	unsigned long mask = __bitops_mask(nr);
	unsigned long old;

old = *addr;
	*addr &= ~mask;
	return old & mask;
}

static inline bool arch___test_and_change_bit(unsigned long nr,
					      volatile unsigned long *ptr)
{
	unsigned long *addr = __bitops_word(nr, ptr);
	unsigned long mask = __bitops_mask(nr);
	unsigned long old;

old = *addr;
	*addr ^= mask;
	return old & mask;
}

static inline bool arch_test_bit(unsigned long nr,
				 const volatile unsigned long *ptr)
{
	const volatile unsigned long *addr = __bitops_word(nr, ptr);
	unsigned long mask = __bitops_mask(nr);

return *addr & mask;
}

static inline bool arch_test_and_set_bit_lock(unsigned long nr,
					      volatile unsigned long *ptr)
{
	if (arch_test_bit(nr, ptr))
		return 1;
	return arch_test_and_set_bit(nr, ptr);
}

static inline void arch_clear_bit_unlock(unsigned long nr,
					 volatile unsigned long *ptr)
{
	smp_mb__before_atomic();
	arch_clear_bit(nr, ptr);
}

static inline void arch___clear_bit_unlock(unsigned long nr,
					   volatile unsigned long *ptr)
{
	smp_mb();
	arch___clear_bit(nr, ptr);
}

#include <asm-generic/bitops/instrumented-atomic.h>
#include <asm-generic/bitops/instrumented-non-atomic.h>
#include <asm-generic/bitops/instrumented-lock.h>

/*
 * Functions which use MSB0 bit numbering.
 * The bits are numbered:
 *   |0..............63|64............127|128...........191|192...........255|
 */
unsigned long find_first_bit_inv(const unsigned long *addr, unsigned long size);
unsigned long find_next_bit_inv(const unsigned long *addr, unsigned long size,
				unsigned long offset);

#define for_each_set_bit_inv(bit, addr, size)				\
	for ((bit) = find_first_bit_inv((addr), (size));		\
	     (bit) < (size);						\
	     (bit) = find_next_bit_inv((addr), (size), (bit) + 1))

static inline void set_bit_inv(unsigned long nr, volatile unsigned long *ptr)
{
	return set_bit(nr ^ (BITS_PER_LONG - 1), ptr);
}

static inline void clear_bit_inv(unsigned long nr, volatile unsigned long *ptr)
{
	return clear_bit(nr ^ (BITS_PER_LONG - 1), ptr);
}

static inline bool test_and_clear_bit_inv(unsigned long nr,
					  volatile unsigned long *ptr)
{
	return test_and_clear_bit(nr ^ (BITS_PER_LONG - 1), ptr);
}

static inline void __set_bit_inv(unsigned long nr, volatile unsigned long *ptr)
{
	return __set_bit(nr ^ (BITS_PER_LONG - 1), ptr);
}

static inline void __clear_bit_inv(unsigned long nr, volatile unsigned long *ptr)
{
	return __clear_bit(nr ^ (BITS_PER_LONG - 1), ptr);
}

static inline bool test_bit_inv(unsigned long nr,
				const volatile unsigned long *ptr)
{
	return test_bit(nr ^ (BITS_PER_LONG - 1), ptr);
}

#ifdef CONFIG_HAVE_MARCH_Z9_109_FEATURES

/**
 * __flogr - find leftmost one
 * @word - The word to search
 *
 * Returns the bit number of the most significant bit set,
 * where the most significant bit has bit number 0.
 * If no bit is set this function returns 64.
 */
static inline unsigned char __flogr(unsigned long word)
{
	if (__builtin_constant_p(word)) {
		unsigned long bit = 0;

if (!word)
			return 64;
		if (!(word & 0xffffffff00000000UL)) {
			word <<= 32;
			bit += 32;
		}
		if (!(word & 0xffff000000000000UL)) {
			word <<= 16;
			bit += 16;
		}
		if (!(word & 0xff00000000000000UL)) {
			word <<= 8;
			bit += 8;
		}
		if (!(word & 0xf000000000000000UL)) {
			word <<= 4;
			bit += 4;
		}
		if (!(word & 0xc000000000000000UL)) {
			word <<= 2;
			bit += 2;
		}
		if (!(word & 0x8000000000000000UL)) {
			word <<= 1;
			bit += 1;
		}
		return bit;
	} else {
		union register_pair rp;

rp.even = word;
		asm volatile(
			"       flogr   %[rp],%[rp]\n"
			: [rp] "+d" (rp.pair) : : "cc");
		return rp.even;
	}
}

/**
 * __ffs - find first bit in word.
 * @word: The word to search
 *
 * Undefined if no bit exists, so code should check against 0 first.
 */
static inline unsigned long __ffs(unsigned long word)
{
	return __flogr(-word & word) ^ (BITS_PER_LONG - 1);
}

/**
 * ffs - find first bit set
 * @word: the word to search
 *
 * This is defined the same way as the libc and
 * compiler builtin ffs routines (man ffs).
 */
static inline int ffs(int word)
{
	unsigned long mask = 2 * BITS_PER_LONG - 1;
	unsigned int val = (unsigned int)word;

return (1 + (__flogr(-val & val) ^ (BITS_PER_LONG - 1))) & mask;
}

/**
 * __fls - find last (most-significant) set bit in a long word
 * @word: the word to search
 *
 * Undefined if no set bit exists, so code should check against 0 first.
 */
static inline unsigned long __fls(unsigned long word)
{
	return __flogr(word) ^ (BITS_PER_LONG - 1);
}

/**
 * fls64 - find last set bit in a 64-bit word
 * @word: the word to search
 *
 * This is defined in a similar way as the libc and compiler builtin
 * ffsll, but returns the position of the most significant set bit.
 *
 * fls64(value) returns 0 if value is 0 or the position of the last
 * set bit if value is nonzero. The last (most significant) bit is
 * at position 64.
 */
static inline int fls64(unsigned long word)
{
	unsigned long mask = 2 * BITS_PER_LONG - 1;

return (1 + (__flogr(word) ^ (BITS_PER_LONG - 1))) & mask;
}

/**
 * fls - find last (most-significant) bit set
 * @word: the word to search
 *
 * This is defined the same way as ffs.
 * Note fls(0) = 0, fls(1) = 1, fls(0x80000000) = 32.
 */
static inline int fls(unsigned int word)
{
	return fls64(word);
}

#else /* CONFIG_HAVE_MARCH_Z9_109_FEATURES */

#include <asm-generic/bitops/__ffs.h>
#include <asm-generic/bitops/ffs.h>
#include <asm-generic/bitops/__fls.h>
#include <asm-generic/bitops/fls.h>
#include <asm-generic/bitops/fls64.h>

#endif /* CONFIG_HAVE_MARCH_Z9_109_FEATURES */

#include <asm-generic/bitops/ffz.h>
#include <asm-generic/bitops/find.h>
#include <asm-generic/bitops/hweight.h>
#include <asm-generic/bitops/sched.h>
#include <asm-generic/bitops/le.h>
#include <asm-generic/bitops/ext2-atomic-setbit.h>

#endif /* _S390_BITOPS_H */

cmd: