XenevaOS
Loading...
Searching...
No Matches
Classes | Macros | Enumerations | Variables
nodemask.h File Reference
#include <linux/threads.h>
#include <linux/bitmap.h>
#include <linux/minmax.h>
#include <linux/nodemask_types.h>
#include <linux/random.h>
Include dependency graph for nodemask.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  nodemask_scratch
 

Macros

#define nodemask_pr_args(maskp)
 
#define node_set(node, dst)   __node_set((node), &(dst))
 
#define node_clear(node, dst)   __node_clear((node), &(dst))
 
#define nodes_setall(dst)   __nodes_setall(&(dst), MAX_NUMNODES)
 
#define nodes_clear(dst)   __nodes_clear(&(dst), MAX_NUMNODES)
 
#define node_isset(node, nodemask)   test_bit((node), (nodemask).bits)
 
#define node_test_and_set(node, nodemask)    __node_test_and_set((node), &(nodemask))
 
#define nodes_and(dst, src1, src2)    __nodes_and(&(dst), &(src1), &(src2), MAX_NUMNODES)
 
#define nodes_or(dst, src1, src2)    __nodes_or(&(dst), &(src1), &(src2), MAX_NUMNODES)
 
#define nodes_xor(dst, src1, src2)    __nodes_xor(&(dst), &(src1), &(src2), MAX_NUMNODES)
 
#define nodes_andnot(dst, src1, src2)    __nodes_andnot(&(dst), &(src1), &(src2), MAX_NUMNODES)
 
#define nodes_copy(dst, src)   __nodes_copy(&(dst), &(src), MAX_NUMNODES)
 
#define nodes_complement(dst, src)    __nodes_complement(&(dst), &(src), MAX_NUMNODES)
 
#define nodes_equal(src1, src2)    __nodes_equal(&(src1), &(src2), MAX_NUMNODES)
 
#define nodes_intersects(src1, src2)    __nodes_intersects(&(src1), &(src2), MAX_NUMNODES)
 
#define nodes_subset(src1, src2)    __nodes_subset(&(src1), &(src2), MAX_NUMNODES)
 
#define nodes_empty(src)   __nodes_empty(&(src), MAX_NUMNODES)
 
#define nodes_full(nodemask)   __nodes_full(&(nodemask), MAX_NUMNODES)
 
#define nodes_weight(nodemask)   __nodes_weight(&(nodemask), MAX_NUMNODES)
 
#define first_node(src)   __first_node(&(src))
 
#define next_node(n, src)   __next_node((n), &(src))
 
#define next_node_in(n, src)   __next_node_in((n), &(src))
 
#define nodemask_of_node(node)
 
#define first_unset_node(mask)   __first_unset_node(&(mask))
 
#define NODE_MASK_LAST_WORD   BITMAP_LAST_WORD_MASK(MAX_NUMNODES)
 
#define NODE_MASK_ALL
 
#define NODE_MASK_NONE
 
#define nodes_addr(src)   ((src).bits)
 
#define nodemask_parse_user(ubuf, ulen, dst)    __nodemask_parse_user((ubuf), (ulen), &(dst), MAX_NUMNODES)
 
#define nodelist_parse(buf, dst)   __nodelist_parse((buf), &(dst), MAX_NUMNODES)
 
#define node_remap(oldbit, old, new)    __node_remap((oldbit), &(old), &(new), MAX_NUMNODES)
 
#define nodes_remap(dst, src, old, new)    __nodes_remap(&(dst), &(src), &(old), &(new), MAX_NUMNODES)
 
#define nodes_onto(dst, orig, relmap)    __nodes_onto(&(dst), &(orig), &(relmap), MAX_NUMNODES)
 
#define nodes_fold(dst, orig, sz)    __nodes_fold(&(dst), &(orig), sz, MAX_NUMNODES)
 
#define for_each_node_mask(node, mask)    for ((node) = 0; (node) < 1 && !nodes_empty(mask); (node)++)
 
#define for_each_node_state(node, __state)    for ( (node) = 0; (node) == 0; (node) = 1)
 
#define first_online_node   0
 
#define first_memory_node   0
 
#define next_online_node(nid)   (MAX_NUMNODES)
 
#define next_memory_node(nid)   (MAX_NUMNODES)
 
#define nr_node_ids   1U
 
#define nr_online_nodes   1U
 
#define node_set_online(node)   node_set_state((node), N_ONLINE)
 
#define node_set_offline(node)   node_clear_state((node), N_ONLINE)
 
#define node_online_map   node_states[N_ONLINE]
 
#define node_possible_map   node_states[N_POSSIBLE]
 
#define num_online_nodes()   num_node_state(N_ONLINE)
 
#define num_possible_nodes()   num_node_state(N_POSSIBLE)
 
#define node_online(node)   node_state((node), N_ONLINE)
 
#define node_possible(node)   node_state((node), N_POSSIBLE)
 
#define for_each_node(node)   for_each_node_state(node, N_POSSIBLE)
 
#define for_each_online_node(node)   for_each_node_state(node, N_ONLINE)
 
#define for_each_node_with_cpus(node)   for_each_node_state(node, N_CPU)
 
#define NODEMASK_ALLOC(type, name, gfp_flags)   type _##name, *name = &_##name
 
#define NODEMASK_FREE(m)   do {} while (0)
 
#define NODEMASK_SCRATCH(x)
 
#define NODEMASK_SCRATCH_FREE(x)   NODEMASK_FREE(x)
 

Enumerations

enum  node_states {
  N_POSSIBLE , N_ONLINE , N_NORMAL_MEMORY , N_HIGH_MEMORY = N_NORMAL_MEMORY ,
  N_MEMORY , N_CPU , N_GENERIC_INITIATOR , NR_NODE_STATES
}
 

Variables

nodemask_t _unused_nodemask_arg_
 
nodemask_t node_states [NR_NODE_STATES]
 

Macro Definition Documentation

◆ first_memory_node

#define first_memory_node   0

◆ first_node

#define first_node (   src)    __first_node(&(src))

◆ first_online_node

#define first_online_node   0

◆ first_unset_node

#define first_unset_node (   mask)    __first_unset_node(&(mask))

◆ for_each_node

#define for_each_node (   node)    for_each_node_state(node, N_POSSIBLE)

◆ for_each_node_mask

#define for_each_node_mask (   node,
  mask 
)     for ((node) = 0; (node) < 1 && !nodes_empty(mask); (node)++)

◆ for_each_node_state

#define for_each_node_state (   node,
  __state 
)     for ( (node) = 0; (node) == 0; (node) = 1)

◆ for_each_node_with_cpus

#define for_each_node_with_cpus (   node)    for_each_node_state(node, N_CPU)

◆ for_each_online_node

#define for_each_online_node (   node)    for_each_node_state(node, N_ONLINE)

◆ next_memory_node

#define next_memory_node (   nid)    (MAX_NUMNODES)

◆ next_node

#define next_node (   n,
  src 
)    __next_node((n), &(src))

◆ next_node_in

#define next_node_in (   n,
  src 
)    __next_node_in((n), &(src))

◆ next_online_node

#define next_online_node (   nid)    (MAX_NUMNODES)

◆ node_clear

#define node_clear (   node,
  dst 
)    __node_clear((node), &(dst))

◆ node_isset

#define node_isset (   node,
  nodemask 
)    test_bit((node), (nodemask).bits)

◆ NODE_MASK_ALL

#define NODE_MASK_ALL
Value:
((nodemask_t) { { \
[BITS_TO_LONGS(MAX_NUMNODES)-1] = NODE_MASK_LAST_WORD \
} })
BITS_TO_LONGS
#define BITS_TO_LONGS(nr)
Definition bordoisila_bits.h:39
NODE_MASK_LAST_WORD
#define NODE_MASK_LAST_WORD
Definition nodemask.h:299
MAX_NUMNODES
#define MAX_NUMNODES
Definition nodemask_types.h:13
nodemask_t
Definition nodemask_types.h:17

◆ NODE_MASK_LAST_WORD

#define NODE_MASK_LAST_WORD   BITMAP_LAST_WORD_MASK(MAX_NUMNODES)

◆ NODE_MASK_NONE

#define NODE_MASK_NONE
Value:
((nodemask_t) { { \
[0 ... BITS_TO_LONGS(MAX_NUMNODES)-1] = 0UL \
} })
UL
#define UL(x)
Definition const.h:78

◆ node_online

#define node_online (   node)    node_state((node), N_ONLINE)

◆ node_online_map

#define node_online_map   node_states[N_ONLINE]

◆ node_possible

#define node_possible (   node)    node_state((node), N_POSSIBLE)

◆ node_possible_map

#define node_possible_map   node_states[N_POSSIBLE]

◆ node_remap

#define node_remap (   oldbit,
  old,
  new 
)     __node_remap((oldbit), &(old), &(new), MAX_NUMNODES)

◆ node_set

#define node_set (   node,
  dst 
)    __node_set((node), &(dst))

◆ node_set_offline

#define node_set_offline (   node)    node_clear_state((node), N_ONLINE)

◆ node_set_online

#define node_set_online (   node)    node_set_state((node), N_ONLINE)

◆ node_test_and_set

#define node_test_and_set (   node,
  nodemask 
)     __node_test_and_set((node), &(nodemask))

◆ nodelist_parse

#define nodelist_parse (   buf,
  dst 
)    __nodelist_parse((buf), &(dst), MAX_NUMNODES)

◆ NODEMASK_ALLOC

#define NODEMASK_ALLOC (   type,
  name,
  gfp_flags 
)    type _##name, *name = &_##name

◆ NODEMASK_FREE

#define NODEMASK_FREE (   m)    do {} while (0)

◆ nodemask_of_node

#define nodemask_of_node (   node)
Value:
({ \
typeof(_unused_nodemask_arg_) m; \
if (sizeof(m) == sizeof(unsigned long)) { \
m.bits[0] = 1UL << (node); \
} else { \
init_nodemask_of_node(&m, (node)); \
} \
m; \
})
node
void int node
Definition kthread.h:31
_unused_nodemask_arg_
nodemask_t _unused_nodemask_arg_

◆ nodemask_parse_user

#define nodemask_parse_user (   ubuf,
  ulen,
  dst 
)     __nodemask_parse_user((ubuf), (ulen), &(dst), MAX_NUMNODES)

◆ nodemask_pr_args

#define nodemask_pr_args (   maskp)
Value:
__nodemask_pr_numnodes(maskp), \
__nodemask_pr_bits(maskp)

nodemask_pr_args - printf args to output a nodemask @maskp: nodemask to be printed

Can be used to provide arguments for '%*pb[l]' when printing a nodemask.

◆ NODEMASK_SCRATCH

#define NODEMASK_SCRATCH (   x)
Value:
NODEMASK_ALLOC(struct nodemask_scratch, x, \
GFP_KERNEL | __GFP_NORETRY)
__GFP_NORETRY
#define __GFP_NORETRY
Definition gfp_types.h:262
GFP_KERNEL
#define GFP_KERNEL
Definition gfp_types.h:377
NODEMASK_ALLOC
#define NODEMASK_ALLOC(type, name, gfp_flags)
Definition nodemask.h:524
nodemask_scratch
Definition nodemask.h:529

◆ NODEMASK_SCRATCH_FREE

#define NODEMASK_SCRATCH_FREE (   x)    NODEMASK_FREE(x)

◆ nodes_addr

#define nodes_addr (   src)    ((src).bits)

◆ nodes_and

#define nodes_and (   dst,
  src1,
  src2 
)     __nodes_and(&(dst), &(src1), &(src2), MAX_NUMNODES)

◆ nodes_andnot

#define nodes_andnot (   dst,
  src1,
  src2 
)     __nodes_andnot(&(dst), &(src1), &(src2), MAX_NUMNODES)

◆ nodes_clear

#define nodes_clear (   dst)    __nodes_clear(&(dst), MAX_NUMNODES)

◆ nodes_complement

#define nodes_complement (   dst,
  src 
)     __nodes_complement(&(dst), &(src), MAX_NUMNODES)

◆ nodes_copy

#define nodes_copy (   dst,
  src 
)    __nodes_copy(&(dst), &(src), MAX_NUMNODES)

◆ nodes_empty

#define nodes_empty (   src)    __nodes_empty(&(src), MAX_NUMNODES)

◆ nodes_equal

#define nodes_equal (   src1,
  src2 
)     __nodes_equal(&(src1), &(src2), MAX_NUMNODES)

◆ nodes_fold

#define nodes_fold (   dst,
  orig,
  sz 
)     __nodes_fold(&(dst), &(orig), sz, MAX_NUMNODES)

◆ nodes_full

#define nodes_full (   nodemask)    __nodes_full(&(nodemask), MAX_NUMNODES)

◆ nodes_intersects

#define nodes_intersects (   src1,
  src2 
)     __nodes_intersects(&(src1), &(src2), MAX_NUMNODES)

◆ nodes_onto

#define nodes_onto (   dst,
  orig,
  relmap 
)     __nodes_onto(&(dst), &(orig), &(relmap), MAX_NUMNODES)

◆ nodes_or

#define nodes_or (   dst,
  src1,
  src2 
)     __nodes_or(&(dst), &(src1), &(src2), MAX_NUMNODES)

◆ nodes_remap

#define nodes_remap (   dst,
  src,
  old,
  new 
)     __nodes_remap(&(dst), &(src), &(old), &(new), MAX_NUMNODES)

◆ nodes_setall

#define nodes_setall (   dst)    __nodes_setall(&(dst), MAX_NUMNODES)

◆ nodes_subset

#define nodes_subset (   src1,
  src2 
)     __nodes_subset(&(src1), &(src2), MAX_NUMNODES)

◆ nodes_weight

#define nodes_weight (   nodemask)    __nodes_weight(&(nodemask), MAX_NUMNODES)

◆ nodes_xor

#define nodes_xor (   dst,
  src1,
  src2 
)     __nodes_xor(&(dst), &(src1), &(src2), MAX_NUMNODES)

◆ nr_node_ids

#define nr_node_ids   1U

◆ nr_online_nodes

#define nr_online_nodes   1U

◆ num_online_nodes

#define num_online_nodes ( )    num_node_state(N_ONLINE)

◆ num_possible_nodes

#define num_possible_nodes ( )    num_node_state(N_POSSIBLE)

Enumeration Type Documentation

◆ node_states

enum node_states
Enumerator
N_POSSIBLE 
N_ONLINE 
N_NORMAL_MEMORY 
N_HIGH_MEMORY 
N_MEMORY 
N_CPU 
N_GENERIC_INITIATOR 
NR_NODE_STATES 

Variable Documentation

◆ _unused_nodemask_arg_

nodemask_t _unused_nodemask_arg_
extern

◆ node_states

nodemask_t node_states[NR_NODE_STATES]
extern
Generated by doxygen 1.9.8