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,3)
 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 unsigned kvm_get_tsc_khz(void);
 392 #define kvm_tsc_khz (kvm_get_tsc_khz())
 393
 394 #else
 395
 396 #define kvm_tsc_khz tsc_khz
 397
 398 #endif
 399
 400 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,21)
 401
 402 #include <linux/ktime.h>
 403 #include <linux/hrtimer.h>
 404
 405 #define ktime_get kvm_ktime_get
 406
 407 static inline ktime_t ktime_get(void)
 408 {
 409         struct timespec now;
 410
 411         ktime_get_ts(&now);
 412
 413         return timespec_to_ktime(now);
 414 }
 415
 416 #endif
 417
 418 /* __aligned arrived in 2.6.21 */
 419 #ifndef __aligned
 420 #define __aligned(x) __attribute__((__aligned__(x)))
 421 #endif
 422
 423 #include <linux/mm.h>
 424
 425 /* The shrinker API changed in 2.6.23 */
 426 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 427
 428 struct kvm_shrinker {
 429         int (*shrink)(int nr_to_scan, gfp_t gfp_mask);
 430         int seeks;
 431         struct shrinker *kshrinker;
 432 };
 433
 434 static inline void register_shrinker(struct kvm_shrinker *shrinker)
 435 {
 436         shrinker->kshrinker = set_shrinker(shrinker->seeks, shrinker->shrink);
 437 }
 438
 439 static inline void unregister_shrinker(struct kvm_shrinker *shrinker)
 440 {
 441         if (shrinker->kshrinker)
 442                 remove_shrinker(shrinker->kshrinker);
 443 }
 444
 445 #define shrinker kvm_shrinker
 446
 447 #endif
 448
 449 /* clocksource */
 450 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)
 451 static inline u32 clocksource_khz2mult(u32 khz, u32 shift_constant)
 452 {
 453         /*  khz = cyc/(Million ns)
 454          *  mult/2^shift  = ns/cyc
 455          *  mult = ns/cyc * 2^shift
 456          *  mult = 1Million/khz * 2^shift
 457          *  mult = 1000000 * 2^shift / khz
 458          *  mult = (1000000<<shift) / khz
 459          */
 460         u64 tmp = ((u64)1000000) << shift_constant;
 461
 462         tmp += khz/2; /* round for do_div */
 463         do_div(tmp, khz);
 464
 465         return (u32)tmp;
 466 }
 467 #else
 468 #include <linux/clocksource.h>
 469 #endif
 470
 471 /* manually export hrtimer_init/start/cancel */
 472 #include <linux/kallsyms.h>
 473 extern void (*hrtimer_init_p)(struct hrtimer *timer, clockid_t which_clock,
 474                               enum hrtimer_mode mode);
 475 extern int (*hrtimer_start_p)(struct hrtimer *timer, ktime_t tim,
 476                               const enum hrtimer_mode mode);
 477 extern int (*hrtimer_cancel_p)(struct hrtimer *timer);
 478
 479 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,17) && defined(CONFIG_KALLSYMS)
 480 static inline void hrtimer_kallsyms_resolve(void)
 481 {
 482         hrtimer_init_p = (void *) kallsyms_lookup_name("hrtimer_init");
 483         BUG_ON(!hrtimer_init_p);
 484         hrtimer_start_p = (void *) kallsyms_lookup_name("hrtimer_start");
 485         BUG_ON(!hrtimer_start_p);
 486         hrtimer_cancel_p = (void *) kallsyms_lookup_name("hrtimer_cancel");
 487         BUG_ON(!hrtimer_cancel_p);
 488 }
 489 #else
 490 static inline void hrtimer_kallsyms_resolve(void)
 491 {
 492         hrtimer_init_p = hrtimer_init;
 493         hrtimer_start_p = hrtimer_start;
 494         hrtimer_cancel_p = hrtimer_cancel;
 495 }
 496 #endif
 497
 498 /* handle old hrtimer API with data pointer */
 499 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,17)
 500 static inline void hrtimer_data_pointer(struct hrtimer *timer)
 501 {
 502         timer->data = (void *)timer;
 503 }
 504 #else
 505 static inline void hrtimer_data_pointer(struct hrtimer *timer) {}
 506 #endif
 507
 508 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
 509
 510 #define ns_to_timespec kvm_ns_to_timespec
 511
 512 struct timespec kvm_ns_to_timespec(const s64 nsec);
 513
 514 #endif
 515
 516 /* work_struct lost the 'data' field in 2.6.20 */
 517 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
 518
 519 #define kvm_INIT_WORK(work, handler) \
 520         INIT_WORK(work, (void (*)(void *))handler, work)
 521
 522 #else
 523
 524 #define kvm_INIT_WORK(work, handler) INIT_WORK(work, handler)
 525
 526 #endif
 527
 528 /* cancel_work_sync() was flush_work() in 2.6.21 */
 529 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
 530
 531 static inline int cancel_work_sync(struct work_struct *work)
 532 {
 533         /*
 534          * FIXME: actually cancel.  How?  Add own implementation of workqueues?
 535          */
 536         return 0;
 537 }
 538
 539 /* ... and it returned void before 2.6.23 */
 540 #elif LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 541
 542 #define cancel_work_sync(work) ({ cancel_work_sync(work); 0; })
 543
 544 #endif
 545
 546 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
 547
 548 struct pci_dev;
 549
 550 struct pci_dev *pci_get_bus_and_slot(unsigned int bus, unsigned int devfn);
 551
 552 #endif
 553
 554 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)
 555
 556 #include <linux/relay.h>
 557
 558 /* relay_open() interface has changed on 2.6.21 */
 559
 560 struct rchan *kvm_relay_open(const char *base_filename,
 561                          struct dentry *parent,
 562                          size_t subbuf_size,
 563                          size_t n_subbufs,
 564                          struct rchan_callbacks *cb,
 565                          void *private_data);
 566
 567 #else
 568
 569 #define kvm_relay_open relay_open
 570
 571 #endif
 572
 573 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)
 574
 575 static inline int get_user_pages_fast(unsigned long start, int nr_pages,
 576                                       int write, struct page **pages)
 577 {
 578         int npages;
 579
 580         down_read(&current->mm->mmap_sem);
 581         npages = get_user_pages(current, current->mm, start, nr_pages, write,
 582                                 0, pages, NULL);
 583         up_read(&current->mm->mmap_sem);
 584
 585         return npages;
 586 }
 587
 588 #endif
 589
 590 /* spin_needbreak() was called something else in 2.6.24 */
 591 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,24)
 592
 593 #define spin_needbreak need_lockbreak
 594
 595 #endif
 596
 597 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
 598
 599 static inline void kvm_hrtimer_add_expires_ns(struct hrtimer *timer, u64 delta)
 600 {
 601         timer->expires = ktime_add_ns(timer->expires, delta);
 602 }
 603
 604 static inline ktime_t kvm_hrtimer_get_expires(struct hrtimer *timer)
 605 {
 606         return timer->expires;
 607 }
 608
 609 static inline u64 kvm_hrtimer_get_expires_ns(struct hrtimer *timer)
 610 {
 611         return ktime_to_ns(timer->expires);
 612 }
 613
 614 static inline void kvm_hrtimer_start_expires(struct hrtimer *timer, int mode)
 615 {
 616         hrtimer_start_p(timer, timer->expires, mode);
 617 }
 618
 619 static inline ktime_t kvm_hrtimer_expires_remaining(const struct hrtimer *timer)
 620 {
 621     return ktime_sub(timer->expires, timer->base->get_time());
 622 }
 623
 624 #else
 625
 626 #define kvm_hrtimer_add_expires_ns hrtimer_add_expires_ns
 627 #define kvm_hrtimer_get_expires hrtimer_get_expires
 628 #define kvm_hrtimer_get_expires_ns hrtimer_get_expires_ns
 629 #define kvm_hrtimer_start_expires hrtimer_start_expires
 630 #define kvm_hrtimer_expires_remaining hrtimer_expires_remaining
 631
 632 #endif
 633
 634 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
 635
 636 static inline int pci_reset_function(struct pci_dev *dev)
 637 {
 638         return 0;
 639 }
 640
 641 #endif
 642
 643 #include <linux/interrupt.h>
 644 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
 645
 646 typedef irqreturn_t (*kvm_irq_handler_t)(int, void *, struct pt_regs *);
 647 static inline int kvm_request_irq(unsigned int a, kvm_irq_handler_t handler,
 648                                   unsigned long c, const char *d, void *e)
 649 {
 650         /* FIXME: allocate thunk, etc. */
 651         return -EINVAL;
 652 }
 653
 654 #else
 655
 656 #define kvm_request_irq request_irq
 657
 658 #endif
 659
 660 /* dynamically allocated cpu masks introduced in 2.6.28 */
 661 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
 662
 663 typedef cpumask_t cpumask_var_t[1];
 664
 665 static inline bool alloc_cpumask_var(cpumask_var_t *mask, gfp_t flags)
 666 {
 667         return 1;
 668 }
 669
 670 static inline void free_cpumask_var(cpumask_var_t mask)
 671 {
 672 }
 673
 674 static inline void cpumask_clear(cpumask_var_t mask)
 675 {
 676         cpus_clear(*mask);
 677 }
 678
 679 static inline void cpumask_set_cpu(int cpu, cpumask_var_t mask)
 680 {
 681         cpu_set(cpu, *mask);
 682 }
 683
 684 static inline int smp_call_function_many(cpumask_var_t cpus,
 685                                          void (*func)(void *data), void *data,
 686                                          int sync)
 687 {
 688         return smp_call_function_mask(*cpus, func, data, sync);
 689 }
 690
 691 static inline int cpumask_empty(cpumask_var_t mask)
 692 {
 693         return cpus_empty(*mask);
 694 }
 695
 696 static inline int cpumask_test_cpu(int cpu, cpumask_var_t mask)
 697 {
 698         return cpu_isset(cpu, *mask);
 699 }
 700
 701 static inline void cpumask_clear_cpu(int cpu, cpumask_var_t mask)
 702 {
 703         cpu_clear(cpu, *mask);
 704 }
 705
 706 #define cpu_online_mask (&cpu_online_map)
 707
 708 #endif
 709
 710 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29)
 711
 712 #define IF_ANON_INODES_DOES_REFCOUNTS(x)
 713
 714 #else
 715
 716 #define IF_ANON_INODES_DOES_REFCOUNTS(x) x
 717
 718 #endif
 719
 720
 721 /* Macro introduced only on newer kernels: */
 722 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
 723 #define marker_synchronize_unregister() synchronize_sched()
 724 #endif
 725
 726 /* pci_dev.msi_enable was introduced in 2.6.18 */
 727 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)
 728
 729 struct pci_dev;
 730
 731 int kvm_pcidev_msi_enabled(struct pci_dev *dev);
 732
 733 #else
 734
 735 #define kvm_pcidev_msi_enabled(dev)     (dev)->msi_enabled
 736
 737 #endif
 738
 739 /* compound_head() was introduced in 2.6.22 */
 740
 741 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
 742 #  define NEED_COMPOUND_HEAD 1
 743 #  ifdef RHEL_RELEASE_CODE
 744 #    if RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(5,2)
 745 #      undef NEED_COMPOUND_HEAD
 746 #    endif
 747 #  endif
 748 #endif
 749
 750 #ifdef NEED_COMPOUND_HEAD
 751
 752 static inline struct page *compound_head(struct page *page)
 753 {
 754         if (PageCompound(page))
 755                 page = (struct page *)page_private(page);
 756         return page;
 757 }
 758
 759 #endif