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
  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
 254 static inline void pagefault_disable(void)
 255 {
 256         inc_preempt_count();
 257         /*
 258          * make sure to have issued the store before a pagefault
 259          * can hit.
 260          */
 261         barrier();
 262 }
 263
 264 static inline void pagefault_enable(void)
 265 {
 266         /*
 267          * make sure to issue those last loads/stores before enabling
 268          * the pagefault handler again.
 269          */
 270         barrier();
 271         dec_preempt_count();
 272         /*
 273          * make sure we do..
 274          */
 275         barrier();
 276         preempt_check_resched();
 277 }
 278
 279 #endif
 280
 281 /* vm ops ->fault() was introduced in 2.6.23. */
 282 #include <linux/mm.h>
 283
 284 #ifdef KVM_MAIN
 285 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 286
 287 struct vm_fault {
 288         unsigned int flags;
 289         pgoff_t pgoff;
 290         void __user *virtual_address;
 291         struct page *page;
 292 };
 293
 294 static int kvm_vcpu_fault(struct vm_area_struct *vma, struct vm_fault *vmf);
 295 static int kvm_vm_fault(struct vm_area_struct *vma, struct vm_fault *vmf);
 296
 297 static inline struct page *kvm_nopage_to_fault(
 298         int (*fault)(struct vm_area_struct *vma, struct vm_fault *vmf),
 299         struct vm_area_struct *vma,
 300         unsigned long address,
 301         int *type)
 302 {
 303         struct vm_fault vmf;
 304         int ret;
 305
 306         vmf.pgoff = ((address - vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff;
 307         vmf.virtual_address = (void __user *)address;
 308         ret = fault(vma, &vmf);
 309         if (ret)
 310                 return NOPAGE_SIGBUS;
 311         *type = VM_FAULT_MINOR;
 312         return vmf.page;
 313 }
 314
 315 static inline struct page *__kvm_vcpu_fault(struct vm_area_struct *vma,
 316                                             unsigned long address,
 317                                             int *type)
 318 {
 319         return kvm_nopage_to_fault(kvm_vcpu_fault, vma, address, type);
 320 }
 321
 322 static inline struct page *__kvm_vm_fault(struct vm_area_struct *vma,
 323                                           unsigned long address,
 324                                           int *type)
 325 {
 326         return kvm_nopage_to_fault(kvm_vm_fault, vma, address, type);
 327 }
 328
 329 #define VMA_OPS_FAULT(x) nopage
 330 #define VMA_OPS_FAULT_FUNC(x) __##x
 331
 332 #else
 333
 334 #define VMA_OPS_FAULT(x) x
 335 #define VMA_OPS_FAULT_FUNC(x) x
 336
 337 #endif
 338 #endif
 339
 340 /* simple vfs attribute getter signature has changed to add a return code */
 341
 342 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
 343
 344 #define MAKE_SIMPLE_ATTRIBUTE_GETTER(x)       \
 345         static u64 x(void *v)                 \
 346         {                                     \
 347                 u64 ret = 0;                  \
 348                                               \
 349                 __##x(v, &ret);               \
 350                 return ret;                   \
 351         }
 352
 353 #else
 354
 355 #define MAKE_SIMPLE_ATTRIBUTE_GETTER(x)       \
 356         static int x(void *v, u64 *val)       \
 357         {                                     \
 358                 return __##x(v, val);         \
 359         }
 360
 361 #endif
 362
 363 /* set_kset_name() is gone in 2.6.25 */
 364
 365 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
 366
 367 #define set_kset_name(x) .name = x
 368
 369 #endif
 370
 371 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
 372 #ifndef FASTCALL
 373 #define FASTCALL(x)     x
 374 #define fastcall
 375 #endif
 376 #endif
 377
 378 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 379
 380 static unsigned  __attribute__((__used__)) kvm_tsc_khz = 2000000;
 381
 382 #else
 383
 384 #define kvm_tsc_khz tsc_khz
 385
 386 #endif
 387
 388 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,21)
 389
 390 #include <linux/ktime.h>
 391 #include <linux/hrtimer.h>
 392
 393 #define ktime_get kvm_ktime_get
 394
 395 static inline ktime_t ktime_get(void)
 396 {
 397         struct timespec now;
 398
 399         ktime_get_ts(&now);
 400
 401         return timespec_to_ktime(now);
 402 }
 403
 404 #endif
 405
 406 /* __aligned arrived in 2.6.21 */
 407 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)
 408 #define __aligned(x) __attribute__((__aligned__(x)))
 409 #endif
 410
 411 #include <linux/mm.h>
 412
 413 /* The shrinker API changed in 2.6.23 */
 414 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 415
 416 struct kvm_shrinker {
 417         int (*shrink)(int nr_to_scan, gfp_t gfp_mask);
 418         int seeks;
 419         struct shrinker *kshrinker;
 420 };
 421
 422 static inline void register_shrinker(struct kvm_shrinker *shrinker)
 423 {
 424         shrinker->kshrinker = set_shrinker(shrinker->seeks, shrinker->shrink);
 425 }
 426
 427 static inline void unregister_shrinker(struct kvm_shrinker *shrinker)
 428 {
 429         if (shrinker->kshrinker)
 430                 remove_shrinker(shrinker->kshrinker);
 431 }
 432
 433 #define shrinker kvm_shrinker
 434
 435 #endif
 436
 437 /* clocksource */
 438 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)
 439 static inline u32 clocksource_khz2mult(u32 khz, u32 shift_constant)
 440 {
 441         /*  khz = cyc/(Million ns)
 442          *  mult/2^shift  = ns/cyc
 443          *  mult = ns/cyc * 2^shift
 444          *  mult = 1Million/khz * 2^shift
 445          *  mult = 1000000 * 2^shift / khz
 446          *  mult = (1000000<<shift) / khz
 447          */
 448         u64 tmp = ((u64)1000000) << shift_constant;
 449
 450         tmp += khz/2; /* round for do_div */
 451         do_div(tmp, khz);
 452
 453         return (u32)tmp;
 454 }
 455 #else
 456 #include <linux/clocksource.h>
 457 #endif
 458
 459 /* manually export hrtimer_init/start/cancel */
 460 #include <linux/kallsyms.h>
 461 extern void (*hrtimer_init_p)(struct hrtimer *timer, clockid_t which_clock,
 462                               enum hrtimer_mode mode);
 463 extern int (*hrtimer_start_p)(struct hrtimer *timer, ktime_t tim,
 464                               const enum hrtimer_mode mode);
 465 extern int (*hrtimer_cancel_p)(struct hrtimer *timer);
 466
 467 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,17) && defined(CONFIG_KALLSYMS)
 468 static inline void hrtimer_kallsyms_resolve(void)
 469 {
 470         hrtimer_init_p = (void *) kallsyms_lookup_name("hrtimer_init");
 471         BUG_ON(!hrtimer_init_p);
 472         hrtimer_start_p = (void *) kallsyms_lookup_name("hrtimer_start");
 473         BUG_ON(!hrtimer_start_p);
 474         hrtimer_cancel_p = (void *) kallsyms_lookup_name("hrtimer_cancel");
 475         BUG_ON(!hrtimer_cancel_p);
 476 }
 477 #else
 478 static inline void hrtimer_kallsyms_resolve(void)
 479 {
 480         hrtimer_init_p = hrtimer_init;
 481         hrtimer_start_p = hrtimer_start;
 482         hrtimer_cancel_p = hrtimer_cancel;
 483 }
 484 #endif
 485
 486 /* handle old hrtimer API with data pointer */
 487 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,17)
 488 static inline void hrtimer_data_pointer(struct hrtimer *timer)
 489 {
 490         timer->data = (void *)timer;
 491 }
 492 #else
 493 static inline void hrtimer_data_pointer(struct hrtimer *timer) {}
 494 #endif
 495
 496 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
 497
 498 #define ns_to_timespec kvm_ns_to_timespec
 499
 500 struct timespec kvm_ns_to_timespec(const s64 nsec);
 501
 502 #endif
 503
 504 /* work_struct lost the 'data' field in 2.6.20 */
 505 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
 506
 507 #define kvm_INIT_WORK(work, handler) \
 508         INIT_WORK(work, (void (*)(void *))handler, work)
 509
 510 #else
 511
 512 #define kvm_INIT_WORK(work, handler) INIT_WORK(work, handler)
 513
 514 #endif
 515
 516 /* cancel_work_sync() was flush_work() in 2.6.21 */
 517 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
 518
 519 static inline int cancel_work_sync(struct work_struct *work)
 520 {
 521         /*
 522          * FIXME: actually cancel.  How?  Add own implementation of workqueues?
 523          */
 524         return 0;
 525 }
 526
 527 /* ... and it returned void before 2.6.23 */
 528 #elif LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 529
 530 #define cancel_work_sync(work) ({ cancel_work_sync(work); 0; })
 531
 532 #endif
 533
 534 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
 535
 536 struct pci_dev;
 537
 538 struct pci_dev *pci_get_bus_and_slot(unsigned int bus, unsigned int devfn);
 539
 540 #endif
 541
 542 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)
 543
 544 #include <linux/relay.h>
 545
 546 /* relay_open() interface has changed on 2.6.21 */
 547
 548 struct rchan *kvm_relay_open(const char *base_filename,
 549                          struct dentry *parent,
 550                          size_t subbuf_size,
 551                          size_t n_subbufs,
 552                          struct rchan_callbacks *cb,
 553                          void *private_data);
 554
 555 #else
 556
 557 #define kvm_relay_open relay_open
 558
 559 #endif
 560
 561 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)
 562
 563 static inline int get_user_pages_fast(unsigned long start, int nr_pages,
 564                                       int write, struct page **pages)
 565 {
 566         int npages;
 567
 568         down_read(&current->mm->mmap_sem);
 569         npages = get_user_pages(current, current->mm, start, nr_pages, write,
 570                                 0, pages, NULL);
 571         up_read(&current->mm->mmap_sem);
 572
 573         return npages;
 574 }
 575
 576 #endif
 577
 578 /* spin_needbreak() was called something else in 2.6.24 */
 579 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,24)
 580
 581 #define spin_needbreak need_lockbreak
 582
 583 #endif
 584
 585 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
 586
 587 static inline void kvm_hrtimer_add_expires_ns(struct hrtimer *timer, u64 delta)
 588 {
 589         timer->expires = ktime_add_ns(timer->expires, delta);
 590 }
 591
 592 static inline ktime_t kvm_hrtimer_get_expires(struct hrtimer *timer)
 593 {
 594         return timer->expires;
 595 }
 596
 597 static inline u64 kvm_hrtimer_get_expires_ns(struct hrtimer *timer)
 598 {
 599         return ktime_to_ns(timer->expires);
 600 }
 601
 602 static inline void kvm_hrtimer_start_expires(struct hrtimer *timer, int mode)
 603 {
 604         hrtimer_start_p(timer, timer->expires, mode);
 605 }
 606
 607 #else
 608
 609 #define kvm_hrtimer_add_expires_ns hrtimer_add_expires_ns
 610 #define kvm_hrtimer_get_expires hrtimer_get_expires
 611 #define kvm_hrtimer_get_expires_ns hrtimer_get_expires_ns
 612 #define kvm_hrtimer_start_expires hrtimer_start_expires
 613
 614 #endif
 615
 616 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
 617
 618 static inline int pci_reset_function(struct pci_dev *dev)
 619 {
 620         return 0;
 621 }
 622
 623 #endif
 624
 625 #include <linux/interrupt.h>
 626 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
 627
 628 typedef irqreturn_t (*kvm_irq_handler_t)(int, void *, struct pt_regs *);
 629 static inline int kvm_request_irq(unsigned int a, kvm_irq_handler_t handler,
 630                                   unsigned long c, const char *d, void *e)
 631 {
 632         /* FIXME: allocate thunk, etc. */
 633         return -EINVAL;
 634 }
 635
 636 #else
 637
 638 #define kvm_request_irq request_irq
 639
 640 #endif
 641
 642 /* dynamically allocated cpu masks introduced in 2.6.28 */
 643 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
 644
 645 typedef cpumask_t cpumask_var_t[1];
 646
 647 static inline bool alloc_cpumask_var(cpumask_var_t *mask, gfp_t flags)
 648 {
 649         return 1;
 650 }
 651
 652 static inline void free_cpumask_var(cpumask_var_t mask)
 653 {
 654 }
 655
 656 static inline void cpumask_clear(cpumask_var_t mask)
 657 {
 658         cpus_clear(*mask);
 659 }
 660
 661 static inline void cpumask_set_cpu(int cpu, cpumask_var_t mask)
 662 {
 663         cpu_set(cpu, *mask);
 664 }
 665
 666 static inline int smp_call_function_many(cpumask_var_t cpus,
 667                                          void (*func)(void *data), void *data,
 668                                          int sync)
 669 {
 670         return smp_call_function_mask(*cpus, func, data, sync);
 671 }
 672
 673 static inline int cpumask_empty(cpumask_var_t mask)
 674 {
 675         return cpus_empty(*mask);
 676 }
 677
 678 static inline int cpumask_test_cpu(int cpu, cpumask_var_t mask)
 679 {
 680         return cpu_isset(cpu, *mask);
 681 }
 682
 683 static inline void cpumask_clear_cpu(int cpu, cpumask_var_t mask)
 684 {
 685         cpu_clear(cpu, *mask);
 686 }
 687
 688 #define cpu_online_mask (&cpu_online_map)
 689
 690 #endif
 691
 692 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29)
 693
 694 #define IF_ANON_INODES_DOES_REFCOUNTS(x)
 695
 696 #else
 697
 698 #define IF_ANON_INODES_DOES_REFCOUNTS(x) x
 699
 700 #endif
 701
 702
 703 /* Macro introduced only on newer kernels: */
 704 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
 705 #define marker_synchronize_unregister() synchronize_sched()
 706 #endif