Release 4.14 arch/s390/include/asm/bitops.h

Directory: arch/s390/include/asm
/* 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 <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, volatile unsigned long *ptr)
{
	unsigned long addr;

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

Contributors
Person Tokens Prop Commits CommitProp
Martin Schwidefsky 32 56.14% 3 42.86%
Heiko Carstens 16 28.07% 1 14.29%
Linus Torvalds (pre-git) 7 12.28% 1 14.29%
Akinobu Mita 1 1.75% 1 14.29%
Linus Torvalds 1 1.75% 1 14.29%
Total 57 100.00% 7 100.00%


static inline unsigned char *

__bitops_byte(unsigned long nr, volatile unsigned long *ptr)
{
	return ((unsigned char *)ptr) + ((nr ^ (BITS_PER_LONG - 8)) >> 3);
}

Contributors
Person Tokens Prop Commits CommitProp
Heiko Carstens 43 100.00% 1 100.00%
Total 43 100.00% 1 100.00%



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

#ifdef CONFIG_HAVE_MARCH_ZEC12_FEATURES
	if (__builtin_constant_p(nr)) {
		unsigned char *caddr = __bitops_byte(nr, ptr);

		asm volatile(
                        "oi     %0,%b1\n"
                        : "+Q" (*caddr)
                        : "i" (1 << (nr & 7))
                        : "cc", "memory");
		return;
	}
#endif
	mask = 1UL << (nr & (BITS_PER_LONG - 1));
	__atomic64_or(mask, addr);
}

Contributors
Person Tokens Prop Commits CommitProp
Heiko Carstens 62 73.81% 3 37.50%
Martin Schwidefsky 20 23.81% 3 37.50%
Akinobu Mita 1 1.19% 1 12.50%
Linus Torvalds (pre-git) 1 1.19% 1 12.50%
Total 84 100.00% 8 100.00%



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

#ifdef CONFIG_HAVE_MARCH_ZEC12_FEATURES
	if (__builtin_constant_p(nr)) {
		unsigned char *caddr = __bitops_byte(nr, ptr);

		asm volatile(
                        "ni     %0,%b1\n"
                        : "+Q" (*caddr)
                        : "i" (~(1 << (nr & 7)))
                        : "cc", "memory");
		return;
	}
#endif
	mask = ~(1UL << (nr & (BITS_PER_LONG - 1)));
	__atomic64_and(mask, addr);
}

Contributors
Person Tokens Prop Commits CommitProp
Heiko Carstens 41 47.13% 3 30.00%
Martin Schwidefsky 34 39.08% 4 40.00%
Linus Torvalds (pre-git) 10 11.49% 1 10.00%
Akinobu Mita 1 1.15% 1 10.00%
Linus Torvalds 1 1.15% 1 10.00%
Total 87 100.00% 10 100.00%



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

#ifdef CONFIG_HAVE_MARCH_ZEC12_FEATURES
	if (__builtin_constant_p(nr)) {
		unsigned char *caddr = __bitops_byte(nr, ptr);

		asm volatile(
                        "xi     %0,%b1\n"
                        : "+Q" (*caddr)
                        : "i" (1 << (nr & 7))
                        : "cc", "memory");
		return;
	}
#endif
	mask = 1UL << (nr & (BITS_PER_LONG - 1));
	__atomic64_xor(mask, addr);
}

Contributors
Person Tokens Prop Commits CommitProp
Heiko Carstens 41 48.81% 3 30.00%
Martin Schwidefsky 32 38.10% 4 40.00%
Linus Torvalds (pre-git) 9 10.71% 1 10.00%
Linus Torvalds 1 1.19% 1 10.00%
Akinobu Mita 1 1.19% 1 10.00%
Total 84 100.00% 10 100.00%


static inline int

test_and_set_bit(unsigned long nr, volatile unsigned long *ptr)
{
	unsigned long *addr = __bitops_word(nr, ptr);
	unsigned long old, mask;

	mask = 1UL << (nr & (BITS_PER_LONG - 1));
	old = __atomic64_or_barrier(mask, addr);
	return (old & mask) != 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Martin Schwidefsky 41 61.19% 4 44.44%
Heiko Carstens 14 20.90% 2 22.22%
Linus Torvalds (pre-git) 10 14.93% 1 11.11%
Akinobu Mita 1 1.49% 1 11.11%
Linus Torvalds 1 1.49% 1 11.11%
Total 67 100.00% 9 100.00%


static inline int

test_and_clear_bit(unsigned long nr, volatile unsigned long *ptr)
{
	unsigned long *addr = __bitops_word(nr, ptr);
	unsigned long old, mask;

	mask = ~(1UL << (nr & (BITS_PER_LONG - 1)));
	old = __atomic64_and_barrier(mask, addr);
	return (old & ~mask) != 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Martin Schwidefsky 40 56.34% 4 44.44%
Heiko Carstens 19 26.76% 2 22.22%
Linus Torvalds (pre-git) 10 14.08% 1 11.11%
Akinobu Mita 1 1.41% 1 11.11%
Linus Torvalds 1 1.41% 1 11.11%
Total 71 100.00% 9 100.00%


static inline int

test_and_change_bit(unsigned long nr, volatile unsigned long *ptr)
{
	unsigned long *addr = __bitops_word(nr, ptr);
	unsigned long old, mask;

	mask = 1UL << (nr & (BITS_PER_LONG - 1));
	old = __atomic64_xor_barrier(mask, addr);
	return (old & mask) != 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Martin Schwidefsky 40 59.70% 4 44.44%
Heiko Carstens 14 20.90% 2 22.22%
Linus Torvalds (pre-git) 11 16.42% 1 11.11%
Akinobu Mita 1 1.49% 1 11.11%
Linus Torvalds 1 1.49% 1 11.11%
Total 67 100.00% 9 100.00%



static inline void __set_bit(unsigned long nr, volatile unsigned long *ptr)
{
	unsigned char *addr = __bitops_byte(nr, ptr);

	*addr |= 1 << (nr & 7);
}

Contributors
Person Tokens Prop Commits CommitProp
Heiko Carstens 15 37.50% 1 16.67%
Martin Schwidefsky 14 35.00% 3 50.00%
Linus Torvalds (pre-git) 10 25.00% 1 16.67%
Linus Torvalds 1 2.50% 1 16.67%
Total 40 100.00% 6 100.00%


static inline void 

__clear_bit(unsigned long nr, volatile unsigned long *ptr)
{
	unsigned char *addr = __bitops_byte(nr, ptr);

	*addr &= ~(1 << (nr & 7));
}

Contributors
Person Tokens Prop Commits CommitProp
Heiko Carstens 18 41.86% 1 16.67%
Martin Schwidefsky 16 37.21% 3 50.00%
Linus Torvalds (pre-git) 8 18.60% 1 16.67%
Linus Torvalds 1 2.33% 1 16.67%
Total 43 100.00% 6 100.00%



static inline void __change_bit(unsigned long nr, volatile unsigned long *ptr)
{
	unsigned char *addr = __bitops_byte(nr, ptr);

	*addr ^= 1 << (nr & 7);
}

Contributors
Person Tokens Prop Commits CommitProp
Heiko Carstens 27 67.50% 1 33.33%
Martin Schwidefsky 9 22.50% 1 33.33%
Linus Torvalds (pre-git) 4 10.00% 1 33.33%
Total 40 100.00% 3 100.00%


static inline int

__test_and_set_bit(unsigned long nr, volatile unsigned long *ptr)
{
	unsigned char *addr = __bitops_byte(nr, ptr);
	unsigned char ch;

	ch = *addr;
	*addr |= 1 << (nr & 7);
	return (ch >> (nr & 7)) & 1;
}

Contributors
Person Tokens Prop Commits CommitProp
Heiko Carstens 36 58.06% 1 16.67%
Martin Schwidefsky 17 27.42% 3 50.00%
Linus Torvalds (pre-git) 8 12.90% 1 16.67%
Linus Torvalds 1 1.61% 1 16.67%
Total 62 100.00% 6 100.00%


static inline int

__test_and_clear_bit(unsigned long nr, volatile unsigned long *ptr)
{
	unsigned char *addr = __bitops_byte(nr, ptr);
	unsigned char ch;

	ch = *addr;
	*addr &= ~(1 << (nr & 7));
	return (ch >> (nr & 7)) & 1;
}

Contributors
Person Tokens Prop Commits CommitProp
Martin Schwidefsky 29 44.62% 3 50.00%
Heiko Carstens 22 33.85% 1 16.67%
Linus Torvalds (pre-git) 13 20.00% 1 16.67%
Linus Torvalds 1 1.54% 1 16.67%
Total 65 100.00% 6 100.00%


static inline int

__test_and_change_bit(unsigned long nr, volatile unsigned long *ptr)
{
	unsigned char *addr = __bitops_byte(nr, ptr);
	unsigned char ch;

	ch = *addr;
	*addr ^= 1 << (nr & 7);
	return (ch >> (nr & 7)) & 1;
}

Contributors
Person Tokens Prop Commits CommitProp
Martin Schwidefsky 28 45.16% 3 50.00%
Heiko Carstens 20 32.26% 1 16.67%
Linus Torvalds (pre-git) 13 20.97% 1 16.67%
Linus Torvalds 1 1.61% 1 16.67%
Total 62 100.00% 6 100.00%



static inline int test_bit(unsigned long nr, const volatile unsigned long *ptr)
{
	const volatile unsigned char *addr;

	addr = ((const volatile unsigned char *)ptr);
	addr += (nr ^ (BITS_PER_LONG - 8)) >> 3;
	return (*addr >> (nr & 7)) & 1;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds (pre-git) 28 42.42% 1 12.50%
Heiko Carstens 24 36.36% 1 12.50%
Martin Schwidefsky 12 18.18% 4 50.00%
Akinobu Mita 1 1.52% 1 12.50%
Linus Torvalds 1 1.52% 1 12.50%
Total 66 100.00% 8 100.00%



static inline int test_and_set_bit_lock(unsigned long nr,
					volatile unsigned long *ptr)
{
	if (test_bit(nr, ptr))
		return 1;
	return test_and_set_bit(nr, ptr);
}

Contributors
Person Tokens Prop Commits CommitProp
Martin Schwidefsky 37 100.00% 1 100.00%
Total 37 100.00% 1 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
Martin Schwidefsky 27 100.00% 1 100.00%
Total 27 100.00% 1 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
Martin Schwidefsky 27 100.00% 1 100.00%
Total 27 100.00% 1 100.00%

/*
 * 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);
}

Contributors
Person Tokens Prop Commits CommitProp
Heiko Carstens 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
Heiko Carstens 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
Heiko Carstens 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
Heiko Carstens 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
Heiko Carstens 32 100.00% 1 100.00%
Total 32 100.00% 1 100.00%

#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 {
		register unsigned long bit asm("4") = word;
		register unsigned long out asm("5");

		asm volatile(
                        "       flogr   %[bit],%[bit]\n"
                        : [bit] "+d" (bit), [out] "=d" (out) : : "cc");
		return bit;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Heiko Carstens 181 100.00% 1 100.00%
Total 181 100.00% 1 100.00%

/**
 * __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);
}

Contributors
Person Tokens Prop Commits CommitProp
Heiko Carstens 27 100.00% 1 100.00%
Total 27 100.00% 1 100.00%

/**
 * 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;
}

Contributors
Person Tokens Prop Commits CommitProp
Heiko Carstens 53 100.00% 1 100.00%
Total 53 100.00% 1 100.00%

/**
 * __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);
}

Contributors
Person Tokens Prop Commits CommitProp
Heiko Carstens 24 100.00% 1 100.00%
Total 24 100.00% 1 100.00%

/**
 * 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;
}

Contributors
Person Tokens Prop Commits CommitProp
Heiko Carstens 41 100.00% 1 100.00%
Total 41 100.00% 1 100.00%

/**
 * 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(int word)
{
	return fls64((unsigned int)word);
}

Contributors
Person Tokens Prop Commits CommitProp
Heiko Carstens 20 100.00% 1 100.00%
Total 20 100.00% 1 100.00%

#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 */
Overall Contributors
Person Tokens Prop Commits CommitProp
Heiko Carstens 980 58.89% 10 35.71%
Martin Schwidefsky 488 29.33% 9 32.14%
Linus Torvalds (pre-git) 153 9.19% 1 3.57%
Akinobu Mita 15 0.90% 3 10.71%
Linus Torvalds 12 0.72% 1 3.57%
Jiri Slaby 8 0.48% 1 3.57%
Andrew Morton 7 0.42% 2 7.14%
Greg Kroah-Hartman 1 0.06% 1 3.57%
Total 1664 100.00% 28 100.00%
Directory: arch/s390/include/asm

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.
Person	Tokens	Prop	Commits	CommitProp
Martin Schwidefsky	32	56.14%	3	42.86%
Heiko Carstens	16	28.07%	1	14.29%
Linus Torvalds (pre-git)	7	12.28%	1	14.29%
Akinobu Mita	1	1.75%	1	14.29%
Linus Torvalds	1	1.75%	1	14.29%
Total	57	100.00%	7	100.00%
cregit-Linux how code gets into the kernel

Release 4.14 arch/s390/include/asm/bitops.h

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
