Subversion Repositories Kolibri OS

Rev

Rev 6936 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. #ifndef __LINUX_CPUMASK_H
  2. #define __LINUX_CPUMASK_H
  3.  
  4. /*
  5.  * Cpumasks provide a bitmap suitable for representing the
  6.  * set of CPU's in a system, one bit position per CPU number.  In general,
  7.  * only nr_cpu_ids (<= NR_CPUS) bits are valid.
  8.  */
  9. #include <linux/kernel.h>
  10. #include <linux/threads.h>
  11. #include <linux/bitmap.h>
  12. #include <linux/bug.h>
  13.  
  14. /* Don't assign or return these: may not be this big! */
  15. typedef struct cpumask { DECLARE_BITMAP(bits, NR_CPUS); } cpumask_t;
  16.  
  17. /**
  18.  * cpumask_bits - get the bits in a cpumask
  19.  * @maskp: the struct cpumask *
  20.  *
  21.  * You should only assume nr_cpu_ids bits of this mask are valid.  This is
  22.  * a macro so it's const-correct.
  23.  */
  24. #define cpumask_bits(maskp) ((maskp)->bits)
  25.  
  26. /**
  27.  * cpumask_pr_args - printf args to output a cpumask
  28.  * @maskp: cpumask to be printed
  29.  *
  30.  * Can be used to provide arguments for '%*pb[l]' when printing a cpumask.
  31.  */
  32. #define cpumask_pr_args(maskp)          nr_cpu_ids, cpumask_bits(maskp)
  33.  
  34. #if NR_CPUS == 1
  35. #define nr_cpu_ids              1
  36. #else
  37. extern int nr_cpu_ids;
  38. #endif
  39.  
  40. #ifdef CONFIG_CPUMASK_OFFSTACK
  41. /* Assuming NR_CPUS is huge, a runtime limit is more efficient.  Also,
  42.  * not all bits may be allocated. */
  43. #define nr_cpumask_bits nr_cpu_ids
  44. #else
  45. #define nr_cpumask_bits NR_CPUS
  46. #endif
  47.  
  48. /*
  49.  * The following particular system cpumasks and operations manage
  50.  * possible, present, active and online cpus.
  51.  *
  52.  *     cpu_possible_mask- has bit 'cpu' set iff cpu is populatable
  53.  *     cpu_present_mask - has bit 'cpu' set iff cpu is populated
  54.  *     cpu_online_mask  - has bit 'cpu' set iff cpu available to scheduler
  55.  *     cpu_active_mask  - has bit 'cpu' set iff cpu available to migration
  56.  *
  57.  *  If !CONFIG_HOTPLUG_CPU, present == possible, and active == online.
  58.  *
  59.  *  The cpu_possible_mask is fixed at boot time, as the set of CPU id's
  60.  *  that it is possible might ever be plugged in at anytime during the
  61.  *  life of that system boot.  The cpu_present_mask is dynamic(*),
  62.  *  representing which CPUs are currently plugged in.  And
  63.  *  cpu_online_mask is the dynamic subset of cpu_present_mask,
  64.  *  indicating those CPUs available for scheduling.
  65.  *
  66.  *  If HOTPLUG is enabled, then cpu_possible_mask is forced to have
  67.  *  all NR_CPUS bits set, otherwise it is just the set of CPUs that
  68.  *  ACPI reports present at boot.
  69.  *
  70.  *  If HOTPLUG is enabled, then cpu_present_mask varies dynamically,
  71.  *  depending on what ACPI reports as currently plugged in, otherwise
  72.  *  cpu_present_mask is just a copy of cpu_possible_mask.
  73.  *
  74.  *  (*) Well, cpu_present_mask is dynamic in the hotplug case.  If not
  75.  *      hotplug, it's a copy of cpu_possible_mask, hence fixed at boot.
  76.  *
  77.  * Subtleties:
  78.  * 1) UP arch's (NR_CPUS == 1, CONFIG_SMP not defined) hardcode
  79.  *    assumption that their single CPU is online.  The UP
  80.  *    cpu_{online,possible,present}_masks are placebos.  Changing them
  81.  *    will have no useful affect on the following num_*_cpus()
  82.  *    and cpu_*() macros in the UP case.  This ugliness is a UP
  83.  *    optimization - don't waste any instructions or memory references
  84.  *    asking if you're online or how many CPUs there are if there is
  85.  *    only one CPU.
  86.  */
  87.  
  88. extern struct cpumask __cpu_possible_mask;
  89. extern struct cpumask __cpu_online_mask;
  90. extern struct cpumask __cpu_present_mask;
  91. extern struct cpumask __cpu_active_mask;
  92. #define cpu_possible_mask ((const struct cpumask *)&__cpu_possible_mask)
  93. #define cpu_online_mask   ((const struct cpumask *)&__cpu_online_mask)
  94. #define cpu_present_mask  ((const struct cpumask *)&__cpu_present_mask)
  95. #define cpu_active_mask   ((const struct cpumask *)&__cpu_active_mask)
  96.  
  97. #if NR_CPUS > 1
  98. #define num_online_cpus()       cpumask_weight(cpu_online_mask)
  99. #define num_possible_cpus()     cpumask_weight(cpu_possible_mask)
  100. #define num_present_cpus()      cpumask_weight(cpu_present_mask)
  101. #define num_active_cpus()       cpumask_weight(cpu_active_mask)
  102. #define cpu_online(cpu)         cpumask_test_cpu((cpu), cpu_online_mask)
  103. #define cpu_possible(cpu)       cpumask_test_cpu((cpu), cpu_possible_mask)
  104. #define cpu_present(cpu)        cpumask_test_cpu((cpu), cpu_present_mask)
  105. #define cpu_active(cpu)         cpumask_test_cpu((cpu), cpu_active_mask)
  106. #else
  107. #define num_online_cpus()       1U
  108. #define num_possible_cpus()     1U
  109. #define num_present_cpus()      1U
  110. #define num_active_cpus()       1U
  111. #define cpu_online(cpu)         ((cpu) == 0)
  112. #define cpu_possible(cpu)       ((cpu) == 0)
  113. #define cpu_present(cpu)        ((cpu) == 0)
  114. #define cpu_active(cpu)         ((cpu) == 0)
  115. #endif
  116.  
  117. /* verify cpu argument to cpumask_* operators */
  118. static inline unsigned int cpumask_check(unsigned int cpu)
  119. {
  120. #ifdef CONFIG_DEBUG_PER_CPU_MAPS
  121.         WARN_ON_ONCE(cpu >= nr_cpumask_bits);
  122. #endif /* CONFIG_DEBUG_PER_CPU_MAPS */
  123.         return cpu;
  124. }
  125.  
  126. #if NR_CPUS == 1
  127. /* Uniprocessor.  Assume all masks are "1". */
  128. static inline unsigned int cpumask_first(const struct cpumask *srcp)
  129. {
  130.         return 0;
  131. }
  132.  
  133. /* Valid inputs for n are -1 and 0. */
  134. static inline unsigned int cpumask_next(int n, const struct cpumask *srcp)
  135. {
  136.         return n+1;
  137. }
  138.  
  139. static inline unsigned int cpumask_next_zero(int n, const struct cpumask *srcp)
  140. {
  141.         return n+1;
  142. }
  143.  
  144. static inline unsigned int cpumask_next_and(int n,
  145.                                             const struct cpumask *srcp,
  146.                                             const struct cpumask *andp)
  147. {
  148.         return n+1;
  149. }
  150.  
  151. /* cpu must be a valid cpu, ie 0, so there's no other choice. */
  152. static inline unsigned int cpumask_any_but(const struct cpumask *mask,
  153.                                            unsigned int cpu)
  154. {
  155.         return 1;
  156. }
  157.  
  158. static inline unsigned int cpumask_local_spread(unsigned int i, int node)
  159. {
  160.         return 0;
  161. }
  162.  
  163. #define for_each_cpu(cpu, mask)                 \
  164.         for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask)
  165. #define for_each_cpu_not(cpu, mask)             \
  166.         for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask)
  167. #define for_each_cpu_and(cpu, mask, and)        \
  168.         for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask, (void)and)
  169. #else
  170. /**
  171.  * cpumask_first - get the first cpu in a cpumask
  172.  * @srcp: the cpumask pointer
  173.  *
  174.  * Returns >= nr_cpu_ids if no cpus set.
  175.  */
  176. static inline unsigned int cpumask_first(const struct cpumask *srcp)
  177. {
  178.         return find_first_bit(cpumask_bits(srcp), nr_cpumask_bits);
  179. }
  180.  
  181. /**
  182.  * cpumask_next - get the next cpu in a cpumask
  183.  * @n: the cpu prior to the place to search (ie. return will be > @n)
  184.  * @srcp: the cpumask pointer
  185.  *
  186.  * Returns >= nr_cpu_ids if no further cpus set.
  187.  */
  188. static inline unsigned int cpumask_next(int n, const struct cpumask *srcp)
  189. {
  190.         /* -1 is a legal arg here. */
  191.         if (n != -1)
  192.                 cpumask_check(n);
  193.         return find_next_bit(cpumask_bits(srcp), nr_cpumask_bits, n+1);
  194. }
  195.  
  196. /**
  197.  * cpumask_next_zero - get the next unset cpu in a cpumask
  198.  * @n: the cpu prior to the place to search (ie. return will be > @n)
  199.  * @srcp: the cpumask pointer
  200.  *
  201.  * Returns >= nr_cpu_ids if no further cpus unset.
  202.  */
  203. static inline unsigned int cpumask_next_zero(int n, const struct cpumask *srcp)
  204. {
  205.         /* -1 is a legal arg here. */
  206.         if (n != -1)
  207.                 cpumask_check(n);
  208.         return find_next_zero_bit(cpumask_bits(srcp), nr_cpumask_bits, n+1);
  209. }
  210.  
  211. int cpumask_next_and(int n, const struct cpumask *, const struct cpumask *);
  212. int cpumask_any_but(const struct cpumask *mask, unsigned int cpu);
  213. unsigned int cpumask_local_spread(unsigned int i, int node);
  214.  
  215. /**
  216.  * for_each_cpu - iterate over every cpu in a mask
  217.  * @cpu: the (optionally unsigned) integer iterator
  218.  * @mask: the cpumask pointer
  219.  *
  220.  * After the loop, cpu is >= nr_cpu_ids.
  221.  */
  222. #define for_each_cpu(cpu, mask)                         \
  223.         for ((cpu) = -1;                                \
  224.                 (cpu) = cpumask_next((cpu), (mask)),    \
  225.                 (cpu) < nr_cpu_ids;)
  226.  
  227. /**
  228.  * for_each_cpu_not - iterate over every cpu in a complemented mask
  229.  * @cpu: the (optionally unsigned) integer iterator
  230.  * @mask: the cpumask pointer
  231.  *
  232.  * After the loop, cpu is >= nr_cpu_ids.
  233.  */
  234. #define for_each_cpu_not(cpu, mask)                             \
  235.         for ((cpu) = -1;                                        \
  236.                 (cpu) = cpumask_next_zero((cpu), (mask)),       \
  237.                 (cpu) < nr_cpu_ids;)
  238.  
  239. /**
  240.  * for_each_cpu_and - iterate over every cpu in both masks
  241.  * @cpu: the (optionally unsigned) integer iterator
  242.  * @mask: the first cpumask pointer
  243.  * @and: the second cpumask pointer
  244.  *
  245.  * This saves a temporary CPU mask in many places.  It is equivalent to:
  246.  *      struct cpumask tmp;
  247.  *      cpumask_and(&tmp, &mask, &and);
  248.  *      for_each_cpu(cpu, &tmp)
  249.  *              ...
  250.  *
  251.  * After the loop, cpu is >= nr_cpu_ids.
  252.  */
  253. #define for_each_cpu_and(cpu, mask, and)                                \
  254.         for ((cpu) = -1;                                                \
  255.                 (cpu) = cpumask_next_and((cpu), (mask), (and)),         \
  256.                 (cpu) < nr_cpu_ids;)
  257. #endif /* SMP */
  258.  
  259. #define CPU_BITS_NONE                                           \
  260. {                                                               \
  261.         [0 ... BITS_TO_LONGS(NR_CPUS)-1] = 0UL                  \
  262. }
  263.  
  264. #define CPU_BITS_CPU0                                           \
  265. {                                                               \
  266.         [0] =  1UL                                              \
  267. }
  268.  
  269. /**
  270.  * cpumask_set_cpu - set a cpu in a cpumask
  271.  * @cpu: cpu number (< nr_cpu_ids)
  272.  * @dstp: the cpumask pointer
  273.  */
  274. static inline void cpumask_set_cpu(unsigned int cpu, struct cpumask *dstp)
  275. {
  276.         set_bit(cpumask_check(cpu), cpumask_bits(dstp));
  277. }
  278.  
  279. /**
  280.  * cpumask_clear_cpu - clear a cpu in a cpumask
  281.  * @cpu: cpu number (< nr_cpu_ids)
  282.  * @dstp: the cpumask pointer
  283.  */
  284. static inline void cpumask_clear_cpu(int cpu, struct cpumask *dstp)
  285. {
  286.         clear_bit(cpumask_check(cpu), cpumask_bits(dstp));
  287. }
  288.  
  289. /**
  290.  * cpumask_test_cpu - test for a cpu in a cpumask
  291.  * @cpu: cpu number (< nr_cpu_ids)
  292.  * @cpumask: the cpumask pointer
  293.  *
  294.  * Returns 1 if @cpu is set in @cpumask, else returns 0
  295.  */
  296. static inline int cpumask_test_cpu(int cpu, const struct cpumask *cpumask)
  297. {
  298.         return test_bit(cpumask_check(cpu), cpumask_bits((cpumask)));
  299. }
  300.  
  301. /**
  302.  * cpumask_test_and_set_cpu - atomically test and set a cpu in a cpumask
  303.  * @cpu: cpu number (< nr_cpu_ids)
  304.  * @cpumask: the cpumask pointer
  305.  *
  306.  * Returns 1 if @cpu is set in old bitmap of @cpumask, else returns 0
  307.  *
  308.  * test_and_set_bit wrapper for cpumasks.
  309.  */
  310. static inline int cpumask_test_and_set_cpu(int cpu, struct cpumask *cpumask)
  311. {
  312.         return test_and_set_bit(cpumask_check(cpu), cpumask_bits(cpumask));
  313. }
  314.  
  315. /**
  316.  * cpumask_test_and_clear_cpu - atomically test and clear a cpu in a cpumask
  317.  * @cpu: cpu number (< nr_cpu_ids)
  318.  * @cpumask: the cpumask pointer
  319.  *
  320.  * Returns 1 if @cpu is set in old bitmap of @cpumask, else returns 0
  321.  *
  322.  * test_and_clear_bit wrapper for cpumasks.
  323.  */
  324. static inline int cpumask_test_and_clear_cpu(int cpu, struct cpumask *cpumask)
  325. {
  326.         return test_and_clear_bit(cpumask_check(cpu), cpumask_bits(cpumask));
  327. }
  328.  
  329. /**
  330.  * cpumask_setall - set all cpus (< nr_cpu_ids) in a cpumask
  331.  * @dstp: the cpumask pointer
  332.  */
  333. static inline void cpumask_setall(struct cpumask *dstp)
  334. {
  335.         bitmap_fill(cpumask_bits(dstp), nr_cpumask_bits);
  336. }
  337.  
  338. /**
  339.  * cpumask_clear - clear all cpus (< nr_cpu_ids) in a cpumask
  340.  * @dstp: the cpumask pointer
  341.  */
  342. static inline void cpumask_clear(struct cpumask *dstp)
  343. {
  344.         bitmap_zero(cpumask_bits(dstp), nr_cpumask_bits);
  345. }
  346.  
  347. /**
  348.  * cpumask_and - *dstp = *src1p & *src2p
  349.  * @dstp: the cpumask result
  350.  * @src1p: the first input
  351.  * @src2p: the second input
  352.  *
  353.  * If *@dstp is empty, returns 0, else returns 1
  354.  */
  355. static inline int cpumask_and(struct cpumask *dstp,
  356.                                const struct cpumask *src1p,
  357.                                const struct cpumask *src2p)
  358. {
  359.         return bitmap_and(cpumask_bits(dstp), cpumask_bits(src1p),
  360.                                        cpumask_bits(src2p), nr_cpumask_bits);
  361. }
  362.  
  363. /**
  364.  * cpumask_or - *dstp = *src1p | *src2p
  365.  * @dstp: the cpumask result
  366.  * @src1p: the first input
  367.  * @src2p: the second input
  368.  */
  369. static inline void cpumask_or(struct cpumask *dstp, const struct cpumask *src1p,
  370.                               const struct cpumask *src2p)
  371. {
  372.         bitmap_or(cpumask_bits(dstp), cpumask_bits(src1p),
  373.                                       cpumask_bits(src2p), nr_cpumask_bits);
  374. }
  375.  
  376. /**
  377.  * cpumask_xor - *dstp = *src1p ^ *src2p
  378.  * @dstp: the cpumask result
  379.  * @src1p: the first input
  380.  * @src2p: the second input
  381.  */
  382. static inline void cpumask_xor(struct cpumask *dstp,
  383.                                const struct cpumask *src1p,
  384.                                const struct cpumask *src2p)
  385. {
  386.         bitmap_xor(cpumask_bits(dstp), cpumask_bits(src1p),
  387.                                        cpumask_bits(src2p), nr_cpumask_bits);
  388. }
  389.  
  390. /**
  391.  * cpumask_andnot - *dstp = *src1p & ~*src2p
  392.  * @dstp: the cpumask result
  393.  * @src1p: the first input
  394.  * @src2p: the second input
  395.  *
  396.  * If *@dstp is empty, returns 0, else returns 1
  397.  */
  398. static inline int cpumask_andnot(struct cpumask *dstp,
  399.                                   const struct cpumask *src1p,
  400.                                   const struct cpumask *src2p)
  401. {
  402.         return bitmap_andnot(cpumask_bits(dstp), cpumask_bits(src1p),
  403.                                           cpumask_bits(src2p), nr_cpumask_bits);
  404. }
  405.  
  406. /**
  407.  * cpumask_complement - *dstp = ~*srcp
  408.  * @dstp: the cpumask result
  409.  * @srcp: the input to invert
  410.  */
  411. static inline void cpumask_complement(struct cpumask *dstp,
  412.                                       const struct cpumask *srcp)
  413. {
  414.         bitmap_complement(cpumask_bits(dstp), cpumask_bits(srcp),
  415.                                               nr_cpumask_bits);
  416. }
  417.  
  418. /**
  419.  * cpumask_equal - *src1p == *src2p
  420.  * @src1p: the first input
  421.  * @src2p: the second input
  422.  */
  423. static inline bool cpumask_equal(const struct cpumask *src1p,
  424.                                 const struct cpumask *src2p)
  425. {
  426.         return bitmap_equal(cpumask_bits(src1p), cpumask_bits(src2p),
  427.                                                  nr_cpumask_bits);
  428. }
  429.  
  430. /**
  431.  * cpumask_intersects - (*src1p & *src2p) != 0
  432.  * @src1p: the first input
  433.  * @src2p: the second input
  434.  */
  435. static inline bool cpumask_intersects(const struct cpumask *src1p,
  436.                                      const struct cpumask *src2p)
  437. {
  438.         return bitmap_intersects(cpumask_bits(src1p), cpumask_bits(src2p),
  439.                                                       nr_cpumask_bits);
  440. }
  441.  
  442. /**
  443.  * cpumask_subset - (*src1p & ~*src2p) == 0
  444.  * @src1p: the first input
  445.  * @src2p: the second input
  446.  *
  447.  * Returns 1 if *@src1p is a subset of *@src2p, else returns 0
  448.  */
  449. static inline int cpumask_subset(const struct cpumask *src1p,
  450.                                  const struct cpumask *src2p)
  451. {
  452.         return bitmap_subset(cpumask_bits(src1p), cpumask_bits(src2p),
  453.                                                   nr_cpumask_bits);
  454. }
  455.  
  456. /**
  457.  * cpumask_empty - *srcp == 0
  458.  * @srcp: the cpumask to that all cpus < nr_cpu_ids are clear.
  459.  */
  460. static inline bool cpumask_empty(const struct cpumask *srcp)
  461. {
  462.         return bitmap_empty(cpumask_bits(srcp), nr_cpumask_bits);
  463. }
  464.  
  465. /**
  466.  * cpumask_full - *srcp == 0xFFFFFFFF...
  467.  * @srcp: the cpumask to that all cpus < nr_cpu_ids are set.
  468.  */
  469. static inline bool cpumask_full(const struct cpumask *srcp)
  470. {
  471.         return bitmap_full(cpumask_bits(srcp), nr_cpumask_bits);
  472. }
  473.  
  474. /**
  475.  * cpumask_weight - Count of bits in *srcp
  476.  * @srcp: the cpumask to count bits (< nr_cpu_ids) in.
  477.  */
  478. static inline unsigned int cpumask_weight(const struct cpumask *srcp)
  479. {
  480.         return bitmap_weight(cpumask_bits(srcp), nr_cpumask_bits);
  481. }
  482.  
  483. /**
  484.  * cpumask_shift_right - *dstp = *srcp >> n
  485.  * @dstp: the cpumask result
  486.  * @srcp: the input to shift
  487.  * @n: the number of bits to shift by
  488.  */
  489. static inline void cpumask_shift_right(struct cpumask *dstp,
  490.                                        const struct cpumask *srcp, int n)
  491. {
  492.         bitmap_shift_right(cpumask_bits(dstp), cpumask_bits(srcp), n,
  493.                                                nr_cpumask_bits);
  494. }
  495.  
  496. /**
  497.  * cpumask_shift_left - *dstp = *srcp << n
  498.  * @dstp: the cpumask result
  499.  * @srcp: the input to shift
  500.  * @n: the number of bits to shift by
  501.  */
  502. static inline void cpumask_shift_left(struct cpumask *dstp,
  503.                                       const struct cpumask *srcp, int n)
  504. {
  505.         bitmap_shift_left(cpumask_bits(dstp), cpumask_bits(srcp), n,
  506.                                               nr_cpumask_bits);
  507. }
  508.  
  509. /**
  510.  * cpumask_copy - *dstp = *srcp
  511.  * @dstp: the result
  512.  * @srcp: the input cpumask
  513.  */
  514. static inline void cpumask_copy(struct cpumask *dstp,
  515.                                 const struct cpumask *srcp)
  516. {
  517.         bitmap_copy(cpumask_bits(dstp), cpumask_bits(srcp), nr_cpumask_bits);
  518. }
  519.  
  520. /**
  521.  * cpumask_any - pick a "random" cpu from *srcp
  522.  * @srcp: the input cpumask
  523.  *
  524.  * Returns >= nr_cpu_ids if no cpus set.
  525.  */
  526. #define cpumask_any(srcp) cpumask_first(srcp)
  527.  
  528. /**
  529.  * cpumask_first_and - return the first cpu from *srcp1 & *srcp2
  530.  * @src1p: the first input
  531.  * @src2p: the second input
  532.  *
  533.  * Returns >= nr_cpu_ids if no cpus set in both.  See also cpumask_next_and().
  534.  */
  535. #define cpumask_first_and(src1p, src2p) cpumask_next_and(-1, (src1p), (src2p))
  536.  
  537. /**
  538.  * cpumask_any_and - pick a "random" cpu from *mask1 & *mask2
  539.  * @mask1: the first input cpumask
  540.  * @mask2: the second input cpumask
  541.  *
  542.  * Returns >= nr_cpu_ids if no cpus set.
  543.  */
  544. #define cpumask_any_and(mask1, mask2) cpumask_first_and((mask1), (mask2))
  545.  
  546. /**
  547.  * cpumask_of - the cpumask containing just a given cpu
  548.  * @cpu: the cpu (<= nr_cpu_ids)
  549.  */
  550. #define cpumask_of(cpu) (get_cpu_mask(cpu))
  551.  
  552. /**
  553.  * cpumask_parse_user - extract a cpumask from a user string
  554.  * @buf: the buffer to extract from
  555.  * @len: the length of the buffer
  556.  * @dstp: the cpumask to set.
  557.  *
  558.  * Returns -errno, or 0 for success.
  559.  */
  560. static inline int cpumask_parse_user(const char __user *buf, int len,
  561.                                      struct cpumask *dstp)
  562. {
  563.         return bitmap_parse_user(buf, len, cpumask_bits(dstp), nr_cpu_ids);
  564. }
  565.  
  566. /**
  567.  * cpumask_parselist_user - extract a cpumask from a user string
  568.  * @buf: the buffer to extract from
  569.  * @len: the length of the buffer
  570.  * @dstp: the cpumask to set.
  571.  *
  572.  * Returns -errno, or 0 for success.
  573.  */
  574. static inline int cpumask_parselist_user(const char __user *buf, int len,
  575.                                      struct cpumask *dstp)
  576. {
  577.         return bitmap_parselist_user(buf, len, cpumask_bits(dstp),
  578.                                      nr_cpu_ids);
  579. }
  580.  
  581. /**
  582.  * cpumask_parse - extract a cpumask from from a string
  583.  * @buf: the buffer to extract from
  584.  * @dstp: the cpumask to set.
  585.  *
  586.  * Returns -errno, or 0 for success.
  587.  */
  588. static inline int cpumask_parse(const char *buf, struct cpumask *dstp)
  589. {
  590.         char *nl = strchr(buf, '\n');
  591.         unsigned int len = nl ? (unsigned int)(nl - buf) : strlen(buf);
  592.  
  593.         return bitmap_parse(buf, len, cpumask_bits(dstp), nr_cpu_ids);
  594. }
  595.  
  596. /**
  597.  * cpulist_parse - extract a cpumask from a user string of ranges
  598.  * @buf: the buffer to extract from
  599.  * @dstp: the cpumask to set.
  600.  *
  601.  * Returns -errno, or 0 for success.
  602.  */
  603. static inline int cpulist_parse(const char *buf, struct cpumask *dstp)
  604. {
  605.         return bitmap_parselist(buf, cpumask_bits(dstp), nr_cpu_ids);
  606. }
  607.  
  608. /**
  609.  * cpumask_size - size to allocate for a 'struct cpumask' in bytes
  610.  */
  611. static inline size_t cpumask_size(void)
  612. {
  613.         return BITS_TO_LONGS(nr_cpumask_bits) * sizeof(long);
  614. }
  615.  
  616. /*
  617.  * cpumask_var_t: struct cpumask for stack usage.
  618.  *
  619.  * Oh, the wicked games we play!  In order to make kernel coding a
  620.  * little more difficult, we typedef cpumask_var_t to an array or a
  621.  * pointer: doing &mask on an array is a noop, so it still works.
  622.  *
  623.  * ie.
  624.  *      cpumask_var_t tmpmask;
  625.  *      if (!alloc_cpumask_var(&tmpmask, GFP_KERNEL))
  626.  *              return -ENOMEM;
  627.  *
  628.  *        ... use 'tmpmask' like a normal struct cpumask * ...
  629.  *
  630.  *      free_cpumask_var(tmpmask);
  631.  *
  632.  *
  633.  * However, one notable exception is there. alloc_cpumask_var() allocates
  634.  * only nr_cpumask_bits bits (in the other hand, real cpumask_t always has
  635.  * NR_CPUS bits). Therefore you don't have to dereference cpumask_var_t.
  636.  *
  637.  *      cpumask_var_t tmpmask;
  638.  *      if (!alloc_cpumask_var(&tmpmask, GFP_KERNEL))
  639.  *              return -ENOMEM;
  640.  *
  641.  *      var = *tmpmask;
  642.  *
  643.  * This code makes NR_CPUS length memcopy and brings to a memory corruption.
  644.  * cpumask_copy() provide safe copy functionality.
  645.  *
  646.  * Note that there is another evil here: If you define a cpumask_var_t
  647.  * as a percpu variable then the way to obtain the address of the cpumask
  648.  * structure differently influences what this_cpu_* operation needs to be
  649.  * used. Please use this_cpu_cpumask_var_t in those cases. The direct use
  650.  * of this_cpu_ptr() or this_cpu_read() will lead to failures when the
  651.  * other type of cpumask_var_t implementation is configured.
  652.  */
  653. #ifdef CONFIG_CPUMASK_OFFSTACK
  654. typedef struct cpumask *cpumask_var_t;
  655.  
  656. #define this_cpu_cpumask_var_ptr(x) this_cpu_read(x)
  657.  
  658. bool alloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags, int node);
  659. bool alloc_cpumask_var(cpumask_var_t *mask, gfp_t flags);
  660. bool zalloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags, int node);
  661. bool zalloc_cpumask_var(cpumask_var_t *mask, gfp_t flags);
  662. void alloc_bootmem_cpumask_var(cpumask_var_t *mask);
  663. void free_cpumask_var(cpumask_var_t mask);
  664. void free_bootmem_cpumask_var(cpumask_var_t mask);
  665.  
  666. #else
  667. typedef struct cpumask cpumask_var_t[1];
  668.  
  669. #define this_cpu_cpumask_var_ptr(x) this_cpu_ptr(x)
  670.  
  671. static inline bool alloc_cpumask_var(cpumask_var_t *mask, gfp_t flags)
  672. {
  673.         return true;
  674. }
  675.  
  676. static inline bool alloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags,
  677.                                           int node)
  678. {
  679.         return true;
  680. }
  681.  
  682. static inline bool zalloc_cpumask_var(cpumask_var_t *mask, gfp_t flags)
  683. {
  684.         cpumask_clear(*mask);
  685.         return true;
  686. }
  687.  
  688. static inline bool zalloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags,
  689.                                           int node)
  690. {
  691.         cpumask_clear(*mask);
  692.         return true;
  693. }
  694.  
  695. static inline void alloc_bootmem_cpumask_var(cpumask_var_t *mask)
  696. {
  697. }
  698.  
  699. static inline void free_cpumask_var(cpumask_var_t mask)
  700. {
  701. }
  702.  
  703. static inline void free_bootmem_cpumask_var(cpumask_var_t mask)
  704. {
  705. }
  706. #endif /* CONFIG_CPUMASK_OFFSTACK */
  707.  
  708. /* It's common to want to use cpu_all_mask in struct member initializers,
  709.  * so it has to refer to an address rather than a pointer. */
  710. extern const DECLARE_BITMAP(cpu_all_bits, NR_CPUS);
  711. #define cpu_all_mask to_cpumask(cpu_all_bits)
  712.  
  713. /* First bits of cpu_bit_bitmap are in fact unset. */
  714. #define cpu_none_mask to_cpumask(cpu_bit_bitmap[0])
  715.  
  716. #define for_each_possible_cpu(cpu) for_each_cpu((cpu), cpu_possible_mask)
  717. #define for_each_online_cpu(cpu)   for_each_cpu((cpu), cpu_online_mask)
  718. #define for_each_present_cpu(cpu)  for_each_cpu((cpu), cpu_present_mask)
  719.  
  720. /* Wrappers for arch boot code to manipulate normally-constant masks */
  721. void init_cpu_present(const struct cpumask *src);
  722. void init_cpu_possible(const struct cpumask *src);
  723. void init_cpu_online(const struct cpumask *src);
  724.  
  725. static inline void
  726. set_cpu_possible(unsigned int cpu, bool possible)
  727. {
  728.         if (possible)
  729.                 cpumask_set_cpu(cpu, &__cpu_possible_mask);
  730.         else
  731.                 cpumask_clear_cpu(cpu, &__cpu_possible_mask);
  732. }
  733.  
  734. static inline void
  735. set_cpu_present(unsigned int cpu, bool present)
  736. {
  737.         if (present)
  738.                 cpumask_set_cpu(cpu, &__cpu_present_mask);
  739.         else
  740.                 cpumask_clear_cpu(cpu, &__cpu_present_mask);
  741. }
  742.  
  743. static inline void
  744. set_cpu_online(unsigned int cpu, bool online)
  745. {
  746.         if (online) {
  747.                 cpumask_set_cpu(cpu, &__cpu_online_mask);
  748.                 cpumask_set_cpu(cpu, &__cpu_active_mask);
  749.         } else {
  750.                 cpumask_clear_cpu(cpu, &__cpu_online_mask);
  751.         }
  752. }
  753.  
  754. static inline void
  755. set_cpu_active(unsigned int cpu, bool active)
  756. {
  757.         if (active)
  758.                 cpumask_set_cpu(cpu, &__cpu_active_mask);
  759.         else
  760.                 cpumask_clear_cpu(cpu, &__cpu_active_mask);
  761. }
  762.  
  763.  
  764. /**
  765.  * to_cpumask - convert an NR_CPUS bitmap to a struct cpumask *
  766.  * @bitmap: the bitmap
  767.  *
  768.  * There are a few places where cpumask_var_t isn't appropriate and
  769.  * static cpumasks must be used (eg. very early boot), yet we don't
  770.  * expose the definition of 'struct cpumask'.
  771.  *
  772.  * This does the conversion, and can be used as a constant initializer.
  773.  */
  774. #define to_cpumask(bitmap)                                              \
  775.         ((struct cpumask *)(1 ? (bitmap)                                \
  776.                             : (void *)sizeof(__check_is_bitmap(bitmap))))
  777.  
  778. static inline int __check_is_bitmap(const unsigned long *bitmap)
  779. {
  780.         return 1;
  781. }
  782.  
  783. /*
  784.  * Special-case data structure for "single bit set only" constant CPU masks.
  785.  *
  786.  * We pre-generate all the 64 (or 32) possible bit positions, with enough
  787.  * padding to the left and the right, and return the constant pointer
  788.  * appropriately offset.
  789.  */
  790. extern const unsigned long
  791.         cpu_bit_bitmap[BITS_PER_LONG+1][BITS_TO_LONGS(NR_CPUS)];
  792.  
  793. static inline const struct cpumask *get_cpu_mask(unsigned int cpu)
  794. {
  795.         const unsigned long *p = cpu_bit_bitmap[1 + cpu % BITS_PER_LONG];
  796.         p -= cpu / BITS_PER_LONG;
  797.         return to_cpumask(p);
  798. }
  799.  
  800. #define cpu_is_offline(cpu)     unlikely(!cpu_online(cpu))
  801.  
  802. #if NR_CPUS <= BITS_PER_LONG
  803. #define CPU_BITS_ALL                                            \
  804. {                                                               \
  805.         [BITS_TO_LONGS(NR_CPUS)-1] = BITMAP_LAST_WORD_MASK(NR_CPUS)     \
  806. }
  807.  
  808. #else /* NR_CPUS > BITS_PER_LONG */
  809.  
  810. #define CPU_BITS_ALL                                            \
  811. {                                                               \
  812.         [0 ... BITS_TO_LONGS(NR_CPUS)-2] = ~0UL,                \
  813.         [BITS_TO_LONGS(NR_CPUS)-1] = BITMAP_LAST_WORD_MASK(NR_CPUS)     \
  814. }
  815. #endif /* NR_CPUS > BITS_PER_LONG */
  816.  
  817. /**
  818.  * cpumap_print_to_pagebuf  - copies the cpumask into the buffer either
  819.  *      as comma-separated list of cpus or hex values of cpumask
  820.  * @list: indicates whether the cpumap must be list
  821.  * @mask: the cpumask to copy
  822.  * @buf: the buffer to copy into
  823.  *
  824.  * Returns the length of the (null-terminated) @buf string, zero if
  825.  * nothing is copied.
  826.  */
  827. static inline ssize_t
  828. cpumap_print_to_pagebuf(bool list, char *buf, const struct cpumask *mask)
  829. {
  830.         return bitmap_print_to_pagebuf(list, buf, cpumask_bits(mask),
  831.                                       nr_cpu_ids);
  832. }
  833.  
  834. #if NR_CPUS <= BITS_PER_LONG
  835. #define CPU_MASK_ALL                                                    \
  836. (cpumask_t) { {                                                         \
  837.         [BITS_TO_LONGS(NR_CPUS)-1] = BITMAP_LAST_WORD_MASK(NR_CPUS)     \
  838. } }
  839. #else
  840. #define CPU_MASK_ALL                                                    \
  841. (cpumask_t) { {                                                         \
  842.         [0 ... BITS_TO_LONGS(NR_CPUS)-2] = ~0UL,                        \
  843.         [BITS_TO_LONGS(NR_CPUS)-1] = BITMAP_LAST_WORD_MASK(NR_CPUS)     \
  844. } }
  845. #endif /* NR_CPUS > BITS_PER_LONG */
  846.  
  847. #define CPU_MASK_NONE                                                   \
  848. (cpumask_t) { {                                                         \
  849.         [0 ... BITS_TO_LONGS(NR_CPUS)-1] =  0UL                         \
  850. } }
  851.  
  852. #define CPU_MASK_CPU0                                                   \
  853. (cpumask_t) { {                                                         \
  854.         [0] =  1UL                                                      \
  855. } }
  856.  
  857. #endif /* __LINUX_CPUMASK_H */
  858.