osfmk/i386/bsd_i386.c

   1 /*
   2  * Copyright (c) 2000-2010 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28 #ifdef  MACH_BSD
  29 #include <mach_rt.h>
  30 #include <mach_debug.h>
  31 #include <mach_ldebug.h>
  32
  33 #include <mach/kern_return.h>
  34 #include <mach/mach_traps.h>
  35 #include <mach/thread_status.h>
  36 #include <mach/vm_param.h>
  37
  38 #include <kern/counters.h>
  39 #include <kern/cpu_data.h>
  40 #include <kern/mach_param.h>
  41 #include <kern/task.h>
  42 #include <kern/thread.h>
  43 #include <kern/sched_prim.h>
  44 #include <kern/misc_protos.h>
  45 #include <kern/assert.h>
  46 #include <kern/debug.h>
  47 #include <kern/spl.h>
  48 #include <kern/syscall_sw.h>
  49 #include <ipc/ipc_port.h>
  50 #include <vm/vm_kern.h>
  51 #include <vm/pmap.h>
  52
  53 #include <i386/cpu_number.h>
  54 #include <i386/eflags.h>
  55 #include <i386/proc_reg.h>
  56 #include <i386/tss.h>
  57 #include <i386/user_ldt.h>
  58 #include <i386/fpu.h>
  59 #include <i386/machdep_call.h>
  60 #include <i386/vmparam.h>
  61 #include <i386/mp_desc.h>
  62 #include <i386/misc_protos.h>
  63 #include <i386/thread.h>
  64 #include <i386/trap.h>
  65 #include <i386/seg.h>
  66 #include <mach/i386/syscall_sw.h>
  67 #include <sys/syscall.h>
  68 #include <sys/kdebug.h>
  69 #include <sys/errno.h>
  70 #include <../bsd/sys/sysent.h>
  71
  72 #ifdef MACH_BSD
  73 extern void     mach_kauth_cred_uthread_update(void);
  74 #endif
  75
  76 void * find_user_regs(thread_t);
  77
  78 unsigned int get_msr_exportmask(void);
  79
  80 unsigned int get_msr_nbits(void);
  81
  82 unsigned int get_msr_rbits(void);
  83
  84 extern void throttle_lowpri_io(int);
  85
  86 /*
  87  * thread_userstack:
  88  *
  89  * Return the user stack pointer from the machine
  90  * dependent thread state info.
  91  */
  92 kern_return_t
  93 thread_userstack(
  94     __unused thread_t   thread,
  95     int                 flavor,
  96     thread_state_t      tstate,
  97     __unused unsigned int        count,
  98     mach_vm_offset_t    *user_stack,
  99         int                                     *customstack
 100 )
 101 {
 102         if (customstack)
 103                 *customstack = 0;
 104
 105         switch (flavor) {
 106         case x86_THREAD_STATE32:
 107                 {
 108                         x86_thread_state32_t *state25;
 109
 110                         state25 = (x86_thread_state32_t *) tstate;
 111
 112                         if (state25->esp) {
 113                                 *user_stack = state25->esp;
 114                                 if (customstack)
 115                                         *customstack = 1;
 116                         } else {
 117                                 *user_stack = VM_USRSTACK32;
 118                                 if (customstack)
 119                                         *customstack = 0;
 120                         }
 121                         break;
 122                 }
 123
 124         case x86_THREAD_STATE64:
 125                 {
 126                         x86_thread_state64_t *state25;
 127
 128                         state25 = (x86_thread_state64_t *) tstate;
 129
 130                         if (state25->rsp) {
 131                                 *user_stack = state25->rsp;
 132                                 if (customstack)
 133                                         *customstack = 1;
 134                         } else {
 135                                 *user_stack = VM_USRSTACK64;
 136                                 if (customstack)
 137                                         *customstack = 0;
 138                         }
 139                         break;
 140                 }
 141
 142         default:
 143                 return (KERN_INVALID_ARGUMENT);
 144         }
 145
 146         return (KERN_SUCCESS);
 147 }
 148
 149
 150 kern_return_t
 151 thread_entrypoint(
 152     __unused thread_t   thread,
 153     int                 flavor,
 154     thread_state_t      tstate,
 155     __unused unsigned int        count,
 156     mach_vm_offset_t    *entry_point
 157 )
 158 {
 159         /*
 160          * Set a default.
 161          */
 162         if (*entry_point == 0)
 163                 *entry_point = VM_MIN_ADDRESS;
 164
 165         switch (flavor) {
 166         case x86_THREAD_STATE32:
 167                 {
 168                         x86_thread_state32_t *state25;
 169
 170                         state25 = (i386_thread_state_t *) tstate;
 171                         *entry_point = state25->eip ? state25->eip: VM_MIN_ADDRESS;
 172                         break;
 173                 }
 174
 175         case x86_THREAD_STATE64:
 176                 {
 177                         x86_thread_state64_t *state25;
 178
 179                         state25 = (x86_thread_state64_t *) tstate;
 180                         *entry_point = state25->rip ? state25->rip: VM_MIN_ADDRESS64;
 181                         break;
 182                 }
 183         }
 184         return (KERN_SUCCESS);
 185 }
 186
 187 /*
 188  * FIXME - thread_set_child
 189  */
 190
 191 void thread_set_child(thread_t child, int pid);
 192 void
 193 thread_set_child(thread_t child, int pid)
 194 {
 195         pal_register_cache_state(child, DIRTY);
 196
 197         if (thread_is_64bit(child)) {
 198                 x86_saved_state64_t     *iss64;
 199
 200                 iss64 = USER_REGS64(child);
 201
 202                 iss64->rax = pid;
 203                 iss64->rdx = 1;
 204                 iss64->isf.rflags &= ~EFL_CF;
 205         } else {
 206                 x86_saved_state32_t     *iss32;
 207
 208                 iss32 = USER_REGS32(child);
 209
 210                 iss32->eax = pid;
 211                 iss32->edx = 1;
 212                 iss32->efl &= ~EFL_CF;
 213         }
 214 }
 215
 216
 217
 218 /*
 219  * System Call handling code
 220  */
 221
 222 extern long fuword(vm_offset_t);
 223
 224
 225
 226 void
 227 machdep_syscall(x86_saved_state_t *state)
 228 {
 229         int                     args[machdep_call_count];
 230         int                     trapno;
 231         int                     nargs;
 232         machdep_call_t          *entry;
 233         x86_saved_state32_t     *regs;
 234
 235         assert(is_saved_state32(state));
 236         regs = saved_state32(state);
 237
 238         trapno = regs->eax;
 239 #if DEBUG_TRACE
 240         kprintf("machdep_syscall(0x%08x) code=%d\n", regs, trapno);
 241 #endif
 242
 243         DEBUG_KPRINT_SYSCALL_MDEP(
 244                 "machdep_syscall: trapno=%d\n", trapno);
 245
 246         if (trapno < 0 || trapno >= machdep_call_count) {
 247                 regs->eax = (unsigned int)kern_invalid(NULL);
 248
 249                 thread_exception_return();
 250                 /* NOTREACHED */
 251         }
 252         entry = &machdep_call_table[trapno];
 253         nargs = entry->nargs;
 254
 255         if (nargs != 0) {
 256                 if (copyin((user_addr_t) regs->uesp + sizeof (int),
 257                                 (char *) args, (nargs * sizeof (int)))) {
 258                         regs->eax = KERN_INVALID_ADDRESS;
 259
 260                         thread_exception_return();
 261                         /* NOTREACHED */
 262                 }
 263         }
 264         switch (nargs) {
 265         case 0:
 266                 regs->eax = (*entry->routine.args_0)();
 267                 break;
 268         case 1:
 269                 regs->eax = (*entry->routine.args_1)(args[0]);
 270                 break;
 271         case 2:
 272                 regs->eax = (*entry->routine.args_2)(args[0],args[1]);
 273                 break;
 274         case 3:
 275                 if (!entry->bsd_style)
 276                         regs->eax = (*entry->routine.args_3)(args[0],args[1],args[2]);
 277                 else {
 278                         int     error;
 279                         uint32_t        rval;
 280
 281                         error = (*entry->routine.args_bsd_3)(&rval, args[0], args[1], args[2]);
 282                         if (error) {
 283                                 regs->eax = error;
 284                                 regs->efl |= EFL_CF;    /* carry bit */
 285                         } else {
 286                                 regs->eax = rval;
 287                                 regs->efl &= ~EFL_CF;
 288                         }
 289                 }
 290                 break;
 291         case 4:
 292                 regs->eax = (*entry->routine.args_4)(args[0], args[1], args[2], args[3]);
 293                 break;
 294
 295         default:
 296                 panic("machdep_syscall: too many args");
 297         }
 298         if (current_thread()->funnel_lock)
 299                 (void) thread_funnel_set(current_thread()->funnel_lock, FALSE);
 300
 301         DEBUG_KPRINT_SYSCALL_MDEP("machdep_syscall: retval=%u\n", regs->eax);
 302
 303         throttle_lowpri_io(TRUE);
 304
 305         thread_exception_return();
 306         /* NOTREACHED */
 307 }
 308
 309
 310 void
 311 machdep_syscall64(x86_saved_state_t *state)
 312 {
 313         int                     trapno;
 314         machdep_call_t          *entry;
 315         x86_saved_state64_t     *regs;
 316
 317         assert(is_saved_state64(state));
 318         regs = saved_state64(state);
 319
 320         trapno = (int)(regs->rax & SYSCALL_NUMBER_MASK);
 321
 322         DEBUG_KPRINT_SYSCALL_MDEP(
 323                 "machdep_syscall64: trapno=%d\n", trapno);
 324
 325         if (trapno < 0 || trapno >= machdep_call_count) {
 326                 regs->rax = (unsigned int)kern_invalid(NULL);
 327
 328                 thread_exception_return();
 329                 /* NOTREACHED */
 330         }
 331         entry = &machdep_call_table64[trapno];
 332
 333         switch (entry->nargs) {
 334         case 0:
 335                 regs->rax = (*entry->routine.args_0)();
 336                 break;
 337         case 1:
 338                 regs->rax = (*entry->routine.args64_1)(regs->rdi);
 339                 break;
 340         default:
 341                 panic("machdep_syscall64: too many args");
 342         }
 343         if (current_thread()->funnel_lock)
 344                 (void) thread_funnel_set(current_thread()->funnel_lock, FALSE);
 345
 346         DEBUG_KPRINT_SYSCALL_MDEP("machdep_syscall: retval=%llu\n", regs->rax);
 347
 348         throttle_lowpri_io(TRUE);
 349
 350         thread_exception_return();
 351         /* NOTREACHED */
 352 }
 353
 354 #endif  /* MACH_BSD */
 355
 356
 357 typedef kern_return_t (*mach_call_t)(void *);
 358
 359 struct mach_call_args {
 360         syscall_arg_t arg1;
 361         syscall_arg_t arg2;
 362         syscall_arg_t arg3;
 363         syscall_arg_t arg4;
 364         syscall_arg_t arg5;
 365         syscall_arg_t arg6;
 366         syscall_arg_t arg7;
 367         syscall_arg_t arg8;
 368         syscall_arg_t arg9;
 369 };
 370
 371 static kern_return_t
 372 mach_call_arg_munger32(uint32_t sp, int nargs, int call_number, struct mach_call_args *args);
 373
 374
 375 static kern_return_t
 376 mach_call_arg_munger32(uint32_t sp, int nargs, int call_number, struct mach_call_args *args)
 377 {
 378         unsigned int args32[9];
 379
 380         if (copyin((user_addr_t)(sp + sizeof(int)), (char *)args32, nargs * sizeof (int)))
 381                 return KERN_INVALID_ARGUMENT;
 382
 383         switch (nargs) {
 384         case 9: args->arg9 = args32[8];
 385         case 8: args->arg8 = args32[7];
 386         case 7: args->arg7 = args32[6];
 387         case 6: args->arg6 = args32[5];
 388         case 5: args->arg5 = args32[4];
 389         case 4: args->arg4 = args32[3];
 390         case 3: args->arg3 = args32[2];
 391         case 2: args->arg2 = args32[1];
 392         case 1: args->arg1 = args32[0];
 393         }
 394         if (call_number == 90) {
 395                 /* munge_l for mach_wait_until_trap() */
 396                 args->arg1 = (((uint64_t)(args32[0])) | ((((uint64_t)(args32[1]))<<32)));
 397         }
 398         if (call_number == 93) {
 399                 /* munge_wl for mk_timer_arm_trap() */
 400                 args->arg2 = (((uint64_t)(args32[1])) | ((((uint64_t)(args32[2]))<<32)));
 401         }
 402
 403         return KERN_SUCCESS;
 404 }
 405
 406
 407 __private_extern__ void mach_call_munger(x86_saved_state_t *state);
 408
 409 extern const char *mach_syscall_name_table[];
 410
 411 void
 412 mach_call_munger(x86_saved_state_t *state)
 413 {
 414         int argc;
 415         int call_number;
 416         mach_call_t mach_call;
 417         kern_return_t retval;
 418         struct mach_call_args args = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 419         x86_saved_state32_t     *regs;
 420
 421         assert(is_saved_state32(state));
 422         regs = saved_state32(state);
 423
 424         call_number = -(regs->eax);
 425
 426         DEBUG_KPRINT_SYSCALL_MACH(
 427                 "mach_call_munger: code=%d(%s)\n",
 428                 call_number, mach_syscall_name_table[call_number]);
 429 #if DEBUG_TRACE
 430         kprintf("mach_call_munger(0x%08x) code=%d\n", regs, call_number);
 431 #endif
 432
 433         if (call_number < 0 || call_number >= mach_trap_count) {
 434                 i386_exception(EXC_SYSCALL, call_number, 1);
 435                 /* NOTREACHED */
 436         }
 437         mach_call = (mach_call_t)mach_trap_table[call_number].mach_trap_function;
 438
 439         if (mach_call == (mach_call_t)kern_invalid) {
 440                 DEBUG_KPRINT_SYSCALL_MACH(
 441                         "mach_call_munger: kern_invalid 0x%x\n", regs->eax);
 442                 i386_exception(EXC_SYSCALL, call_number, 1);
 443                 /* NOTREACHED */
 444         }
 445
 446         argc = mach_trap_table[call_number].mach_trap_arg_count;
 447         if (argc) {
 448                 retval = mach_call_arg_munger32(regs->uesp, argc, call_number, &args);
 449                 if (retval != KERN_SUCCESS) {
 450                         regs->eax = retval;
 451
 452                         DEBUG_KPRINT_SYSCALL_MACH(
 453                                 "mach_call_munger: retval=0x%x\n", retval);
 454
 455                         thread_exception_return();
 456                         /* NOTREACHED */
 457                 }
 458         }
 459
 460 #ifdef MACH_BSD
 461         mach_kauth_cred_uthread_update();
 462 #endif
 463         KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_EXCP_SC, (call_number)) | DBG_FUNC_START,
 464                         args.arg1, args.arg2, args.arg3, args.arg4, 0);
 465
 466         retval = mach_call(&args);
 467
 468         DEBUG_KPRINT_SYSCALL_MACH("mach_call_munger: retval=0x%x\n", retval);
 469
 470         KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_EXCP_SC,(call_number)) | DBG_FUNC_END,
 471                         retval, 0, 0, 0, 0);
 472         regs->eax = retval;
 473
 474         throttle_lowpri_io(TRUE);
 475
 476         thread_exception_return();
 477         /* NOTREACHED */
 478 }
 479
 480
 481 __private_extern__ void mach_call_munger64(x86_saved_state_t *regs);
 482
 483 void
 484 mach_call_munger64(x86_saved_state_t *state)
 485 {
 486         int call_number;
 487         int argc;
 488         mach_call_t mach_call;
 489         x86_saved_state64_t     *regs;
 490
 491         assert(is_saved_state64(state));
 492         regs = saved_state64(state);
 493
 494         call_number = (int)(regs->rax & SYSCALL_NUMBER_MASK);
 495
 496         DEBUG_KPRINT_SYSCALL_MACH(
 497                 "mach_call_munger64: code=%d(%s)\n",
 498                 call_number, mach_syscall_name_table[call_number]);
 499
 500         KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_EXCP_SC,
 501                                            (call_number)) | DBG_FUNC_START,
 502                               regs->rdi, regs->rsi,
 503                               regs->rdx, regs->r10, 0);
 504
 505         if (call_number < 0 || call_number >= mach_trap_count) {
 506                 i386_exception(EXC_SYSCALL, regs->rax, 1);
 507                 /* NOTREACHED */
 508         }
 509         mach_call = (mach_call_t)mach_trap_table[call_number].mach_trap_function;
 510
 511         if (mach_call == (mach_call_t)kern_invalid) {
 512                 i386_exception(EXC_SYSCALL, regs->rax, 1);
 513                 /* NOTREACHED */
 514         }
 515         argc = mach_trap_table[call_number].mach_trap_arg_count;
 516
 517         if (argc > 6) {
 518                 int copyin_count;
 519
 520                 copyin_count = (argc - 6) * (int)sizeof(uint64_t);
 521
 522                 if (copyin((user_addr_t)(regs->isf.rsp + sizeof(user_addr_t)), (char *)&regs->v_arg6, copyin_count)) {
 523                         regs->rax = KERN_INVALID_ARGUMENT;
 524
 525                         thread_exception_return();
 526                         /* NOTREACHED */
 527                 }
 528         }
 529
 530 #ifdef MACH_BSD
 531         mach_kauth_cred_uthread_update();
 532 #endif
 533
 534         regs->rax = (uint64_t)mach_call((void *)(&regs->rdi));
 535
 536         DEBUG_KPRINT_SYSCALL_MACH( "mach_call_munger64: retval=0x%llx\n", regs->rax);
 537
 538         KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_EXCP_SC,
 539                                            (call_number)) | DBG_FUNC_END,
 540                               regs->rax, 0, 0, 0, 0);
 541
 542         throttle_lowpri_io(TRUE);
 543
 544         thread_exception_return();
 545         /* NOTREACHED */
 546 }
 547
 548
 549 /*
 550  * thread_setuserstack:
 551  *
 552  * Sets the user stack pointer into the machine
 553  * dependent thread state info.
 554  */
 555 void
 556 thread_setuserstack(
 557         thread_t        thread,
 558         mach_vm_address_t       user_stack)
 559 {
 560         pal_register_cache_state(thread, DIRTY);
 561         if (thread_is_64bit(thread)) {
 562                 x86_saved_state64_t     *iss64;
 563
 564                 iss64 = USER_REGS64(thread);
 565
 566                 iss64->isf.rsp = (uint64_t)user_stack;
 567         } else {
 568                 x86_saved_state32_t     *iss32;
 569
 570                 iss32 = USER_REGS32(thread);
 571
 572                 iss32->uesp = CAST_DOWN_EXPLICIT(unsigned int, user_stack);
 573         }
 574 }
 575
 576 /*
 577  * thread_adjuserstack:
 578  *
 579  * Returns the adjusted user stack pointer from the machine
 580  * dependent thread state info.  Used for small (<2G) deltas.
 581  */
 582 uint64_t
 583 thread_adjuserstack(
 584         thread_t        thread,
 585         int             adjust)
 586 {
 587         pal_register_cache_state(thread, DIRTY);
 588         if (thread_is_64bit(thread)) {
 589                 x86_saved_state64_t     *iss64;
 590
 591                 iss64 = USER_REGS64(thread);
 592
 593                 iss64->isf.rsp += adjust;
 594
 595                 return iss64->isf.rsp;
 596         } else {
 597                 x86_saved_state32_t     *iss32;
 598
 599                 iss32 = USER_REGS32(thread);
 600
 601                 iss32->uesp += adjust;
 602
 603                 return CAST_USER_ADDR_T(iss32->uesp);
 604         }
 605 }
 606
 607 /*
 608  * thread_setentrypoint:
 609  *
 610  * Sets the user PC into the machine
 611  * dependent thread state info.
 612  */
 613 void
 614 thread_setentrypoint(thread_t thread, mach_vm_address_t entry)
 615 {
 616         pal_register_cache_state(thread, DIRTY);
 617         if (thread_is_64bit(thread)) {
 618                 x86_saved_state64_t     *iss64;
 619
 620                 iss64 = USER_REGS64(thread);
 621
 622                 iss64->isf.rip = (uint64_t)entry;
 623         } else {
 624                 x86_saved_state32_t     *iss32;
 625
 626                 iss32 = USER_REGS32(thread);
 627
 628                 iss32->eip = CAST_DOWN_EXPLICIT(unsigned int, entry);
 629         }
 630 }
 631
 632
 633 kern_return_t
 634 thread_setsinglestep(thread_t thread, int on)
 635 {
 636         pal_register_cache_state(thread, DIRTY);
 637         if (thread_is_64bit(thread)) {
 638                 x86_saved_state64_t     *iss64;
 639
 640                 iss64 = USER_REGS64(thread);
 641
 642                 if (on)
 643                         iss64->isf.rflags |= EFL_TF;
 644                 else
 645                         iss64->isf.rflags &= ~EFL_TF;
 646         } else {
 647                 x86_saved_state32_t     *iss32;
 648
 649                 iss32 = USER_REGS32(thread);
 650
 651                 if (on) {
 652                         iss32->efl |= EFL_TF;
 653                         /* Ensure IRET */
 654                         if (iss32->cs == SYSENTER_CS)
 655                                 iss32->cs = SYSENTER_TF_CS;
 656                 }
 657                 else
 658                         iss32->efl &= ~EFL_TF;
 659         }
 660
 661         return (KERN_SUCCESS);
 662 }
 663
 664
 665
 666 /* XXX this should be a struct savearea so that CHUD will work better on x86 */
 667 void *
 668 find_user_regs(thread_t thread)
 669 {
 670         pal_register_cache_state(thread, DIRTY);
 671         return USER_STATE(thread);
 672 }
 673
 674 void *
 675 get_user_regs(thread_t th)
 676 {
 677         pal_register_cache_state(th, DIRTY);
 678         return(USER_STATE(th));
 679 }
 680
 681 #if CONFIG_DTRACE
 682 /*
 683  * DTrace would like to have a peek at the kernel interrupt state, if available.
 684  * Based on osfmk/chud/i386/chud_thread_i386.c:chudxnu_thread_get_state(), which see.
 685  */
 686 x86_saved_state_t *find_kern_regs(thread_t);
 687
 688 x86_saved_state_t *
 689 find_kern_regs(thread_t thread)
 690 {
 691         if (thread == current_thread() &&
 692                 NULL != current_cpu_datap()->cpu_int_state &&
 693                 !(USER_STATE(thread) == current_cpu_datap()->cpu_int_state &&
 694                   current_cpu_datap()->cpu_interrupt_level == 1)) {
 695
 696                 return current_cpu_datap()->cpu_int_state;
 697         } else {
 698                 return NULL;
 699         }
 700 }
 701
 702 vm_offset_t dtrace_get_cpu_int_stack_top(void);
 703
 704 vm_offset_t
 705 dtrace_get_cpu_int_stack_top(void)
 706 {
 707         return current_cpu_datap()->cpu_int_stack_top;
 708 }
 709 #endif