Merge tag 'bitmap-for-6.7' of https://github.com/norov/linux

R:	Rasmus Villemoes <linux@rasmusvillemoes.dk>

S:	Maintained

F:	include/linux/bitfield.h

F:	include/linux/bitmap-str.h

F:	include/linux/bitmap.h

F:	include/linux/bits.h

F:	include/linux/cpumask.h

F:	include/linux/find.h

F:	include/linux/nodemask.h

F:	include/vdso/bits.h

F:	lib/bitmap-str.c

F:	lib/bitmap.c

F:	lib/cpumask.c

F:	lib/cpumask_kunit.c

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

#ifndef __LINUX_BITMAP_STR_H

#define __LINUX_BITMAP_STR_H

int bitmap_parse_user(const char __user *ubuf, unsigned int ulen, unsigned long *dst, int nbits);

int bitmap_print_to_pagebuf(bool list, char *buf, const unsigned long *maskp, int nmaskbits);

extern int bitmap_print_bitmask_to_buf(char *buf, const unsigned long *maskp,

					int nmaskbits, loff_t off, size_t count);

extern int bitmap_print_list_to_buf(char *buf, const unsigned long *maskp,

					int nmaskbits, loff_t off, size_t count);

int bitmap_parse(const char *buf, unsigned int buflen, unsigned long *dst, int nbits);

int bitmap_parselist(const char *buf, unsigned long *maskp, int nmaskbits);

int bitmap_parselist_user(const char __user *ubuf, unsigned int ulen,

					unsigned long *dst, int nbits);

#endif /* __LINUX_BITMAP_STR_H */

#include <linux/align.h>

#include <linux/bitops.h>

#include <linux/errno.h>

#include <linux/find.h>

#include <linux/limits.h>

#include <linux/string.h>

#include <linux/types.h>

#include <linux/bitmap-str.h>

struct device;

					      align_mask, 0);

}

int bitmap_parse(const char *buf, unsigned int buflen,

			unsigned long *dst, int nbits);

int bitmap_parse_user(const char __user *ubuf, unsigned int ulen,

			unsigned long *dst, int nbits);

int bitmap_parselist(const char *buf, unsigned long *maskp,

			int nmaskbits);

int bitmap_parselist_user(const char __user *ubuf, unsigned int ulen,

			unsigned long *dst, int nbits);

void bitmap_remap(unsigned long *dst, const unsigned long *src,

		const unsigned long *old, const unsigned long *new, unsigned int nbits);

int bitmap_bitremap(int oldbit,

		const unsigned long *relmap, unsigned int bits);

void bitmap_fold(unsigned long *dst, const unsigned long *orig,

		unsigned int sz, unsigned int nbits);

int bitmap_find_free_region(unsigned long *bitmap, unsigned int bits, int order);

void bitmap_release_region(unsigned long *bitmap, unsigned int pos, int order);

int bitmap_allocate_region(unsigned long *bitmap, unsigned int pos, int order);

#ifdef __BIG_ENDIAN

void bitmap_copy_le(unsigned long *dst, const unsigned long *src, unsigned int nbits);

#else

#define bitmap_copy_le bitmap_copy

#endif

int bitmap_print_to_pagebuf(bool list, char *buf,

				   const unsigned long *maskp, int nmaskbits);

extern int bitmap_print_bitmask_to_buf(char *buf, const unsigned long *maskp,

				      int nmaskbits, loff_t off, size_t count);

extern int bitmap_print_list_to_buf(char *buf, const unsigned long *maskp,

				      int nmaskbits, loff_t off, size_t count);

#define BITMAP_FIRST_WORD_MASK(start) (~0UL << ((start) & (BITS_PER_LONG - 1)))

#define BITMAP_LAST_WORD_MASK(nbits) (~0UL >> (-(nbits) & (BITS_PER_LONG - 1)))

	*re = find_next_zero_bit(bitmap, end, *rs + 1);

}

/**

 * bitmap_release_region - release allocated bitmap region

 *	@bitmap: array of unsigned longs corresponding to the bitmap

 *	@pos: beginning of bit region to release

 *	@order: region size (log base 2 of number of bits) to release

 *

 * This is the complement to __bitmap_find_free_region() and releases

 * the found region (by clearing it in the bitmap).

 */

static inline void bitmap_release_region(unsigned long *bitmap, unsigned int pos, int order)

{

	bitmap_clear(bitmap, pos, BIT(order));

}

/**

 * bitmap_allocate_region - allocate bitmap region

 *	@bitmap: array of unsigned longs corresponding to the bitmap

 *	@pos: beginning of bit region to allocate

 *	@order: region size (log base 2 of number of bits) to allocate

 *

 * Allocate (set bits in) a specified region of a bitmap.

 *

 * Returns: 0 on success, or %-EBUSY if specified region wasn't

 * free (not all bits were zero).

 */

static inline int bitmap_allocate_region(unsigned long *bitmap, unsigned int pos, int order)

{

	unsigned int len = BIT(order);

	if (find_next_bit(bitmap, pos + len, pos) < pos + len)

		return -EBUSY;

	bitmap_set(bitmap, pos, len);

	return 0;

}

/**

 * bitmap_find_free_region - find a contiguous aligned mem region

 *	@bitmap: array of unsigned longs corresponding to the bitmap

 *	@bits: number of bits in the bitmap

 *	@order: region size (log base 2 of number of bits) to find

 *

 * Find a region of free (zero) bits in a @bitmap of @bits bits and

 * allocate them (set them to one).  Only consider regions of length

 * a power (@order) of two, aligned to that power of two, which

 * makes the search algorithm much faster.

 *

 * Returns: the bit offset in bitmap of the allocated region,

 * or -errno on failure.

 */

static inline int bitmap_find_free_region(unsigned long *bitmap, unsigned int bits, int order)

{

	unsigned int pos, end;		/* scans bitmap by regions of size order */

	for (pos = 0; (end = pos + BIT(order)) <= bits; pos = end) {

		if (!bitmap_allocate_region(bitmap, pos, order))

			return pos;

	}

	return -ENOMEM;

}

/**

 * BITMAP_FROM_U64() - Represent u64 value in the format suitable for bitmap.

 * @n: u64 value

#ifndef _LINUX_BUILDID_H

#define _LINUX_BUILDID_H

#include <linux/mm_types.h>

#include <linux/types.h>

#define BUILD_ID_SIZE_MAX 20

struct vm_area_struct;

int build_id_parse(struct vm_area_struct *vma, unsigned char *build_id,

		   __u32 *size);

int build_id_parse_buf(const void *buf, unsigned char *build_id, u32 buf_size);

/*

 * Cpumasks provide a bitmap suitable for representing the

 * set of CPU's in a system, one bit position per CPU number.  In general,

 * set of CPUs in a system, one bit position per CPU number.  In general,

 * only nr_cpu_ids (<= NR_CPUS) bits are valid.

 */

#include <linux/kernel.h>

 *

 *  If !CONFIG_HOTPLUG_CPU, present == possible, and active == online.

 *

 *  The cpu_possible_mask is fixed at boot time, as the set of CPU id's

 *  The cpu_possible_mask is fixed at boot time, as the set of CPU IDs

 *  that it is possible might ever be plugged in at anytime during the

 *  life of that system boot.  The cpu_present_mask is dynamic(*),

 *  representing which CPUs are currently plugged in.  And

 *      hotplug, it's a copy of cpu_possible_mask, hence fixed at boot.

 *

 * Subtleties:

 * 1) UP arch's (NR_CPUS == 1, CONFIG_SMP not defined) hardcode

 * 1) UP ARCHes (NR_CPUS == 1, CONFIG_SMP not defined) hardcode

 *    assumption that their single CPU is online.  The UP

 *    cpu_{online,possible,present}_masks are placebos.  Changing them

 *    will have no useful affect on the following num_*_cpus()

 * cpumask_first - get the first cpu in a cpumask

 * @srcp: the cpumask pointer

 *

 * Returns >= nr_cpu_ids if no cpus set.

 * Return: >= nr_cpu_ids if no cpus set.

 */

static inline unsigned int cpumask_first(const struct cpumask *srcp)

{

 * cpumask_first_zero - get the first unset cpu in a cpumask

 * @srcp: the cpumask pointer

 *

 * Returns >= nr_cpu_ids if all cpus are set.

 * Return: >= nr_cpu_ids if all cpus are set.

 */

static inline unsigned int cpumask_first_zero(const struct cpumask *srcp)

{

 * @srcp1: the first input

 * @srcp2: the second input

 *

 * Returns >= nr_cpu_ids if no cpus set in both.  See also cpumask_next_and().

 * Return: >= nr_cpu_ids if no cpus set in both.  See also cpumask_next_and().

 */

static inline

unsigned int cpumask_first_and(const struct cpumask *srcp1, const struct cpumask *srcp2)

 * cpumask_last - get the last CPU in a cpumask

 * @srcp:	- the cpumask pointer

 *

 * Returns	>= nr_cpumask_bits if no CPUs set.

 * Return:	>= nr_cpumask_bits if no CPUs set.

 */

static inline unsigned int cpumask_last(const struct cpumask *srcp)

{

/**

 * cpumask_next - get the next cpu in a cpumask

 * @n: the cpu prior to the place to search (ie. return will be > @n)

 * @n: the cpu prior to the place to search (i.e. return will be > @n)

 * @srcp: the cpumask pointer

 *

 * Returns >= nr_cpu_ids if no further cpus set.

 * Return: >= nr_cpu_ids if no further cpus set.

 */

static inline

unsigned int cpumask_next(int n, const struct cpumask *srcp)

/**

 * cpumask_next_zero - get the next unset cpu in a cpumask

 * @n: the cpu prior to the place to search (ie. return will be > @n)

 * @n: the cpu prior to the place to search (i.e. return will be > @n)

 * @srcp: the cpumask pointer

 *

 * Returns >= nr_cpu_ids if no further cpus unset.

 * Return: >= nr_cpu_ids if no further cpus unset.

 */

static inline unsigned int cpumask_next_zero(int n, const struct cpumask *srcp)

{

/**

 * cpumask_next_and - get the next cpu in *src1p & *src2p

 * @n: the cpu prior to the place to search (ie. return will be > @n)

 * @n: the cpu prior to the place to search (i.e. return will be > @n)

 * @src1p: the first cpumask pointer

 * @src2p: the second cpumask pointer

 *

 * Returns >= nr_cpu_ids if no further cpus set in both.

 * Return: >= nr_cpu_ids if no further cpus set in both.

 */

static inline

unsigned int cpumask_next_and(int n, const struct cpumask *src1p,

 * @cpu: the cpu to ignore.

 *

 * Often used to find any cpu but smp_processor_id() in a mask.

 * Returns >= nr_cpu_ids if no cpus set.

 * Return: >= nr_cpu_ids if no cpus set.

 */

static inline

unsigned int cpumask_any_but(const struct cpumask *mask, unsigned int cpu)

}

/**

 * cpumask_nth - get the first cpu in a cpumask

 * cpumask_nth - get the Nth cpu in a cpumask

 * @srcp: the cpumask pointer

 * @cpu: the N'th cpu to find, starting from 0

 * @cpu: the Nth cpu to find, starting from 0

 *

 * Returns >= nr_cpu_ids if such cpu doesn't exist.

 * Return: >= nr_cpu_ids if such cpu doesn't exist.

 */

static inline unsigned int cpumask_nth(unsigned int cpu, const struct cpumask *srcp)

{

}

/**

 * cpumask_nth_and - get the first cpu in 2 cpumasks

 * cpumask_nth_and - get the Nth cpu in 2 cpumasks

 * @srcp1: the cpumask pointer

 * @srcp2: the cpumask pointer

 * @cpu: the N'th cpu to find, starting from 0

 * @cpu: the Nth cpu to find, starting from 0

 *

 * Returns >= nr_cpu_ids if such cpu doesn't exist.

 * Return: >= nr_cpu_ids if such cpu doesn't exist.

 */

static inline

unsigned int cpumask_nth_and(unsigned int cpu, const struct cpumask *srcp1,

}

/**

 * cpumask_nth_andnot - get the first cpu set in 1st cpumask, and clear in 2nd.

 * cpumask_nth_andnot - get the Nth cpu set in 1st cpumask, and clear in 2nd.

 * @srcp1: the cpumask pointer

 * @srcp2: the cpumask pointer

 * @cpu: the N'th cpu to find, starting from 0

 * @cpu: the Nth cpu to find, starting from 0

 *

 * Returns >= nr_cpu_ids if such cpu doesn't exist.

 * Return: >= nr_cpu_ids if such cpu doesn't exist.

 */

static inline

unsigned int cpumask_nth_andnot(unsigned int cpu, const struct cpumask *srcp1,

 * @srcp1: the cpumask pointer

 * @srcp2: the cpumask pointer

 * @srcp3: the cpumask pointer

 * @cpu: the N'th cpu to find, starting from 0

 * @cpu: the Nth cpu to find, starting from 0

 *

 * Returns >= nr_cpu_ids if such cpu doesn't exist.

 * Return: >= nr_cpu_ids if such cpu doesn't exist.

 */

static __always_inline

unsigned int cpumask_nth_and_andnot(unsigned int cpu, const struct cpumask *srcp1,

 * @cpu: cpu number (< nr_cpu_ids)

 * @cpumask: the cpumask pointer

 *

 * Returns true if @cpu is set in @cpumask, else returns false

 * Return: true if @cpu is set in @cpumask, else returns false

 */

static __always_inline bool cpumask_test_cpu(int cpu, const struct cpumask *cpumask)

{

 * @cpu: cpu number (< nr_cpu_ids)

 * @cpumask: the cpumask pointer

 *

 * Returns true if @cpu is set in old bitmap of @cpumask, else returns false

 *

 * test_and_set_bit wrapper for cpumasks.

 *

 * Return: true if @cpu is set in old bitmap of @cpumask, else returns false

 */

static __always_inline bool cpumask_test_and_set_cpu(int cpu, struct cpumask *cpumask)

{

 * @cpu: cpu number (< nr_cpu_ids)

 * @cpumask: the cpumask pointer

 *

 * Returns true if @cpu is set in old bitmap of @cpumask, else returns false

 *

 * test_and_clear_bit wrapper for cpumasks.

 *

 * Return: true if @cpu is set in old bitmap of @cpumask, else returns false

 */

static __always_inline bool cpumask_test_and_clear_cpu(int cpu, struct cpumask *cpumask)

{

 * @src1p: the first input

 * @src2p: the second input

 *

 * If *@dstp is empty, returns false, else returns true

 * Return: false if *@dstp is empty, else returns true

 */

static inline bool cpumask_and(struct cpumask *dstp,

			       const struct cpumask *src1p,

 * @src1p: the first input

 * @src2p: the second input

 *

 * If *@dstp is empty, returns false, else returns true

 * Return: false if *@dstp is empty, else returns true

 */

static inline bool cpumask_andnot(struct cpumask *dstp,

				  const struct cpumask *src1p,

 * cpumask_equal - *src1p == *src2p

 * @src1p: the first input

 * @src2p: the second input

 *

 * Return: true if the cpumasks are equal, false if not

 */

static inline bool cpumask_equal(const struct cpumask *src1p,

				const struct cpumask *src2p)

 * @src1p: the first input

 * @src2p: the second input

 * @src3p: the third input

 *

 * Return: true if first cpumask ORed with second cpumask == third cpumask,

 *	   otherwise false

 */

static inline bool cpumask_or_equal(const struct cpumask *src1p,

				    const struct cpumask *src2p,

 * cpumask_intersects - (*src1p & *src2p) != 0

 * @src1p: the first input

 * @src2p: the second input

 *

 * Return: true if first cpumask ANDed with second cpumask is non-empty,

 *	   otherwise false

 */

static inline bool cpumask_intersects(const struct cpumask *src1p,

				     const struct cpumask *src2p)

 * @src1p: the first input

 * @src2p: the second input

 *

 * Returns true if *@src1p is a subset of *@src2p, else returns false

 * Return: true if *@src1p is a subset of *@src2p, else returns false

 */

static inline bool cpumask_subset(const struct cpumask *src1p,

				 const struct cpumask *src2p)

/**

 * cpumask_empty - *srcp == 0

 * @srcp: the cpumask to that all cpus < nr_cpu_ids are clear.

 *

 * Return: true if srcp is empty (has no bits set), else false

 */

static inline bool cpumask_empty(const struct cpumask *srcp)

{

/**

 * cpumask_full - *srcp == 0xFFFFFFFF...

 * @srcp: the cpumask to that all cpus < nr_cpu_ids are set.

 *

 * Return: true if srcp is full (has all bits set), else false

 */

static inline bool cpumask_full(const struct cpumask *srcp)

{

/**

 * cpumask_weight - Count of bits in *srcp

 * @srcp: the cpumask to count bits (< nr_cpu_ids) in.

 *

 * Return: count of bits set in *srcp

 */

static inline unsigned int cpumask_weight(const struct cpumask *srcp)

{

 * cpumask_weight_and - Count of bits in (*srcp1 & *srcp2)

 * @srcp1: the cpumask to count bits (< nr_cpu_ids) in.

 * @srcp2: the cpumask to count bits (< nr_cpu_ids) in.

 *

 * Return: count of bits set in both *srcp1 and *srcp2

 */

static inline unsigned int cpumask_weight_and(const struct cpumask *srcp1,

						const struct cpumask *srcp2)

 * cpumask_any - pick a "random" cpu from *srcp

 * @srcp: the input cpumask

 *

 * Returns >= nr_cpu_ids if no cpus set.

 * Return: >= nr_cpu_ids if no cpus set.

 */

#define cpumask_any(srcp) cpumask_first(srcp)

 * @mask1: the first input cpumask

 * @mask2: the second input cpumask

 *

 * Returns >= nr_cpu_ids if no cpus set.

 * Return: >= nr_cpu_ids if no cpus set.

 */

#define cpumask_any_and(mask1, mask2) cpumask_first_and((mask1), (mask2))

 * @len: the length of the buffer

 * @dstp: the cpumask to set.

 *

 * Returns -errno, or 0 for success.

 * Return: -errno, or 0 for success.

 */

static inline int cpumask_parse_user(const char __user *buf, int len,

				     struct cpumask *dstp)

 * @len: the length of the buffer

 * @dstp: the cpumask to set.

 *

 * Returns -errno, or 0 for success.

 * Return: -errno, or 0 for success.

 */

static inline int cpumask_parselist_user(const char __user *buf, int len,

				     struct cpumask *dstp)

 * @buf: the buffer to extract from

 * @dstp: the cpumask to set.

 *

 * Returns -errno, or 0 for success.

 * Return: -errno, or 0 for success.

 */

static inline int cpumask_parse(const char *buf, struct cpumask *dstp)

{

 * @buf: the buffer to extract from

 * @dstp: the cpumask to set.

 *

 * Returns -errno, or 0 for success.

 * Return: -errno, or 0 for success.

 */

static inline int cpulist_parse(const char *buf, struct cpumask *dstp)

{

}

/**

 * cpumask_size - size to allocate for a 'struct cpumask' in bytes

 * cpumask_size - calculate size to allocate for a 'struct cpumask' in bytes

 *

 * Return: size to allocate for a &struct cpumask in bytes

 */

static inline unsigned int cpumask_size(void)

{

 * little more difficult, we typedef cpumask_var_t to an array or a

 * pointer: doing &mask on an array is a noop, so it still works.

 *

 * ie.

 * i.e.

 *	cpumask_var_t tmpmask;

 *	if (!alloc_cpumask_var(&tmpmask, GFP_KERNEL))

 *		return -ENOMEM;

 * a nop returning a constant 1 (in <linux/cpumask.h>).

 *

 * See alloc_cpumask_var_node.

 *

 * Return: %true if allocation succeeded, %false if not

 */

static inline

bool alloc_cpumask_var(cpumask_var_t *mask, gfp_t flags)

}

/**

 * to_cpumask - convert an NR_CPUS bitmap to a struct cpumask *

 * to_cpumask - convert a NR_CPUS bitmap to a struct cpumask *

 * @bitmap: the bitmap

 *

 * There are a few places where cpumask_var_t isn't appropriate and

 * interface gives only a momentary snapshot and is not protected against

 * concurrent CPU hotplug operations unless invoked from a cpuhp_lock held

 * region.

 *

 * Return: momentary snapshot of the number of online CPUs

 */

static __always_inline unsigned int num_online_cpus(void)

{

 * @mask: the cpumask to copy

 * @buf: the buffer to copy into

 *

 * Returns the length of the (null-terminated) @buf string, zero if

 * Return: the length of the (null-terminated) @buf string, zero if

 * nothing is copied.

 */

static inline ssize_t

 * cpumask; Typically used by bin_attribute to export cpumask bitmask

 * ABI.

 *

 * Returns the length of how many bytes have been copied, excluding

 * Return: the length of how many bytes have been copied, excluding

 * terminating '\0'.

 */

static inline ssize_t

 *

 * Everything is same with the above cpumap_print_bitmask_to_buf()

 * except the print format.

 *

 * Return: the length of how many bytes have been copied, excluding

 * terminating '\0'.

 */

static inline ssize_t

cpumap_print_list_to_buf(char *buf, const struct cpumask *mask,