kvm/kernel/external-module-compat-comm.h

   1
   2 /*
   3  * Compatibility header for building as an external module.
   4  */
   5
   6 /*
   7  * Avoid picking up the kernel's kvm.h in case we have a newer one.
   8  */
   9
  10 #include <linux/compiler.h>
  11 #include <linux/version.h>
  12 #include <linux/string.h>
  13 #include <linux/kvm.h>
  14 #include <linux/kvm_para.h>
  15 #include <linux/cpu.h>
  16 #include <linux/time.h>
  17 #include <asm/processor.h>
  18 #include <linux/hrtimer.h>
  19 #include <asm/bitops.h>
  20
  21 /* Override CONFIG_KVM_TRACE */
  22 #ifdef EXT_CONFIG_KVM_TRACE
  23 #  define CONFIG_KVM_TRACE 1
  24 #else
  25 #  undef CONFIG_KVM_TRACE
  26 #endif
  27
  28 /*
  29  * 2.6.16 does not have GFP_NOWAIT
  30  */
  31
  32 #include <linux/gfp.h>
  33
  34 #ifndef GFP_NOWAIT
  35 #define GFP_NOWAIT (GFP_ATOMIC & ~__GFP_HIGH)
  36 #endif
  37
  38
  39 /*
  40  * kvm profiling support needs 2.6.20
  41  */
  42 #include <linux/profile.h>
  43
  44 #ifndef KVM_PROFILING
  45 #define KVM_PROFILING 1234
  46 #define prof_on       4321
  47 #endif
  48
  49 /*
  50  * smp_call_function_single() is not exported below 2.6.20, and has different
  51  * semantics below 2.6.23.  The 'nonatomic' argument was removed in 2.6.27.
  52  */
  53 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)
  54
  55 int kvm_smp_call_function_single(int cpu, void (*func)(void *info),
  56                                  void *info, int wait);
  57 #undef smp_call_function_single
  58 #define smp_call_function_single kvm_smp_call_function_single
  59
  60 #endif
  61
  62 /* on_each_cpu() lost an argument in 2.6.27. */
  63 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)
  64
  65 #define kvm_on_each_cpu(func, info, wait) on_each_cpu(func, info, 0, wait)
  66
  67 #else
  68
  69 #define kvm_on_each_cpu(func, info, wait) on_each_cpu(func, info, wait)
  70
  71 #endif
  72
  73 /*
  74  * The cpu hotplug stubs are broken if !CONFIG_CPU_HOTPLUG
  75  */
  76
  77 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,15)
  78 #define DEFINE_MUTEX(a) DECLARE_MUTEX(a)
  79 #define mutex_lock_interruptible(a) down_interruptible(a)
  80 #define mutex_unlock(a) up(a)
  81 #define mutex_lock(a) down(a)
  82 #define mutex_init(a) init_MUTEX(a)
  83 #define mutex_trylock(a) down_trylock(a)
  84 #define mutex semaphore
  85 #endif
  86
  87 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14)
  88 #ifndef kzalloc
  89 #define kzalloc(size,flags)                     \
  90 ({                                              \
  91         void *__ret = kmalloc(size, flags);     \
  92         if (__ret)                              \
  93                 memset(__ret, 0, size);         \
  94         __ret;                                  \
  95 })
  96 #endif
  97 #endif
  98
  99 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,17)
 100 #ifndef kmem_cache_zalloc
 101 #define kmem_cache_zalloc(cache,flags)                    \
 102 ({                                                        \
 103         void *__ret = kmem_cache_alloc(cache, flags);     \
 104         if (__ret)                                        \
 105                 memset(__ret, 0, kmem_cache_size(cache)); \
 106         __ret;                                            \
 107 })
 108 #endif
 109 #endif
 110
 111 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)
 112
 113 #ifndef CONFIG_HOTPLUG_CPU
 114 #define register_cpu_notifier(nb) (0)
 115 #endif
 116
 117 #endif
 118
 119 #include <linux/miscdevice.h>
 120 #ifndef KVM_MINOR
 121 #define KVM_MINOR 232
 122 #endif
 123
 124 #include <linux/notifier.h>
 125 #ifndef CPU_TASKS_FROZEN
 126
 127 #define CPU_TASKS_FROZEN       0x0010
 128 #define CPU_ONLINE_FROZEN      (CPU_ONLINE | CPU_TASKS_FROZEN)
 129 #define CPU_UP_PREPARE_FROZEN  (CPU_UP_PREPARE | CPU_TASKS_FROZEN)
 130 #define CPU_UP_CANCELED_FROZEN (CPU_UP_CANCELED | CPU_TASKS_FROZEN)
 131 #define CPU_DOWN_PREPARE_FROZEN        (CPU_DOWN_PREPARE | CPU_TASKS_FROZEN)
 132 #define CPU_DOWN_FAILED_FROZEN (CPU_DOWN_FAILED | CPU_TASKS_FROZEN)
 133 #define CPU_DEAD_FROZEN                (CPU_DEAD | CPU_TASKS_FROZEN)
 134
 135 #endif
 136
 137 #ifndef CPU_DYING
 138 #define CPU_DYING 0x000A
 139 #define CPU_DYING_FROZEN (CPU_DYING | CPU_TASKS_FROZEN)
 140 #endif
 141
 142 #include <asm/system.h>
 143
 144 struct inode;
 145 #include <linux/anon_inodes.h>
 146 #define anon_inode_getfd kvm_anon_inode_getfd
 147 int kvm_init_anon_inodes(void);
 148 void kvm_exit_anon_inodes(void);
 149 int anon_inode_getfd(const char *name,
 150                      const struct file_operations *fops,
 151                      void *priv , int flags);
 152
 153 /*
 154  * 2.6.23 removed the cache destructor
 155  */
 156 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 157 #  define kmem_cache_create(name, size, align, flags, ctor) \
 158         kmem_cache_create(name, size, align, flags, ctor, NULL)
 159 #endif
 160
 161 /* HRTIMER_MODE_ABS started life with a different name */
 162 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)
 163 #define HRTIMER_MODE_ABS HRTIMER_ABS
 164 #endif
 165
 166 /* div64_u64 is fairly new */
 167 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26)
 168
 169 #define div64_u64 kvm_div64_u64
 170
 171 #ifdef CONFIG_64BIT
 172
 173 static inline uint64_t div64_u64(uint64_t dividend, uint64_t divisor)
 174 {
 175         return dividend / divisor;
 176 }
 177
 178 #else
 179
 180 uint64_t div64_u64(uint64_t dividend, uint64_t divisor);
 181
 182 #endif
 183
 184 #endif
 185
 186 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
 187
 188 #ifdef RHEL_RELEASE_CODE
 189 #if RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(5,2)
 190 #define RHEL_BOOL 1
 191 #endif
 192 #endif
 193
 194 #ifndef RHEL_BOOL
 195
 196 typedef _Bool bool;
 197
 198 #endif
 199
 200 #endif
 201
 202 /*
 203  * PF_VCPU is a Linux 2.6.24 addition
 204  */
 205
 206 #include <linux/sched.h>
 207
 208 #ifndef PF_VCPU
 209 #define PF_VCPU 0
 210 #endif
 211
 212 /*
 213  * smp_call_function_mask() is not defined/exported below 2.6.24
 214  */
 215
 216 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 217
 218 int kvm_smp_call_function_mask(cpumask_t mask, void (*func) (void *info),
 219                                void *info, int wait);
 220
 221 #define smp_call_function_mask kvm_smp_call_function_mask
 222
 223 #endif
 224
 225 /* empty_zero_page isn't exported in all kernels */
 226 #include <asm/pgtable.h>
 227
 228 #define empty_zero_page kvm_empty_zero_page
 229
 230 static char empty_zero_page[PAGE_SIZE];
 231
 232 static inline void blahblah(void)
 233 {
 234         (void)empty_zero_page[0];
 235 }
 236
 237 /* __mmdrop() is not exported before 2.6.25 */
 238 #include <linux/sched.h>
 239
 240 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
 241
 242 #define mmdrop(x) do { (void)(x); } while (0)
 243 #define mmget(x) do { (void)(x); } while (0)
 244
 245 #else
 246
 247 #define mmget(x) do { atomic_inc(x); } while (0)
 248
 249 #endif
 250
 251 /* pagefault_enable(), page_fault_disable() - 2.6.20 */
 252 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
 253 #  define KVM_NEED_PAGEFAULT_DISABLE 1
 254 #  ifdef RHEL_RELEASE_CODE
 255 #    if RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(5,2)
 256 #      undef KVM_NEED_PAGEFAULT_DISABLE
 257 #    endif
 258 #  endif
 259 #endif
 260
 261 #ifdef KVM_NEED_PAGEFAULT_DISABLE
 262
 263 static inline void pagefault_disable(void)
 264 {
 265         inc_preempt_count();
 266         /*
 267          * make sure to have issued the store before a pagefault
 268          * can hit.
 269          */
 270         barrier();
 271 }
 272
 273 static inline void pagefault_enable(void)
 274 {
 275         /*
 276          * make sure to issue those last loads/stores before enabling
 277          * the pagefault handler again.
 278          */
 279         barrier();
 280         dec_preempt_count();
 281         /*
 282          * make sure we do..
 283          */
 284         barrier();
 285         preempt_check_resched();
 286 }
 287
 288 #endif
 289
 290 #include <linux/uaccess.h>
 291
 292 /* vm ops ->fault() was introduced in 2.6.23. */
 293 #include <linux/mm.h>
 294
 295 #ifdef KVM_MAIN
 296 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 297
 298 struct vm_fault {
 299         unsigned int flags;
 300         pgoff_t pgoff;
 301         void __user *virtual_address;
 302         struct page *page;
 303 };
 304
 305 static int kvm_vcpu_fault(struct vm_area_struct *vma, struct vm_fault *vmf);
 306 static int kvm_vm_fault(struct vm_area_struct *vma, struct vm_fault *vmf);
 307
 308 static inline struct page *kvm_nopage_to_fault(
 309         int (*fault)(struct vm_area_struct *vma, struct vm_fault *vmf),
 310         struct vm_area_struct *vma,
 311         unsigned long address,
 312         int *type)
 313 {
 314         struct vm_fault vmf;
 315         int ret;
 316
 317         vmf.pgoff = ((address - vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff;
 318         vmf.virtual_address = (void __user *)address;
 319         ret = fault(vma, &vmf);
 320         if (ret)
 321                 return NOPAGE_SIGBUS;
 322         *type = VM_FAULT_MINOR;
 323         return vmf.page;
 324 }
 325
 326 static inline struct page *__kvm_vcpu_fault(struct vm_area_struct *vma,
 327                                             unsigned long address,
 328                                             int *type)
 329 {
 330         return kvm_nopage_to_fault(kvm_vcpu_fault, vma, address, type);
 331 }
 332
 333 static inline struct page *__kvm_vm_fault(struct vm_area_struct *vma,
 334                                           unsigned long address,
 335                                           int *type)
 336 {
 337         return kvm_nopage_to_fault(kvm_vm_fault, vma, address, type);
 338 }
 339
 340 #define VMA_OPS_FAULT(x) nopage
 341 #define VMA_OPS_FAULT_FUNC(x) __##x
 342
 343 #else
 344
 345 #define VMA_OPS_FAULT(x) x
 346 #define VMA_OPS_FAULT_FUNC(x) x
 347
 348 #endif
 349 #endif
 350
 351 /* simple vfs attribute getter signature has changed to add a return code */
 352
 353 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
 354
 355 #define MAKE_SIMPLE_ATTRIBUTE_GETTER(x)       \
 356         static u64 x(void *v)                 \
 357         {                                     \
 358                 u64 ret = 0;                  \
 359                                               \
 360                 __##x(v, &ret);               \
 361                 return ret;                   \
 362         }
 363
 364 #else
 365
 366 #define MAKE_SIMPLE_ATTRIBUTE_GETTER(x)       \
 367         static int x(void *v, u64 *val)       \
 368         {                                     \
 369                 return __##x(v, val);         \
 370         }
 371
 372 #endif
 373
 374 /* set_kset_name() is gone in 2.6.25 */
 375
 376 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
 377
 378 #define set_kset_name(x) .name = x
 379
 380 #endif
 381
 382 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
 383 #ifndef FASTCALL
 384 #define FASTCALL(x)     x
 385 #define fastcall
 386 #endif
 387 #endif
 388
 389 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 390
 391 static unsigned  __attribute__((__used__)) kvm_tsc_khz = 2000000;
 392
 393 #else
 394
 395 #define kvm_tsc_khz tsc_khz
 396
 397 #endif
 398
 399 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,21)
 400
 401 #include <linux/ktime.h>
 402 #include <linux/hrtimer.h>
 403
 404 #define ktime_get kvm_ktime_get
 405
 406 static inline ktime_t ktime_get(void)
 407 {
 408         struct timespec now;
 409
 410         ktime_get_ts(&now);
 411
 412         return timespec_to_ktime(now);
 413 }
 414
 415 #endif
 416
 417 /* __aligned arrived in 2.6.21 */
 418 #ifndef __aligned
 419 #define __aligned(x) __attribute__((__aligned__(x)))
 420 #endif
 421
 422 #include <linux/mm.h>
 423
 424 /* The shrinker API changed in 2.6.23 */
 425 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 426
 427 struct kvm_shrinker {
 428         int (*shrink)(int nr_to_scan, gfp_t gfp_mask);
 429         int seeks;
 430         struct shrinker *kshrinker;
 431 };
 432
 433 static inline void register_shrinker(struct kvm_shrinker *shrinker)
 434 {
 435         shrinker->kshrinker = set_shrinker(shrinker->seeks, shrinker->shrink);
 436 }
 437
 438 static inline void unregister_shrinker(struct kvm_shrinker *shrinker)
 439 {
 440         if (shrinker->kshrinker)
 441                 remove_shrinker(shrinker->kshrinker);
 442 }
 443
 444 #define shrinker kvm_shrinker
 445
 446 #endif
 447
 448 /* clocksource */
 449 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)
 450 static inline u32 clocksource_khz2mult(u32 khz, u32 shift_constant)
 451 {
 452         /*  khz = cyc/(Million ns)
 453          *  mult/2^shift  = ns/cyc
 454          *  mult = ns/cyc * 2^shift
 455          *  mult = 1Million/khz * 2^shift
 456          *  mult = 1000000 * 2^shift / khz
 457          *  mult = (1000000<<shift) / khz
 458          */
 459         u64 tmp = ((u64)1000000) << shift_constant;
 460
 461         tmp += khz/2; /* round for do_div */
 462         do_div(tmp, khz);
 463
 464         return (u32)tmp;
 465 }
 466 #else
 467 #include <linux/clocksource.h>
 468 #endif
 469
 470 /* manually export hrtimer_init/start/cancel */
 471 #include <linux/kallsyms.h>
 472 extern void (*hrtimer_init_p)(struct hrtimer *timer, clockid_t which_clock,
 473                               enum hrtimer_mode mode);
 474 extern int (*hrtimer_start_p)(struct hrtimer *timer, ktime_t tim,
 475                               const enum hrtimer_mode mode);
 476 extern int (*hrtimer_cancel_p)(struct hrtimer *timer);
 477
 478 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,17) && defined(CONFIG_KALLSYMS)
 479 static inline void hrtimer_kallsyms_resolve(void)
 480 {
 481         hrtimer_init_p = (void *) kallsyms_lookup_name("hrtimer_init");
 482         BUG_ON(!hrtimer_init_p);
 483         hrtimer_start_p = (void *) kallsyms_lookup_name("hrtimer_start");
 484         BUG_ON(!hrtimer_start_p);
 485         hrtimer_cancel_p = (void *) kallsyms_lookup_name("hrtimer_cancel");
 486         BUG_ON(!hrtimer_cancel_p);
 487 }
 488 #else
 489 static inline void hrtimer_kallsyms_resolve(void)
 490 {
 491         hrtimer_init_p = hrtimer_init;
 492         hrtimer_start_p = hrtimer_start;
 493         hrtimer_cancel_p = hrtimer_cancel;
 494 }
 495 #endif
 496
 497 /* handle old hrtimer API with data pointer */
 498 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,17)
 499 static inline void hrtimer_data_pointer(struct hrtimer *timer)
 500 {
 501         timer->data = (void *)timer;
 502 }
 503 #else
 504 static inline void hrtimer_data_pointer(struct hrtimer *timer) {}
 505 #endif
 506
 507 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
 508
 509 #define ns_to_timespec kvm_ns_to_timespec
 510
 511 struct timespec kvm_ns_to_timespec(const s64 nsec);
 512
 513 #endif
 514
 515 /* work_struct lost the 'data' field in 2.6.20 */
 516 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
 517
 518 #define kvm_INIT_WORK(work, handler) \
 519         INIT_WORK(work, (void (*)(void *))handler, work)
 520
 521 #else
 522
 523 #define kvm_INIT_WORK(work, handler) INIT_WORK(work, handler)
 524
 525 #endif
 526
 527 /* cancel_work_sync() was flush_work() in 2.6.21 */
 528 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
 529
 530 static inline int cancel_work_sync(struct work_struct *work)
 531 {
 532         /*
 533          * FIXME: actually cancel.  How?  Add own implementation of workqueues?
 534          */
 535         return 0;
 536 }
 537
 538 /* ... and it returned void before 2.6.23 */
 539 #elif LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 540
 541 #define cancel_work_sync(work) ({ cancel_work_sync(work); 0; })
 542
 543 #endif
 544
 545 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
 546
 547 struct pci_dev;
 548
 549 struct pci_dev *pci_get_bus_and_slot(unsigned int bus, unsigned int devfn);
 550
 551 #endif
 552
 553 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)
 554
 555 #include <linux/relay.h>
 556
 557 /* relay_open() interface has changed on 2.6.21 */
 558
 559 struct rchan *kvm_relay_open(const char *base_filename,
 560                          struct dentry *parent,
 561                          size_t subbuf_size,
 562                          size_t n_subbufs,
 563                          struct rchan_callbacks *cb,
 564                          void *private_data);
 565
 566 #else
 567
 568 #define kvm_relay_open relay_open
 569
 570 #endif
 571
 572 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)
 573
 574 static inline int get_user_pages_fast(unsigned long start, int nr_pages,
 575                                       int write, struct page **pages)
 576 {
 577         int npages;
 578
 579         down_read(&current->mm->mmap_sem);
 580         npages = get_user_pages(current, current->mm, start, nr_pages, write,
 581                                 0, pages, NULL);
 582         up_read(&current->mm->mmap_sem);
 583
 584         return npages;
 585 }
 586
 587 #endif
 588
 589 /* spin_needbreak() was called something else in 2.6.24 */
 590 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,24)
 591
 592 #define spin_needbreak need_lockbreak
 593
 594 #endif
 595
 596 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
 597
 598 static inline void kvm_hrtimer_add_expires_ns(struct hrtimer *timer, u64 delta)
 599 {
 600         timer->expires = ktime_add_ns(timer->expires, delta);
 601 }
 602
 603 static inline ktime_t kvm_hrtimer_get_expires(struct hrtimer *timer)
 604 {
 605         return timer->expires;
 606 }
 607
 608 static inline u64 kvm_hrtimer_get_expires_ns(struct hrtimer *timer)
 609 {
 610         return ktime_to_ns(timer->expires);
 611 }
 612
 613 static inline void kvm_hrtimer_start_expires(struct hrtimer *timer, int mode)
 614 {
 615         hrtimer_start_p(timer, timer->expires, mode);
 616 }
 617
 618 static inline ktime_t kvm_hrtimer_expires_remaining(const struct hrtimer *timer)
 619 {
 620     return ktime_sub(timer->expires, timer->base->get_time());
 621 }
 622
 623 #else
 624
 625 #define kvm_hrtimer_add_expires_ns hrtimer_add_expires_ns
 626 #define kvm_hrtimer_get_expires hrtimer_get_expires
 627 #define kvm_hrtimer_get_expires_ns hrtimer_get_expires_ns
 628 #define kvm_hrtimer_start_expires hrtimer_start_expires
 629 #define kvm_hrtimer_expires_remaining hrtimer_expires_remaining
 630
 631 #endif
 632
 633 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
 634
 635 static inline int pci_reset_function(struct pci_dev *dev)
 636 {
 637         return 0;
 638 }
 639
 640 #endif
 641
 642 #include <linux/interrupt.h>
 643 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
 644
 645 typedef irqreturn_t (*kvm_irq_handler_t)(int, void *, struct pt_regs *);
 646 static inline int kvm_request_irq(unsigned int a, kvm_irq_handler_t handler,
 647                                   unsigned long c, const char *d, void *e)
 648 {
 649         /* FIXME: allocate thunk, etc. */
 650         return -EINVAL;
 651 }
 652
 653 #else
 654
 655 #define kvm_request_irq request_irq
 656
 657 #endif
 658
 659 /* dynamically allocated cpu masks introduced in 2.6.28 */
 660 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
 661
 662 typedef cpumask_t cpumask_var_t[1];
 663
 664 static inline bool alloc_cpumask_var(cpumask_var_t *mask, gfp_t flags)
 665 {
 666         return 1;
 667 }
 668
 669 static inline void free_cpumask_var(cpumask_var_t mask)
 670 {
 671 }
 672
 673 static inline void cpumask_clear(cpumask_var_t mask)
 674 {
 675         cpus_clear(*mask);
 676 }
 677
 678 static inline void cpumask_set_cpu(int cpu, cpumask_var_t mask)
 679 {
 680         cpu_set(cpu, *mask);
 681 }
 682
 683 static inline int smp_call_function_many(cpumask_var_t cpus,
 684                                          void (*func)(void *data), void *data,
 685                                          int sync)
 686 {
 687         return smp_call_function_mask(*cpus, func, data, sync);
 688 }
 689
 690 static inline int cpumask_empty(cpumask_var_t mask)
 691 {
 692         return cpus_empty(*mask);
 693 }
 694
 695 static inline int cpumask_test_cpu(int cpu, cpumask_var_t mask)
 696 {
 697         return cpu_isset(cpu, *mask);
 698 }
 699
 700 static inline void cpumask_clear_cpu(int cpu, cpumask_var_t mask)
 701 {
 702         cpu_clear(cpu, *mask);
 703 }
 704
 705 #define cpu_online_mask (&cpu_online_map)
 706
 707 #endif
 708
 709 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29)
 710
 711 #define IF_ANON_INODES_DOES_REFCOUNTS(x)
 712
 713 #else
 714
 715 #define IF_ANON_INODES_DOES_REFCOUNTS(x) x
 716
 717 #endif
 718
 719
 720 /* Macro introduced only on newer kernels: */
 721 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
 722 #define marker_synchronize_unregister() synchronize_sched()
 723 #endif