2005-04-16 16:20:36 -06:00
|
|
|
#ifndef __LINUX_CPUMASK_H
|
|
|
|
#define __LINUX_CPUMASK_H
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Cpumasks provide a bitmap suitable for representing the
|
|
|
|
* set of CPU's in a system, one bit position per CPU number.
|
|
|
|
*
|
2008-11-04 19:39:10 -07:00
|
|
|
* The new cpumask_ ops take a "struct cpumask *"; the old ones
|
|
|
|
* use cpumask_t.
|
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* See detailed comments in the file linux/bitmap.h describing the
|
|
|
|
* data type on which these cpumasks are based.
|
|
|
|
*
|
2006-10-11 02:21:55 -06:00
|
|
|
* For details of cpumask_scnprintf() and cpumask_parse_user(),
|
|
|
|
* see bitmap_scnprintf() and bitmap_parse_user() in lib/bitmap.c.
|
2005-04-16 16:20:36 -06:00
|
|
|
* For details of cpulist_scnprintf() and cpulist_parse(), see
|
|
|
|
* bitmap_scnlistprintf() and bitmap_parselist(), also in bitmap.c.
|
2005-10-30 16:02:33 -07:00
|
|
|
* For details of cpu_remap(), see bitmap_bitremap in lib/bitmap.c
|
|
|
|
* For details of cpus_remap(), see bitmap_remap in lib/bitmap.c.
|
mempolicy: add bitmap_onto() and bitmap_fold() operations
The following adds two more bitmap operators, bitmap_onto() and bitmap_fold(),
with the usual cpumask and nodemask wrappers.
The bitmap_onto() operator computes one bitmap relative to another. If the
n-th bit in the origin mask is set, then the m-th bit of the destination mask
will be set, where m is the position of the n-th set bit in the relative mask.
The bitmap_fold() operator folds a bitmap into a second that has bit m set iff
the input bitmap has some bit n set, where m == n mod sz, for the specified sz
value.
There are two substantive changes between this patch and its
predecessor bitmap_relative:
1) Renamed bitmap_relative() to be bitmap_onto().
2) Added bitmap_fold().
The essential motivation for bitmap_onto() is to provide a mechanism for
converting a cpuset-relative CPU or Node mask to an absolute mask. Cpuset
relative masks are written as if the current task were in a cpuset whose CPUs
or Nodes were just the consecutive ones numbered 0..N-1, for some N. The
bitmap_onto() operator is provided in anticipation of adding support for the
first such cpuset relative mask, by the mbind() and set_mempolicy() system
calls, using a planned flag of MPOL_F_RELATIVE_NODES. These bitmap operators
(and their nodemask wrappers, in particular) will be used in code that
converts the user specified cpuset relative memory policy to a specific system
node numbered policy, given the current mems_allowed of the tasks cpuset.
Such cpuset relative mempolicies will address two deficiencies
of the existing interface between cpusets and mempolicies:
1) A task cannot at present reliably establish a cpuset
relative mempolicy because there is an essential race
condition, in that the tasks cpuset may be changed in
between the time the task can query its cpuset placement,
and the time the task can issue the applicable mbind or
set_memplicy system call.
2) A task cannot at present establish what cpuset relative
mempolicy it would like to have, if it is in a smaller
cpuset than it might have mempolicy preferences for,
because the existing interface only allows specifying
mempolicies for nodes currently allowed by the cpuset.
Cpuset relative mempolicies are useful for tasks that don't distinguish
particularly between one CPU or Node and another, but only between how many of
each are allowed, and the proper placement of threads and memory pages on the
various CPUs and Nodes available.
The motivation for the added bitmap_fold() can be seen in the following
example.
Let's say an application has specified some mempolicies that presume 16 memory
nodes, including say a mempolicy that specified MPOL_F_RELATIVE_NODES (cpuset
relative) nodes 12-15. Then lets say that application is crammed into a
cpuset that only has 8 memory nodes, 0-7. If one just uses bitmap_onto(),
this mempolicy, mapped to that cpuset, would ignore the requested relative
nodes above 7, leaving it empty of nodes. That's not good; better to fold the
higher nodes down, so that some nodes are included in the resulting mapped
mempolicy. In this case, the mempolicy nodes 12-15 are taken modulo 8 (the
weight of the mems_allowed of the confining cpuset), resulting in a mempolicy
specifying nodes 4-7.
Signed-off-by: Paul Jackson <pj@sgi.com>
Signed-off-by: David Rientjes <rientjes@google.com>
Cc: Christoph Lameter <clameter@sgi.com>
Cc: Andi Kleen <ak@suse.de>
Cc: Mel Gorman <mel@csn.ul.ie>
Cc: Lee Schermerhorn <lee.schermerhorn@hp.com>
Cc: <kosaki.motohiro@jp.fujitsu.com>
Cc: <ray-lk@madrabbit.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-04-28 03:12:29 -06:00
|
|
|
* For details of cpus_onto(), see bitmap_onto in lib/bitmap.c.
|
|
|
|
* For details of cpus_fold(), see bitmap_fold in lib/bitmap.c.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2008-05-12 13:21:13 -06:00
|
|
|
* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
|
|
|
|
* Note: The alternate operations with the suffix "_nr" are used
|
|
|
|
* to limit the range of the loop to nr_cpu_ids instead of
|
|
|
|
* NR_CPUS when NR_CPUS > 64 for performance reasons.
|
|
|
|
* If NR_CPUS is <= 64 then most assembler bitmask
|
|
|
|
* operators execute faster with a constant range, so
|
|
|
|
* the operator will continue to use NR_CPUS.
|
|
|
|
*
|
|
|
|
* Another consideration is that nr_cpu_ids is initialized
|
|
|
|
* to NR_CPUS and isn't lowered until the possible cpus are
|
|
|
|
* discovered (including any disabled cpus). So early uses
|
|
|
|
* will span the entire range of NR_CPUS.
|
|
|
|
* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
|
|
|
|
*
|
2008-11-04 19:39:10 -07:00
|
|
|
* The obsolescent cpumask operations are:
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* void cpu_set(cpu, mask) turn on bit 'cpu' in mask
|
|
|
|
* void cpu_clear(cpu, mask) turn off bit 'cpu' in mask
|
|
|
|
* void cpus_setall(mask) set all bits
|
|
|
|
* void cpus_clear(mask) clear all bits
|
|
|
|
* int cpu_isset(cpu, mask) true iff bit 'cpu' set in mask
|
|
|
|
* int cpu_test_and_set(cpu, mask) test and set bit 'cpu' in mask
|
|
|
|
*
|
|
|
|
* void cpus_and(dst, src1, src2) dst = src1 & src2 [intersection]
|
|
|
|
* void cpus_or(dst, src1, src2) dst = src1 | src2 [union]
|
|
|
|
* void cpus_xor(dst, src1, src2) dst = src1 ^ src2
|
|
|
|
* void cpus_andnot(dst, src1, src2) dst = src1 & ~src2
|
|
|
|
* void cpus_complement(dst, src) dst = ~src
|
|
|
|
*
|
|
|
|
* int cpus_equal(mask1, mask2) Does mask1 == mask2?
|
|
|
|
* int cpus_intersects(mask1, mask2) Do mask1 and mask2 intersect?
|
|
|
|
* int cpus_subset(mask1, mask2) Is mask1 a subset of mask2?
|
|
|
|
* int cpus_empty(mask) Is mask empty (no bits sets)?
|
|
|
|
* int cpus_full(mask) Is mask full (all bits sets)?
|
|
|
|
* int cpus_weight(mask) Hamming weigh - number of set bits
|
2008-05-12 13:21:13 -06:00
|
|
|
* int cpus_weight_nr(mask) Same using nr_cpu_ids instead of NR_CPUS
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* void cpus_shift_right(dst, src, n) Shift right
|
|
|
|
* void cpus_shift_left(dst, src, n) Shift left
|
|
|
|
*
|
|
|
|
* int first_cpu(mask) Number lowest set bit, or NR_CPUS
|
|
|
|
* int next_cpu(cpu, mask) Next cpu past 'cpu', or NR_CPUS
|
2008-05-12 13:21:13 -06:00
|
|
|
* int next_cpu_nr(cpu, mask) Next cpu past 'cpu', or nr_cpu_ids
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* cpumask_t cpumask_of_cpu(cpu) Return cpumask with bit 'cpu' set
|
2008-07-24 19:21:29 -06:00
|
|
|
* (can be used as an lvalue)
|
2005-04-16 16:20:36 -06:00
|
|
|
* CPU_MASK_ALL Initializer - all bits set
|
|
|
|
* CPU_MASK_NONE Initializer - no bits set
|
|
|
|
* unsigned long *cpus_addr(mask) Array of unsigned long's in mask
|
|
|
|
*
|
2008-07-18 19:11:33 -06:00
|
|
|
* CPUMASK_ALLOC kmalloc's a structure that is a composite of many cpumask_t
|
|
|
|
* variables, and CPUMASK_PTR provides pointers to each field.
|
|
|
|
*
|
|
|
|
* The structure should be defined something like this:
|
|
|
|
* struct my_cpumasks {
|
|
|
|
* cpumask_t mask1;
|
|
|
|
* cpumask_t mask2;
|
|
|
|
* };
|
|
|
|
*
|
|
|
|
* Usage is then:
|
|
|
|
* CPUMASK_ALLOC(my_cpumasks);
|
|
|
|
* CPUMASK_PTR(mask1, my_cpumasks);
|
|
|
|
* CPUMASK_PTR(mask2, my_cpumasks);
|
|
|
|
*
|
|
|
|
* --- DO NOT reference cpumask_t pointers until this check ---
|
|
|
|
* if (my_cpumasks == NULL)
|
|
|
|
* "kmalloc failed"...
|
|
|
|
*
|
|
|
|
* References are now pointers to the cpumask_t variables (*mask1, ...)
|
|
|
|
*
|
2008-07-15 15:14:36 -06:00
|
|
|
*if NR_CPUS > BITS_PER_LONG
|
|
|
|
* CPUMASK_ALLOC(m) Declares and allocates struct m *m =
|
2008-07-18 19:11:33 -06:00
|
|
|
* kmalloc(sizeof(*m), GFP_KERNEL)
|
|
|
|
* CPUMASK_FREE(m) Macro for kfree(m)
|
2008-07-15 15:14:36 -06:00
|
|
|
*else
|
|
|
|
* CPUMASK_ALLOC(m) Declares struct m _m, *m = &_m
|
|
|
|
* CPUMASK_FREE(m) Nop
|
|
|
|
*endif
|
2008-07-18 19:11:33 -06:00
|
|
|
* CPUMASK_PTR(v, m) Declares cpumask_t *v = &(m->v)
|
|
|
|
* ------------------------------------------------------------------------
|
2008-07-15 15:14:36 -06:00
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* int cpumask_scnprintf(buf, len, mask) Format cpumask for printing
|
2006-10-11 02:21:55 -06:00
|
|
|
* int cpumask_parse_user(ubuf, ulen, mask) Parse ascii string as cpumask
|
2005-04-16 16:20:36 -06:00
|
|
|
* int cpulist_scnprintf(buf, len, mask) Format cpumask as list for printing
|
|
|
|
* int cpulist_parse(buf, map) Parse ascii string as cpulist
|
2005-10-30 16:02:33 -07:00
|
|
|
* int cpu_remap(oldbit, old, new) newbit = map(old, new)(oldbit)
|
mempolicy: add bitmap_onto() and bitmap_fold() operations
The following adds two more bitmap operators, bitmap_onto() and bitmap_fold(),
with the usual cpumask and nodemask wrappers.
The bitmap_onto() operator computes one bitmap relative to another. If the
n-th bit in the origin mask is set, then the m-th bit of the destination mask
will be set, where m is the position of the n-th set bit in the relative mask.
The bitmap_fold() operator folds a bitmap into a second that has bit m set iff
the input bitmap has some bit n set, where m == n mod sz, for the specified sz
value.
There are two substantive changes between this patch and its
predecessor bitmap_relative:
1) Renamed bitmap_relative() to be bitmap_onto().
2) Added bitmap_fold().
The essential motivation for bitmap_onto() is to provide a mechanism for
converting a cpuset-relative CPU or Node mask to an absolute mask. Cpuset
relative masks are written as if the current task were in a cpuset whose CPUs
or Nodes were just the consecutive ones numbered 0..N-1, for some N. The
bitmap_onto() operator is provided in anticipation of adding support for the
first such cpuset relative mask, by the mbind() and set_mempolicy() system
calls, using a planned flag of MPOL_F_RELATIVE_NODES. These bitmap operators
(and their nodemask wrappers, in particular) will be used in code that
converts the user specified cpuset relative memory policy to a specific system
node numbered policy, given the current mems_allowed of the tasks cpuset.
Such cpuset relative mempolicies will address two deficiencies
of the existing interface between cpusets and mempolicies:
1) A task cannot at present reliably establish a cpuset
relative mempolicy because there is an essential race
condition, in that the tasks cpuset may be changed in
between the time the task can query its cpuset placement,
and the time the task can issue the applicable mbind or
set_memplicy system call.
2) A task cannot at present establish what cpuset relative
mempolicy it would like to have, if it is in a smaller
cpuset than it might have mempolicy preferences for,
because the existing interface only allows specifying
mempolicies for nodes currently allowed by the cpuset.
Cpuset relative mempolicies are useful for tasks that don't distinguish
particularly between one CPU or Node and another, but only between how many of
each are allowed, and the proper placement of threads and memory pages on the
various CPUs and Nodes available.
The motivation for the added bitmap_fold() can be seen in the following
example.
Let's say an application has specified some mempolicies that presume 16 memory
nodes, including say a mempolicy that specified MPOL_F_RELATIVE_NODES (cpuset
relative) nodes 12-15. Then lets say that application is crammed into a
cpuset that only has 8 memory nodes, 0-7. If one just uses bitmap_onto(),
this mempolicy, mapped to that cpuset, would ignore the requested relative
nodes above 7, leaving it empty of nodes. That's not good; better to fold the
higher nodes down, so that some nodes are included in the resulting mapped
mempolicy. In this case, the mempolicy nodes 12-15 are taken modulo 8 (the
weight of the mems_allowed of the confining cpuset), resulting in a mempolicy
specifying nodes 4-7.
Signed-off-by: Paul Jackson <pj@sgi.com>
Signed-off-by: David Rientjes <rientjes@google.com>
Cc: Christoph Lameter <clameter@sgi.com>
Cc: Andi Kleen <ak@suse.de>
Cc: Mel Gorman <mel@csn.ul.ie>
Cc: Lee Schermerhorn <lee.schermerhorn@hp.com>
Cc: <kosaki.motohiro@jp.fujitsu.com>
Cc: <ray-lk@madrabbit.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-04-28 03:12:29 -06:00
|
|
|
* void cpus_remap(dst, src, old, new) *dst = map(old, new)(src)
|
|
|
|
* void cpus_onto(dst, orig, relmap) *dst = orig relative to relmap
|
|
|
|
* void cpus_fold(dst, orig, sz) dst bits = orig bits mod sz
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2008-05-12 13:21:13 -06:00
|
|
|
* for_each_cpu_mask(cpu, mask) for-loop cpu over mask using NR_CPUS
|
|
|
|
* for_each_cpu_mask_nr(cpu, mask) for-loop cpu over mask using nr_cpu_ids
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* int num_online_cpus() Number of online CPUs
|
|
|
|
* int num_possible_cpus() Number of all possible CPUs
|
|
|
|
* int num_present_cpus() Number of present CPUs
|
|
|
|
*
|
|
|
|
* int cpu_online(cpu) Is some cpu online?
|
|
|
|
* int cpu_possible(cpu) Is some cpu possible?
|
|
|
|
* int cpu_present(cpu) Is some cpu present (can schedule)?
|
|
|
|
*
|
|
|
|
* int any_online_cpu(mask) First online cpu in mask
|
|
|
|
*
|
2006-03-28 02:56:36 -07:00
|
|
|
* for_each_possible_cpu(cpu) for-loop cpu over cpu_possible_map
|
2005-04-16 16:20:36 -06:00
|
|
|
* for_each_online_cpu(cpu) for-loop cpu over cpu_online_map
|
|
|
|
* for_each_present_cpu(cpu) for-loop cpu over cpu_present_map
|
|
|
|
*
|
|
|
|
* Subtlety:
|
|
|
|
* 1) The 'type-checked' form of cpu_isset() causes gcc (3.3.2, anyway)
|
|
|
|
* to generate slightly worse code. Note for example the additional
|
|
|
|
* 40 lines of assembly code compiling the "for each possible cpu"
|
|
|
|
* loops buried in the disk_stat_read() macros calls when compiling
|
|
|
|
* drivers/block/genhd.c (arch i386, CONFIG_SMP=y). So use a simple
|
|
|
|
* one-line #define for cpu_isset(), instead of wrapping an inline
|
|
|
|
* inside a macro, the way we do the other calls.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/threads.h>
|
|
|
|
#include <linux/bitmap.h>
|
|
|
|
|
2008-11-04 19:39:10 -07:00
|
|
|
typedef struct cpumask { DECLARE_BITMAP(bits, NR_CPUS); } cpumask_t;
|
2005-04-16 16:20:36 -06:00
|
|
|
extern cpumask_t _unused_cpumask_arg_;
|
|
|
|
|
|
|
|
#define cpu_set(cpu, dst) __cpu_set((cpu), &(dst))
|
|
|
|
static inline void __cpu_set(int cpu, volatile cpumask_t *dstp)
|
|
|
|
{
|
|
|
|
set_bit(cpu, dstp->bits);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define cpu_clear(cpu, dst) __cpu_clear((cpu), &(dst))
|
|
|
|
static inline void __cpu_clear(int cpu, volatile cpumask_t *dstp)
|
|
|
|
{
|
|
|
|
clear_bit(cpu, dstp->bits);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define cpus_setall(dst) __cpus_setall(&(dst), NR_CPUS)
|
|
|
|
static inline void __cpus_setall(cpumask_t *dstp, int nbits)
|
|
|
|
{
|
|
|
|
bitmap_fill(dstp->bits, nbits);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define cpus_clear(dst) __cpus_clear(&(dst), NR_CPUS)
|
|
|
|
static inline void __cpus_clear(cpumask_t *dstp, int nbits)
|
|
|
|
{
|
|
|
|
bitmap_zero(dstp->bits, nbits);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* No static inline type checking - see Subtlety (1) above. */
|
|
|
|
#define cpu_isset(cpu, cpumask) test_bit((cpu), (cpumask).bits)
|
|
|
|
|
|
|
|
#define cpu_test_and_set(cpu, cpumask) __cpu_test_and_set((cpu), &(cpumask))
|
|
|
|
static inline int __cpu_test_and_set(int cpu, cpumask_t *addr)
|
|
|
|
{
|
|
|
|
return test_and_set_bit(cpu, addr->bits);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define cpus_and(dst, src1, src2) __cpus_and(&(dst), &(src1), &(src2), NR_CPUS)
|
|
|
|
static inline void __cpus_and(cpumask_t *dstp, const cpumask_t *src1p,
|
|
|
|
const cpumask_t *src2p, int nbits)
|
|
|
|
{
|
|
|
|
bitmap_and(dstp->bits, src1p->bits, src2p->bits, nbits);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define cpus_or(dst, src1, src2) __cpus_or(&(dst), &(src1), &(src2), NR_CPUS)
|
|
|
|
static inline void __cpus_or(cpumask_t *dstp, const cpumask_t *src1p,
|
|
|
|
const cpumask_t *src2p, int nbits)
|
|
|
|
{
|
|
|
|
bitmap_or(dstp->bits, src1p->bits, src2p->bits, nbits);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define cpus_xor(dst, src1, src2) __cpus_xor(&(dst), &(src1), &(src2), NR_CPUS)
|
|
|
|
static inline void __cpus_xor(cpumask_t *dstp, const cpumask_t *src1p,
|
|
|
|
const cpumask_t *src2p, int nbits)
|
|
|
|
{
|
|
|
|
bitmap_xor(dstp->bits, src1p->bits, src2p->bits, nbits);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define cpus_andnot(dst, src1, src2) \
|
|
|
|
__cpus_andnot(&(dst), &(src1), &(src2), NR_CPUS)
|
|
|
|
static inline void __cpus_andnot(cpumask_t *dstp, const cpumask_t *src1p,
|
|
|
|
const cpumask_t *src2p, int nbits)
|
|
|
|
{
|
|
|
|
bitmap_andnot(dstp->bits, src1p->bits, src2p->bits, nbits);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define cpus_complement(dst, src) __cpus_complement(&(dst), &(src), NR_CPUS)
|
|
|
|
static inline void __cpus_complement(cpumask_t *dstp,
|
|
|
|
const cpumask_t *srcp, int nbits)
|
|
|
|
{
|
|
|
|
bitmap_complement(dstp->bits, srcp->bits, nbits);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define cpus_equal(src1, src2) __cpus_equal(&(src1), &(src2), NR_CPUS)
|
|
|
|
static inline int __cpus_equal(const cpumask_t *src1p,
|
|
|
|
const cpumask_t *src2p, int nbits)
|
|
|
|
{
|
|
|
|
return bitmap_equal(src1p->bits, src2p->bits, nbits);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define cpus_intersects(src1, src2) __cpus_intersects(&(src1), &(src2), NR_CPUS)
|
|
|
|
static inline int __cpus_intersects(const cpumask_t *src1p,
|
|
|
|
const cpumask_t *src2p, int nbits)
|
|
|
|
{
|
|
|
|
return bitmap_intersects(src1p->bits, src2p->bits, nbits);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define cpus_subset(src1, src2) __cpus_subset(&(src1), &(src2), NR_CPUS)
|
|
|
|
static inline int __cpus_subset(const cpumask_t *src1p,
|
|
|
|
const cpumask_t *src2p, int nbits)
|
|
|
|
{
|
|
|
|
return bitmap_subset(src1p->bits, src2p->bits, nbits);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define cpus_empty(src) __cpus_empty(&(src), NR_CPUS)
|
|
|
|
static inline int __cpus_empty(const cpumask_t *srcp, int nbits)
|
|
|
|
{
|
|
|
|
return bitmap_empty(srcp->bits, nbits);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define cpus_full(cpumask) __cpus_full(&(cpumask), NR_CPUS)
|
|
|
|
static inline int __cpus_full(const cpumask_t *srcp, int nbits)
|
|
|
|
{
|
|
|
|
return bitmap_full(srcp->bits, nbits);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define cpus_weight(cpumask) __cpus_weight(&(cpumask), NR_CPUS)
|
|
|
|
static inline int __cpus_weight(const cpumask_t *srcp, int nbits)
|
|
|
|
{
|
|
|
|
return bitmap_weight(srcp->bits, nbits);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define cpus_shift_right(dst, src, n) \
|
|
|
|
__cpus_shift_right(&(dst), &(src), (n), NR_CPUS)
|
|
|
|
static inline void __cpus_shift_right(cpumask_t *dstp,
|
|
|
|
const cpumask_t *srcp, int n, int nbits)
|
|
|
|
{
|
|
|
|
bitmap_shift_right(dstp->bits, srcp->bits, n, nbits);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define cpus_shift_left(dst, src, n) \
|
|
|
|
__cpus_shift_left(&(dst), &(src), (n), NR_CPUS)
|
|
|
|
static inline void __cpus_shift_left(cpumask_t *dstp,
|
|
|
|
const cpumask_t *srcp, int n, int nbits)
|
|
|
|
{
|
|
|
|
bitmap_shift_left(dstp->bits, srcp->bits, n, nbits);
|
|
|
|
}
|
|
|
|
|
cpu masks: optimize and clean up cpumask_of_cpu()
Clean up and optimize cpumask_of_cpu(), by sharing all the zero words.
Instead of stupidly generating all possible i=0...NR_CPUS 2^i patterns
creating a huge array of constant bitmasks, realize that the zero words
can be shared.
In other words, on a 64-bit architecture, we only ever need 64 of these
arrays - with a different bit set in one single world (with enough zero
words around it so that we can create any bitmask by just offsetting in
that big array). And then we just put enough zeroes around it that we
can point every single cpumask to be one of those things.
So when we have 4k CPU's, instead of having 4k arrays (of 4k bits each,
with one bit set in each array - 2MB memory total), we have exactly 64
arrays instead, each 8k bits in size (64kB total).
And then we just point cpumask(n) to the right position (which we can
calculate dynamically). Once we have the right arrays, getting
"cpumask(n)" ends up being:
static inline const cpumask_t *get_cpu_mask(unsigned int cpu)
{
const unsigned long *p = cpu_bit_bitmap[1 + cpu % BITS_PER_LONG];
p -= cpu / BITS_PER_LONG;
return (const cpumask_t *)p;
}
This brings other advantages and simplifications as well:
- we are not wasting memory that is just filled with a single bit in
various different places
- we don't need all those games to re-create the arrays in some dense
format, because they're already going to be dense enough.
if we compile a kernel for up to 4k CPU's, "wasting" that 64kB of memory
is a non-issue (especially since by doing this "overlapping" trick we
probably get better cache behaviour anyway).
[ mingo@elte.hu:
Converted Linus's mails into a commit. See:
http://lkml.org/lkml/2008/7/27/156
http://lkml.org/lkml/2008/7/28/320
Also applied a family filter - which also has the side-effect of leaving
out the bits where Linus calls me an idio... Oh, never mind ;-)
]
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Al Viro <viro@ZenIV.linux.org.uk>
Cc: Mike Travis <travis@sgi.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-28 12:32:33 -06:00
|
|
|
/*
|
|
|
|
* Special-case data structure for "single bit set only" constant CPU masks.
|
|
|
|
*
|
|
|
|
* We pre-generate all the 64 (or 32) possible bit positions, with enough
|
|
|
|
* padding to the left and the right, and return the constant pointer
|
|
|
|
* appropriately offset.
|
|
|
|
*/
|
|
|
|
extern const unsigned long
|
|
|
|
cpu_bit_bitmap[BITS_PER_LONG+1][BITS_TO_LONGS(NR_CPUS)];
|
|
|
|
|
|
|
|
static inline const cpumask_t *get_cpu_mask(unsigned int cpu)
|
|
|
|
{
|
|
|
|
const unsigned long *p = cpu_bit_bitmap[1 + cpu % BITS_PER_LONG];
|
|
|
|
p -= cpu / BITS_PER_LONG;
|
|
|
|
return (const cpumask_t *)p;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In cases where we take the address of the cpumask immediately,
|
|
|
|
* gcc optimizes it out (it's a constant) and there's no huge stack
|
|
|
|
* variable created:
|
|
|
|
*/
|
2008-07-29 00:07:37 -06:00
|
|
|
#define cpumask_of_cpu(cpu) (*get_cpu_mask(cpu))
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
|
|
#define CPU_MASK_LAST_WORD BITMAP_LAST_WORD_MASK(NR_CPUS)
|
|
|
|
|
|
|
|
#if NR_CPUS <= BITS_PER_LONG
|
|
|
|
|
|
|
|
#define CPU_MASK_ALL \
|
|
|
|
(cpumask_t) { { \
|
|
|
|
[BITS_TO_LONGS(NR_CPUS)-1] = CPU_MASK_LAST_WORD \
|
|
|
|
} }
|
|
|
|
|
2008-04-04 19:11:02 -06:00
|
|
|
#define CPU_MASK_ALL_PTR (&CPU_MASK_ALL)
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#else
|
|
|
|
|
|
|
|
#define CPU_MASK_ALL \
|
|
|
|
(cpumask_t) { { \
|
|
|
|
[0 ... BITS_TO_LONGS(NR_CPUS)-2] = ~0UL, \
|
|
|
|
[BITS_TO_LONGS(NR_CPUS)-1] = CPU_MASK_LAST_WORD \
|
|
|
|
} }
|
|
|
|
|
2008-04-04 19:11:02 -06:00
|
|
|
/* cpu_mask_all is in init/main.c */
|
|
|
|
extern cpumask_t cpu_mask_all;
|
|
|
|
#define CPU_MASK_ALL_PTR (&cpu_mask_all)
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#define CPU_MASK_NONE \
|
|
|
|
(cpumask_t) { { \
|
|
|
|
[0 ... BITS_TO_LONGS(NR_CPUS)-1] = 0UL \
|
|
|
|
} }
|
|
|
|
|
|
|
|
#define CPU_MASK_CPU0 \
|
|
|
|
(cpumask_t) { { \
|
|
|
|
[0] = 1UL \
|
|
|
|
} }
|
|
|
|
|
|
|
|
#define cpus_addr(src) ((src).bits)
|
|
|
|
|
2008-07-15 15:14:36 -06:00
|
|
|
#if NR_CPUS > BITS_PER_LONG
|
|
|
|
#define CPUMASK_ALLOC(m) struct m *m = kmalloc(sizeof(*m), GFP_KERNEL)
|
|
|
|
#define CPUMASK_FREE(m) kfree(m)
|
|
|
|
#else
|
2008-07-18 19:11:33 -06:00
|
|
|
#define CPUMASK_ALLOC(m) struct m _m, *m = &_m
|
2008-07-15 15:14:36 -06:00
|
|
|
#define CPUMASK_FREE(m)
|
|
|
|
#endif
|
2008-07-18 19:11:33 -06:00
|
|
|
#define CPUMASK_PTR(v, m) cpumask_t *v = &(m->v)
|
2008-07-15 15:14:36 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#define cpumask_scnprintf(buf, len, src) \
|
|
|
|
__cpumask_scnprintf((buf), (len), &(src), NR_CPUS)
|
|
|
|
static inline int __cpumask_scnprintf(char *buf, int len,
|
|
|
|
const cpumask_t *srcp, int nbits)
|
|
|
|
{
|
|
|
|
return bitmap_scnprintf(buf, len, srcp->bits, nbits);
|
|
|
|
}
|
|
|
|
|
2006-10-11 02:21:55 -06:00
|
|
|
#define cpumask_parse_user(ubuf, ulen, dst) \
|
|
|
|
__cpumask_parse_user((ubuf), (ulen), &(dst), NR_CPUS)
|
|
|
|
static inline int __cpumask_parse_user(const char __user *buf, int len,
|
2005-04-16 16:20:36 -06:00
|
|
|
cpumask_t *dstp, int nbits)
|
|
|
|
{
|
2006-10-11 02:21:55 -06:00
|
|
|
return bitmap_parse_user(buf, len, dstp->bits, nbits);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#define cpulist_scnprintf(buf, len, src) \
|
|
|
|
__cpulist_scnprintf((buf), (len), &(src), NR_CPUS)
|
|
|
|
static inline int __cpulist_scnprintf(char *buf, int len,
|
|
|
|
const cpumask_t *srcp, int nbits)
|
|
|
|
{
|
|
|
|
return bitmap_scnlistprintf(buf, len, srcp->bits, nbits);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define cpulist_parse(buf, dst) __cpulist_parse((buf), &(dst), NR_CPUS)
|
|
|
|
static inline int __cpulist_parse(const char *buf, cpumask_t *dstp, int nbits)
|
|
|
|
{
|
|
|
|
return bitmap_parselist(buf, dstp->bits, nbits);
|
|
|
|
}
|
|
|
|
|
2005-10-30 16:02:33 -07:00
|
|
|
#define cpu_remap(oldbit, old, new) \
|
|
|
|
__cpu_remap((oldbit), &(old), &(new), NR_CPUS)
|
|
|
|
static inline int __cpu_remap(int oldbit,
|
|
|
|
const cpumask_t *oldp, const cpumask_t *newp, int nbits)
|
|
|
|
{
|
|
|
|
return bitmap_bitremap(oldbit, oldp->bits, newp->bits, nbits);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define cpus_remap(dst, src, old, new) \
|
|
|
|
__cpus_remap(&(dst), &(src), &(old), &(new), NR_CPUS)
|
|
|
|
static inline void __cpus_remap(cpumask_t *dstp, const cpumask_t *srcp,
|
|
|
|
const cpumask_t *oldp, const cpumask_t *newp, int nbits)
|
|
|
|
{
|
|
|
|
bitmap_remap(dstp->bits, srcp->bits, oldp->bits, newp->bits, nbits);
|
|
|
|
}
|
|
|
|
|
mempolicy: add bitmap_onto() and bitmap_fold() operations
The following adds two more bitmap operators, bitmap_onto() and bitmap_fold(),
with the usual cpumask and nodemask wrappers.
The bitmap_onto() operator computes one bitmap relative to another. If the
n-th bit in the origin mask is set, then the m-th bit of the destination mask
will be set, where m is the position of the n-th set bit in the relative mask.
The bitmap_fold() operator folds a bitmap into a second that has bit m set iff
the input bitmap has some bit n set, where m == n mod sz, for the specified sz
value.
There are two substantive changes between this patch and its
predecessor bitmap_relative:
1) Renamed bitmap_relative() to be bitmap_onto().
2) Added bitmap_fold().
The essential motivation for bitmap_onto() is to provide a mechanism for
converting a cpuset-relative CPU or Node mask to an absolute mask. Cpuset
relative masks are written as if the current task were in a cpuset whose CPUs
or Nodes were just the consecutive ones numbered 0..N-1, for some N. The
bitmap_onto() operator is provided in anticipation of adding support for the
first such cpuset relative mask, by the mbind() and set_mempolicy() system
calls, using a planned flag of MPOL_F_RELATIVE_NODES. These bitmap operators
(and their nodemask wrappers, in particular) will be used in code that
converts the user specified cpuset relative memory policy to a specific system
node numbered policy, given the current mems_allowed of the tasks cpuset.
Such cpuset relative mempolicies will address two deficiencies
of the existing interface between cpusets and mempolicies:
1) A task cannot at present reliably establish a cpuset
relative mempolicy because there is an essential race
condition, in that the tasks cpuset may be changed in
between the time the task can query its cpuset placement,
and the time the task can issue the applicable mbind or
set_memplicy system call.
2) A task cannot at present establish what cpuset relative
mempolicy it would like to have, if it is in a smaller
cpuset than it might have mempolicy preferences for,
because the existing interface only allows specifying
mempolicies for nodes currently allowed by the cpuset.
Cpuset relative mempolicies are useful for tasks that don't distinguish
particularly between one CPU or Node and another, but only between how many of
each are allowed, and the proper placement of threads and memory pages on the
various CPUs and Nodes available.
The motivation for the added bitmap_fold() can be seen in the following
example.
Let's say an application has specified some mempolicies that presume 16 memory
nodes, including say a mempolicy that specified MPOL_F_RELATIVE_NODES (cpuset
relative) nodes 12-15. Then lets say that application is crammed into a
cpuset that only has 8 memory nodes, 0-7. If one just uses bitmap_onto(),
this mempolicy, mapped to that cpuset, would ignore the requested relative
nodes above 7, leaving it empty of nodes. That's not good; better to fold the
higher nodes down, so that some nodes are included in the resulting mapped
mempolicy. In this case, the mempolicy nodes 12-15 are taken modulo 8 (the
weight of the mems_allowed of the confining cpuset), resulting in a mempolicy
specifying nodes 4-7.
Signed-off-by: Paul Jackson <pj@sgi.com>
Signed-off-by: David Rientjes <rientjes@google.com>
Cc: Christoph Lameter <clameter@sgi.com>
Cc: Andi Kleen <ak@suse.de>
Cc: Mel Gorman <mel@csn.ul.ie>
Cc: Lee Schermerhorn <lee.schermerhorn@hp.com>
Cc: <kosaki.motohiro@jp.fujitsu.com>
Cc: <ray-lk@madrabbit.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-04-28 03:12:29 -06:00
|
|
|
#define cpus_onto(dst, orig, relmap) \
|
|
|
|
__cpus_onto(&(dst), &(orig), &(relmap), NR_CPUS)
|
|
|
|
static inline void __cpus_onto(cpumask_t *dstp, const cpumask_t *origp,
|
|
|
|
const cpumask_t *relmapp, int nbits)
|
|
|
|
{
|
|
|
|
bitmap_onto(dstp->bits, origp->bits, relmapp->bits, nbits);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define cpus_fold(dst, orig, sz) \
|
|
|
|
__cpus_fold(&(dst), &(orig), sz, NR_CPUS)
|
|
|
|
static inline void __cpus_fold(cpumask_t *dstp, const cpumask_t *origp,
|
|
|
|
int sz, int nbits)
|
|
|
|
{
|
|
|
|
bitmap_fold(dstp->bits, origp->bits, sz, nbits);
|
|
|
|
}
|
|
|
|
|
2008-05-12 13:21:13 -06:00
|
|
|
#if NR_CPUS == 1
|
|
|
|
|
|
|
|
#define nr_cpu_ids 1
|
|
|
|
#define first_cpu(src) ({ (void)(src); 0; })
|
|
|
|
#define next_cpu(n, src) ({ (void)(src); 1; })
|
|
|
|
#define any_online_cpu(mask) 0
|
|
|
|
#define for_each_cpu_mask(cpu, mask) \
|
|
|
|
for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask)
|
|
|
|
|
|
|
|
#else /* NR_CPUS > 1 */
|
|
|
|
|
|
|
|
extern int nr_cpu_ids;
|
|
|
|
int __first_cpu(const cpumask_t *srcp);
|
|
|
|
int __next_cpu(int n, const cpumask_t *srcp);
|
|
|
|
int __any_online_cpu(const cpumask_t *mask);
|
|
|
|
|
|
|
|
#define first_cpu(src) __first_cpu(&(src))
|
|
|
|
#define next_cpu(n, src) __next_cpu((n), &(src))
|
|
|
|
#define any_online_cpu(mask) __any_online_cpu(&(mask))
|
2008-05-13 03:28:21 -06:00
|
|
|
#define for_each_cpu_mask(cpu, mask) \
|
|
|
|
for ((cpu) = -1; \
|
|
|
|
(cpu) = next_cpu((cpu), (mask)), \
|
|
|
|
(cpu) < NR_CPUS; )
|
2008-05-12 13:21:13 -06:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if NR_CPUS <= 64
|
|
|
|
|
|
|
|
#define next_cpu_nr(n, src) next_cpu(n, src)
|
|
|
|
#define cpus_weight_nr(cpumask) cpus_weight(cpumask)
|
|
|
|
#define for_each_cpu_mask_nr(cpu, mask) for_each_cpu_mask(cpu, mask)
|
|
|
|
|
|
|
|
#else /* NR_CPUS > 64 */
|
|
|
|
|
|
|
|
int __next_cpu_nr(int n, const cpumask_t *srcp);
|
|
|
|
#define next_cpu_nr(n, src) __next_cpu_nr((n), &(src))
|
|
|
|
#define cpus_weight_nr(cpumask) __cpus_weight(&(cpumask), nr_cpu_ids)
|
2008-05-13 03:28:21 -06:00
|
|
|
#define for_each_cpu_mask_nr(cpu, mask) \
|
|
|
|
for ((cpu) = -1; \
|
|
|
|
(cpu) = next_cpu_nr((cpu), (mask)), \
|
|
|
|
(cpu) < nr_cpu_ids; )
|
2008-05-12 13:21:13 -06:00
|
|
|
|
|
|
|
#endif /* NR_CPUS > 64 */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The following particular system cpumasks and operations manage
|
2008-07-15 05:43:49 -06:00
|
|
|
* possible, present, active and online cpus. Each of them is a fixed size
|
2005-04-16 16:20:36 -06:00
|
|
|
* bitmap of size NR_CPUS.
|
|
|
|
*
|
|
|
|
* #ifdef CONFIG_HOTPLUG_CPU
|
2006-02-10 02:51:08 -07:00
|
|
|
* cpu_possible_map - has bit 'cpu' set iff cpu is populatable
|
2005-04-16 16:20:36 -06:00
|
|
|
* cpu_present_map - has bit 'cpu' set iff cpu is populated
|
|
|
|
* cpu_online_map - has bit 'cpu' set iff cpu available to scheduler
|
2008-07-15 05:43:49 -06:00
|
|
|
* cpu_active_map - has bit 'cpu' set iff cpu available to migration
|
2005-04-16 16:20:36 -06:00
|
|
|
* #else
|
|
|
|
* cpu_possible_map - has bit 'cpu' set iff cpu is populated
|
|
|
|
* cpu_present_map - copy of cpu_possible_map
|
|
|
|
* cpu_online_map - has bit 'cpu' set iff cpu available to scheduler
|
|
|
|
* #endif
|
|
|
|
*
|
|
|
|
* In either case, NR_CPUS is fixed at compile time, as the static
|
|
|
|
* size of these bitmaps. The cpu_possible_map is fixed at boot
|
|
|
|
* time, as the set of CPU id's that it is possible might ever
|
|
|
|
* be plugged in at anytime during the life of that system boot.
|
|
|
|
* The cpu_present_map is dynamic(*), representing which CPUs
|
|
|
|
* are currently plugged in. And cpu_online_map is the dynamic
|
|
|
|
* subset of cpu_present_map, indicating those CPUs available
|
|
|
|
* for scheduling.
|
|
|
|
*
|
|
|
|
* If HOTPLUG is enabled, then cpu_possible_map is forced to have
|
|
|
|
* all NR_CPUS bits set, otherwise it is just the set of CPUs that
|
|
|
|
* ACPI reports present at boot.
|
|
|
|
*
|
|
|
|
* If HOTPLUG is enabled, then cpu_present_map varies dynamically,
|
|
|
|
* depending on what ACPI reports as currently plugged in, otherwise
|
|
|
|
* cpu_present_map is just a copy of cpu_possible_map.
|
|
|
|
*
|
|
|
|
* (*) Well, cpu_present_map is dynamic in the hotplug case. If not
|
|
|
|
* hotplug, it's a copy of cpu_possible_map, hence fixed at boot.
|
|
|
|
*
|
|
|
|
* Subtleties:
|
|
|
|
* 1) UP arch's (NR_CPUS == 1, CONFIG_SMP not defined) hardcode
|
|
|
|
* assumption that their single CPU is online. The UP
|
|
|
|
* cpu_{online,possible,present}_maps are placebos. Changing them
|
|
|
|
* will have no useful affect on the following num_*_cpus()
|
|
|
|
* and cpu_*() macros in the UP case. This ugliness is a UP
|
|
|
|
* optimization - don't waste any instructions or memory references
|
|
|
|
* asking if you're online or how many CPUs there are if there is
|
|
|
|
* only one CPU.
|
|
|
|
* 2) Most SMP arch's #define some of these maps to be some
|
|
|
|
* other map specific to that arch. Therefore, the following
|
|
|
|
* must be #define macros, not inlines. To see why, examine
|
|
|
|
* the assembly code produced by the following. Note that
|
|
|
|
* set1() writes phys_x_map, but set2() writes x_map:
|
|
|
|
* int x_map, phys_x_map;
|
|
|
|
* #define set1(a) x_map = a
|
|
|
|
* inline void set2(int a) { x_map = a; }
|
|
|
|
* #define x_map phys_x_map
|
|
|
|
* main(){ set1(3); set2(5); }
|
|
|
|
*/
|
|
|
|
|
|
|
|
extern cpumask_t cpu_possible_map;
|
|
|
|
extern cpumask_t cpu_online_map;
|
|
|
|
extern cpumask_t cpu_present_map;
|
2008-07-15 05:43:49 -06:00
|
|
|
extern cpumask_t cpu_active_map;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#if NR_CPUS > 1
|
2008-05-12 13:21:13 -06:00
|
|
|
#define num_online_cpus() cpus_weight_nr(cpu_online_map)
|
|
|
|
#define num_possible_cpus() cpus_weight_nr(cpu_possible_map)
|
|
|
|
#define num_present_cpus() cpus_weight_nr(cpu_present_map)
|
2005-04-16 16:20:36 -06:00
|
|
|
#define cpu_online(cpu) cpu_isset((cpu), cpu_online_map)
|
|
|
|
#define cpu_possible(cpu) cpu_isset((cpu), cpu_possible_map)
|
|
|
|
#define cpu_present(cpu) cpu_isset((cpu), cpu_present_map)
|
2008-07-15 05:43:49 -06:00
|
|
|
#define cpu_active(cpu) cpu_isset((cpu), cpu_active_map)
|
2005-04-16 16:20:36 -06:00
|
|
|
#else
|
|
|
|
#define num_online_cpus() 1
|
|
|
|
#define num_possible_cpus() 1
|
|
|
|
#define num_present_cpus() 1
|
|
|
|
#define cpu_online(cpu) ((cpu) == 0)
|
|
|
|
#define cpu_possible(cpu) ((cpu) == 0)
|
|
|
|
#define cpu_present(cpu) ((cpu) == 0)
|
2008-07-15 05:43:49 -06:00
|
|
|
#define cpu_active(cpu) ((cpu) == 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|
2007-12-30 03:58:17 -07:00
|
|
|
#define cpu_is_offline(cpu) unlikely(!cpu_online(cpu))
|
|
|
|
|
2008-05-12 13:21:13 -06:00
|
|
|
#define for_each_possible_cpu(cpu) for_each_cpu_mask_nr((cpu), cpu_possible_map)
|
|
|
|
#define for_each_online_cpu(cpu) for_each_cpu_mask_nr((cpu), cpu_online_map)
|
|
|
|
#define for_each_present_cpu(cpu) for_each_cpu_mask_nr((cpu), cpu_present_map)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-11-04 19:39:10 -07:00
|
|
|
/* These are the new versions of the cpumask operators: passed by pointer.
|
|
|
|
* The older versions will be implemented in terms of these, then deleted. */
|
|
|
|
#define cpumask_bits(maskp) ((maskp)->bits)
|
|
|
|
|
|
|
|
#if NR_CPUS <= BITS_PER_LONG
|
|
|
|
#define CPU_BITS_ALL \
|
|
|
|
{ \
|
|
|
|
[BITS_TO_LONGS(NR_CPUS)-1] = CPU_MASK_LAST_WORD \
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This produces more efficient code. */
|
|
|
|
#define nr_cpumask_bits NR_CPUS
|
|
|
|
|
|
|
|
#else /* NR_CPUS > BITS_PER_LONG */
|
|
|
|
|
|
|
|
#define CPU_BITS_ALL \
|
|
|
|
{ \
|
|
|
|
[0 ... BITS_TO_LONGS(NR_CPUS)-2] = ~0UL, \
|
|
|
|
[BITS_TO_LONGS(NR_CPUS)-1] = CPU_MASK_LAST_WORD \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define nr_cpumask_bits nr_cpu_ids
|
|
|
|
#endif /* NR_CPUS > BITS_PER_LONG */
|
|
|
|
|
|
|
|
/* verify cpu argument to cpumask_* operators */
|
|
|
|
static inline unsigned int cpumask_check(unsigned int cpu)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_DEBUG_PER_CPU_MAPS
|
|
|
|
WARN_ON_ONCE(cpu >= nr_cpumask_bits);
|
|
|
|
#endif /* CONFIG_DEBUG_PER_CPU_MAPS */
|
|
|
|
return cpu;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if NR_CPUS == 1
|
|
|
|
/* Uniprocesor. */
|
|
|
|
#define cpumask_first(src) ({ (void)(src); 0; })
|
|
|
|
#define cpumask_next(n, src) ({ (void)(src); 1; })
|
|
|
|
#define cpumask_next_zero(n, src) ({ (void)(src); 1; })
|
|
|
|
#define cpumask_next_and(n, srcp, andp) ({ (void)(srcp), (void)(andp); 1; })
|
|
|
|
#define cpumask_any_but(mask, cpu) ({ (void)(mask); (void)(cpu); 0; })
|
|
|
|
|
|
|
|
#define for_each_cpu(cpu, mask) \
|
|
|
|
for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask)
|
|
|
|
#define for_each_cpu_and(cpu, mask, and) \
|
|
|
|
for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask, (void)and)
|
|
|
|
#else
|
|
|
|
/**
|
|
|
|
* cpumask_first - get the first cpu in a cpumask
|
|
|
|
* @srcp: the cpumask pointer
|
|
|
|
*
|
|
|
|
* Returns >= nr_cpu_ids if no cpus set.
|
|
|
|
*/
|
|
|
|
static inline unsigned int cpumask_first(const struct cpumask *srcp)
|
|
|
|
{
|
|
|
|
return find_first_bit(cpumask_bits(srcp), nr_cpumask_bits);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* cpumask_next - get the next cpu in a cpumask
|
|
|
|
* @n: the cpu prior to the place to search (ie. return will be > @n)
|
|
|
|
* @srcp: the cpumask pointer
|
|
|
|
*
|
|
|
|
* Returns >= nr_cpu_ids if no further cpus set.
|
|
|
|
*/
|
|
|
|
static inline unsigned int cpumask_next(int n, const struct cpumask *srcp)
|
|
|
|
{
|
|
|
|
/* -1 is a legal arg here. */
|
|
|
|
if (n != -1)
|
|
|
|
cpumask_check(n);
|
|
|
|
return find_next_bit(cpumask_bits(srcp), nr_cpumask_bits, n+1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
* @srcp: the cpumask pointer
|
|
|
|
*
|
|
|
|
* Returns >= nr_cpu_ids if no further cpus unset.
|
|
|
|
*/
|
|
|
|
static inline unsigned int cpumask_next_zero(int n, const struct cpumask *srcp)
|
|
|
|
{
|
|
|
|
/* -1 is a legal arg here. */
|
|
|
|
if (n != -1)
|
|
|
|
cpumask_check(n);
|
|
|
|
return find_next_zero_bit(cpumask_bits(srcp), nr_cpumask_bits, n+1);
|
|
|
|
}
|
|
|
|
|
|
|
|
int cpumask_next_and(int n, const struct cpumask *, const struct cpumask *);
|
|
|
|
int cpumask_any_but(const struct cpumask *mask, unsigned int cpu);
|
|
|
|
|
|
|
|
#define for_each_cpu(cpu, mask) \
|
|
|
|
for ((cpu) = -1; \
|
|
|
|
(cpu) = cpumask_next((cpu), (mask)), \
|
|
|
|
(cpu) < nr_cpu_ids;)
|
|
|
|
#define for_each_cpu_and(cpu, mask, and) \
|
|
|
|
for ((cpu) = -1; \
|
|
|
|
(cpu) = cpumask_next_and((cpu), (mask), (and)), \
|
|
|
|
(cpu) < nr_cpu_ids;)
|
|
|
|
#endif /* SMP */
|
|
|
|
|
|
|
|
#define CPU_BITS_NONE \
|
|
|
|
{ \
|
|
|
|
[0 ... BITS_TO_LONGS(NR_CPUS)-1] = 0UL \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define CPU_BITS_CPU0 \
|
|
|
|
{ \
|
|
|
|
[0] = 1UL \
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* cpumask_set_cpu - set a cpu in a cpumask
|
|
|
|
* @cpu: cpu number (< nr_cpu_ids)
|
|
|
|
* @dstp: the cpumask pointer
|
|
|
|
*/
|
|
|
|
static inline void cpumask_set_cpu(unsigned int cpu, struct cpumask *dstp)
|
|
|
|
{
|
|
|
|
set_bit(cpumask_check(cpu), cpumask_bits(dstp));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* cpumask_clear_cpu - clear a cpu in a cpumask
|
|
|
|
* @cpu: cpu number (< nr_cpu_ids)
|
|
|
|
* @dstp: the cpumask pointer
|
|
|
|
*/
|
|
|
|
static inline void cpumask_clear_cpu(int cpu, struct cpumask *dstp)
|
|
|
|
{
|
|
|
|
clear_bit(cpumask_check(cpu), cpumask_bits(dstp));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* cpumask_test_cpu - test for a cpu in a cpumask
|
|
|
|
* @cpu: cpu number (< nr_cpu_ids)
|
|
|
|
* @cpumask: the cpumask pointer
|
|
|
|
*
|
|
|
|
* No static inline type checking - see Subtlety (1) above.
|
|
|
|
*/
|
|
|
|
#define cpumask_test_cpu(cpu, cpumask) \
|
|
|
|
test_bit(cpumask_check(cpu), (cpumask)->bits)
|
|
|
|
|
|
|
|
/**
|
|
|
|
* cpumask_test_and_set_cpu - atomically test and set a cpu in a cpumask
|
|
|
|
* @cpu: cpu number (< nr_cpu_ids)
|
|
|
|
* @cpumask: the cpumask pointer
|
|
|
|
*
|
|
|
|
* test_and_set_bit wrapper for cpumasks.
|
|
|
|
*/
|
|
|
|
static inline int cpumask_test_and_set_cpu(int cpu, struct cpumask *cpumask)
|
|
|
|
{
|
|
|
|
return test_and_set_bit(cpumask_check(cpu), cpumask_bits(cpumask));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* cpumask_setall - set all cpus (< nr_cpu_ids) in a cpumask
|
|
|
|
* @dstp: the cpumask pointer
|
|
|
|
*/
|
|
|
|
static inline void cpumask_setall(struct cpumask *dstp)
|
|
|
|
{
|
|
|
|
bitmap_fill(cpumask_bits(dstp), nr_cpumask_bits);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* cpumask_clear - clear all cpus (< nr_cpu_ids) in a cpumask
|
|
|
|
* @dstp: the cpumask pointer
|
|
|
|
*/
|
|
|
|
static inline void cpumask_clear(struct cpumask *dstp)
|
|
|
|
{
|
|
|
|
bitmap_zero(cpumask_bits(dstp), nr_cpumask_bits);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* cpumask_and - *dstp = *src1p & *src2p
|
|
|
|
* @dstp: the cpumask result
|
|
|
|
* @src1p: the first input
|
|
|
|
* @src2p: the second input
|
|
|
|
*/
|
|
|
|
static inline void cpumask_and(struct cpumask *dstp,
|
|
|
|
const struct cpumask *src1p,
|
|
|
|
const struct cpumask *src2p)
|
|
|
|
{
|
|
|
|
bitmap_and(cpumask_bits(dstp), cpumask_bits(src1p),
|
|
|
|
cpumask_bits(src2p), nr_cpumask_bits);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* cpumask_or - *dstp = *src1p | *src2p
|
|
|
|
* @dstp: the cpumask result
|
|
|
|
* @src1p: the first input
|
|
|
|
* @src2p: the second input
|
|
|
|
*/
|
|
|
|
static inline void cpumask_or(struct cpumask *dstp, const struct cpumask *src1p,
|
|
|
|
const struct cpumask *src2p)
|
|
|
|
{
|
|
|
|
bitmap_or(cpumask_bits(dstp), cpumask_bits(src1p),
|
|
|
|
cpumask_bits(src2p), nr_cpumask_bits);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* cpumask_xor - *dstp = *src1p ^ *src2p
|
|
|
|
* @dstp: the cpumask result
|
|
|
|
* @src1p: the first input
|
|
|
|
* @src2p: the second input
|
|
|
|
*/
|
|
|
|
static inline void cpumask_xor(struct cpumask *dstp,
|
|
|
|
const struct cpumask *src1p,
|
|
|
|
const struct cpumask *src2p)
|
|
|
|
{
|
|
|
|
bitmap_xor(cpumask_bits(dstp), cpumask_bits(src1p),
|
|
|
|
cpumask_bits(src2p), nr_cpumask_bits);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* cpumask_andnot - *dstp = *src1p & ~*src2p
|
|
|
|
* @dstp: the cpumask result
|
|
|
|
* @src1p: the first input
|
|
|
|
* @src2p: the second input
|
|
|
|
*/
|
|
|
|
static inline void cpumask_andnot(struct cpumask *dstp,
|
|
|
|
const struct cpumask *src1p,
|
|
|
|
const struct cpumask *src2p)
|
|
|
|
{
|
|
|
|
bitmap_andnot(cpumask_bits(dstp), cpumask_bits(src1p),
|
|
|
|
cpumask_bits(src2p), nr_cpumask_bits);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* cpumask_complement - *dstp = ~*srcp
|
|
|
|
* @dstp: the cpumask result
|
|
|
|
* @srcp: the input to invert
|
|
|
|
*/
|
|
|
|
static inline void cpumask_complement(struct cpumask *dstp,
|
|
|
|
const struct cpumask *srcp)
|
|
|
|
{
|
|
|
|
bitmap_complement(cpumask_bits(dstp), cpumask_bits(srcp),
|
|
|
|
nr_cpumask_bits);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* cpumask_equal - *src1p == *src2p
|
|
|
|
* @src1p: the first input
|
|
|
|
* @src2p: the second input
|
|
|
|
*/
|
|
|
|
static inline bool cpumask_equal(const struct cpumask *src1p,
|
|
|
|
const struct cpumask *src2p)
|
|
|
|
{
|
|
|
|
return bitmap_equal(cpumask_bits(src1p), cpumask_bits(src2p),
|
|
|
|
nr_cpumask_bits);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* cpumask_intersects - (*src1p & *src2p) != 0
|
|
|
|
* @src1p: the first input
|
|
|
|
* @src2p: the second input
|
|
|
|
*/
|
|
|
|
static inline bool cpumask_intersects(const struct cpumask *src1p,
|
|
|
|
const struct cpumask *src2p)
|
|
|
|
{
|
|
|
|
return bitmap_intersects(cpumask_bits(src1p), cpumask_bits(src2p),
|
|
|
|
nr_cpumask_bits);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* cpumask_subset - (*src1p & ~*src2p) == 0
|
|
|
|
* @src1p: the first input
|
|
|
|
* @src2p: the second input
|
|
|
|
*/
|
|
|
|
static inline int cpumask_subset(const struct cpumask *src1p,
|
|
|
|
const struct cpumask *src2p)
|
|
|
|
{
|
|
|
|
return bitmap_subset(cpumask_bits(src1p), cpumask_bits(src2p),
|
|
|
|
nr_cpumask_bits);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* cpumask_empty - *srcp == 0
|
|
|
|
* @srcp: the cpumask to that all cpus < nr_cpu_ids are clear.
|
|
|
|
*/
|
|
|
|
static inline bool cpumask_empty(const struct cpumask *srcp)
|
|
|
|
{
|
|
|
|
return bitmap_empty(cpumask_bits(srcp), nr_cpumask_bits);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* cpumask_full - *srcp == 0xFFFFFFFF...
|
|
|
|
* @srcp: the cpumask to that all cpus < nr_cpu_ids are set.
|
|
|
|
*/
|
|
|
|
static inline bool cpumask_full(const struct cpumask *srcp)
|
|
|
|
{
|
|
|
|
return bitmap_full(cpumask_bits(srcp), nr_cpumask_bits);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* cpumask_weight - Count of bits in *srcp
|
|
|
|
* @srcp: the cpumask to count bits (< nr_cpu_ids) in.
|
|
|
|
*/
|
|
|
|
static inline unsigned int cpumask_weight(const struct cpumask *srcp)
|
|
|
|
{
|
|
|
|
return bitmap_weight(cpumask_bits(srcp), nr_cpumask_bits);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* cpumask_shift_right - *dstp = *srcp >> n
|
|
|
|
* @dstp: the cpumask result
|
|
|
|
* @srcp: the input to shift
|
|
|
|
* @n: the number of bits to shift by
|
|
|
|
*/
|
|
|
|
static inline void cpumask_shift_right(struct cpumask *dstp,
|
|
|
|
const struct cpumask *srcp, int n)
|
|
|
|
{
|
|
|
|
bitmap_shift_right(cpumask_bits(dstp), cpumask_bits(srcp), n,
|
|
|
|
nr_cpumask_bits);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* cpumask_shift_left - *dstp = *srcp << n
|
|
|
|
* @dstp: the cpumask result
|
|
|
|
* @srcp: the input to shift
|
|
|
|
* @n: the number of bits to shift by
|
|
|
|
*/
|
|
|
|
static inline void cpumask_shift_left(struct cpumask *dstp,
|
|
|
|
const struct cpumask *srcp, int n)
|
|
|
|
{
|
|
|
|
bitmap_shift_left(cpumask_bits(dstp), cpumask_bits(srcp), n,
|
|
|
|
nr_cpumask_bits);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* cpumask_copy - *dstp = *srcp
|
|
|
|
* @dstp: the result
|
|
|
|
* @srcp: the input cpumask
|
|
|
|
*/
|
|
|
|
static inline void cpumask_copy(struct cpumask *dstp,
|
|
|
|
const struct cpumask *srcp)
|
|
|
|
{
|
|
|
|
bitmap_copy(cpumask_bits(dstp), cpumask_bits(srcp), nr_cpumask_bits);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* cpumask_any - pick a "random" cpu from *srcp
|
|
|
|
* @srcp: the input cpumask
|
|
|
|
*
|
|
|
|
* Returns >= nr_cpu_ids if no cpus set.
|
|
|
|
*/
|
|
|
|
#define cpumask_any(srcp) cpumask_first(srcp)
|
|
|
|
|
|
|
|
/**
|
|
|
|
* cpumask_first_and - return the first cpu from *srcp1 & *srcp2
|
|
|
|
* @src1p: the first input
|
|
|
|
* @src2p: the second input
|
|
|
|
*
|
|
|
|
* Returns >= nr_cpu_ids if no cpus set in both. See also cpumask_next_and().
|
|
|
|
*/
|
|
|
|
#define cpumask_first_and(src1p, src2p) cpumask_next_and(-1, (src1p), (src2p))
|
|
|
|
|
|
|
|
/**
|
|
|
|
* cpumask_any_and - pick a "random" cpu from *mask1 & *mask2
|
|
|
|
* @mask1: the first input cpumask
|
|
|
|
* @mask2: the second input cpumask
|
|
|
|
*
|
|
|
|
* Returns >= nr_cpu_ids if no cpus set.
|
|
|
|
*/
|
|
|
|
#define cpumask_any_and(mask1, mask2) cpumask_first_and((mask1), (mask2))
|
|
|
|
|
2008-11-06 17:12:29 -07:00
|
|
|
/**
|
|
|
|
* cpumask_of - the cpumask containing just a given cpu
|
|
|
|
* @cpu: the cpu (<= nr_cpu_ids)
|
|
|
|
*/
|
|
|
|
#define cpumask_of(cpu) (get_cpu_mask(cpu))
|
|
|
|
|
2008-11-04 19:39:10 -07:00
|
|
|
/**
|
|
|
|
* to_cpumask - convert an NR_CPUS bitmap to a struct cpumask *
|
|
|
|
* @bitmap: the bitmap
|
|
|
|
*
|
|
|
|
* There are a few places where cpumask_var_t isn't appropriate and
|
|
|
|
* static cpumasks must be used (eg. very early boot), yet we don't
|
|
|
|
* expose the definition of 'struct cpumask'.
|
|
|
|
*
|
|
|
|
* This does the conversion, and can be used as a constant initializer.
|
|
|
|
*/
|
|
|
|
#define to_cpumask(bitmap) \
|
|
|
|
((struct cpumask *)(1 ? (bitmap) \
|
|
|
|
: (void *)sizeof(__check_is_bitmap(bitmap))))
|
|
|
|
|
|
|
|
static inline int __check_is_bitmap(const unsigned long *bitmap)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* cpumask_size - size to allocate for a 'struct cpumask' in bytes
|
|
|
|
*
|
|
|
|
* This will eventually be a runtime variable, depending on nr_cpu_ids.
|
|
|
|
*/
|
|
|
|
static inline size_t cpumask_size(void)
|
|
|
|
{
|
|
|
|
/* FIXME: Once all cpumask assignments are eliminated, this
|
|
|
|
* can be nr_cpumask_bits */
|
|
|
|
return BITS_TO_LONGS(NR_CPUS) * sizeof(long);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* cpumask_var_t: struct cpumask for stack usage.
|
|
|
|
*
|
|
|
|
* Oh, the wicked games we play! In order to make kernel coding a
|
|
|
|
* 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.
|
|
|
|
* cpumask_var_t tmpmask;
|
|
|
|
* if (!alloc_cpumask_var(&tmpmask, GFP_KERNEL))
|
|
|
|
* return -ENOMEM;
|
|
|
|
*
|
|
|
|
* ... use 'tmpmask' like a normal struct cpumask * ...
|
|
|
|
*
|
|
|
|
* free_cpumask_var(tmpmask);
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_CPUMASK_OFFSTACK
|
|
|
|
typedef struct cpumask *cpumask_var_t;
|
|
|
|
|
|
|
|
bool alloc_cpumask_var(cpumask_var_t *mask, gfp_t flags);
|
|
|
|
void alloc_bootmem_cpumask_var(cpumask_var_t *mask);
|
|
|
|
void free_cpumask_var(cpumask_var_t mask);
|
2008-11-06 17:12:29 -07:00
|
|
|
void free_bootmem_cpumask_var(cpumask_var_t mask);
|
2008-11-04 19:39:10 -07:00
|
|
|
|
|
|
|
#else
|
|
|
|
typedef struct cpumask cpumask_var_t[1];
|
|
|
|
|
|
|
|
static inline bool alloc_cpumask_var(cpumask_var_t *mask, gfp_t flags)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void alloc_bootmem_cpumask_var(cpumask_var_t *mask)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void free_cpumask_var(cpumask_var_t mask)
|
|
|
|
{
|
|
|
|
}
|
2008-11-06 17:12:29 -07:00
|
|
|
|
|
|
|
static inline void free_bootmem_cpumask_var(cpumask_var_t mask)
|
|
|
|
{
|
|
|
|
}
|
2008-11-04 19:39:10 -07:00
|
|
|
#endif /* CONFIG_CPUMASK_OFFSTACK */
|
|
|
|
|
|
|
|
/* The pointer versions of the maps, these will become the primary versions. */
|
|
|
|
#define cpu_possible_mask ((const struct cpumask *)&cpu_possible_map)
|
|
|
|
#define cpu_online_mask ((const struct cpumask *)&cpu_online_map)
|
|
|
|
#define cpu_present_mask ((const struct cpumask *)&cpu_present_map)
|
|
|
|
#define cpu_active_mask ((const struct cpumask *)&cpu_active_map)
|
|
|
|
|
|
|
|
/* It's common to want to use cpu_all_mask in struct member initializers,
|
|
|
|
* so it has to refer to an address rather than a pointer. */
|
|
|
|
extern const DECLARE_BITMAP(cpu_all_bits, NR_CPUS);
|
|
|
|
#define cpu_all_mask to_cpumask(cpu_all_bits)
|
|
|
|
|
|
|
|
/* First bits of cpu_bit_bitmap are in fact unset. */
|
|
|
|
#define cpu_none_mask to_cpumask(cpu_bit_bitmap[0])
|
|
|
|
|
|
|
|
/* Wrappers for arch boot code to manipulate normally-constant masks */
|
|
|
|
static inline void set_cpu_possible(unsigned int cpu, bool possible)
|
|
|
|
{
|
|
|
|
if (possible)
|
|
|
|
cpumask_set_cpu(cpu, &cpu_possible_map);
|
|
|
|
else
|
|
|
|
cpumask_clear_cpu(cpu, &cpu_possible_map);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void set_cpu_present(unsigned int cpu, bool present)
|
|
|
|
{
|
|
|
|
if (present)
|
|
|
|
cpumask_set_cpu(cpu, &cpu_present_map);
|
|
|
|
else
|
|
|
|
cpumask_clear_cpu(cpu, &cpu_present_map);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void set_cpu_online(unsigned int cpu, bool online)
|
|
|
|
{
|
|
|
|
if (online)
|
|
|
|
cpumask_set_cpu(cpu, &cpu_online_map);
|
|
|
|
else
|
|
|
|
cpumask_clear_cpu(cpu, &cpu_online_map);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void set_cpu_active(unsigned int cpu, bool active)
|
|
|
|
{
|
|
|
|
if (active)
|
|
|
|
cpumask_set_cpu(cpu, &cpu_active_map);
|
|
|
|
else
|
|
|
|
cpumask_clear_cpu(cpu, &cpu_active_map);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void init_cpu_present(const struct cpumask *src)
|
|
|
|
{
|
|
|
|
cpumask_copy(&cpu_present_map, src);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void init_cpu_possible(const struct cpumask *src)
|
|
|
|
{
|
|
|
|
cpumask_copy(&cpu_possible_map, src);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void init_cpu_online(const struct cpumask *src)
|
|
|
|
{
|
|
|
|
cpumask_copy(&cpu_online_map, src);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif /* __LINUX_CPUMASK_H */
|