include/linux/cpumask.h

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