![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to i386_lock.s CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / i386|
Return to i386_lock.s CVS log | Up to [Apple XNU] / XNU / osfmk / i386 |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* ! 23: * @OSF_COPYRIGHT@ ! 24: */ ! 25: /* ! 26: * Mach Operating System ! 27: * Copyright (c) 1989 Carnegie-Mellon University ! 28: * All rights reserved. The CMU software License Agreement specifies ! 29: * the terms and conditions for use and redistribution. ! 30: */ ! 31: ! 32: #include <cpus.h> ! 33: #include <mach_rt.h> ! 34: #include <platforms.h> ! 35: #include <mach_ldebug.h> ! 36: #include <i386/asm.h> ! 37: #include <assym.s> ! 38: #include <kern/etap_options.h> ! 39: ! 40: ! 41: /* ! 42: * When performance isn't the only concern, it's ! 43: * nice to build stack frames... ! 44: */ ! 45: #define BUILD_STACK_FRAMES ((MACH_LDEBUG || ETAP_LOCK_TRACE) && MACH_KDB) ! 46: ! 47: #if BUILD_STACK_FRAMES ! 48: ! 49: #define L_PC 4(%ebp) ! 50: #define L_ARG0 8(%ebp) ! 51: #define L_ARG1 12(%ebp) ! 52: ! 53: #define SWT_HI -4(%ebp) ! 54: #define SWT_LO -8(%ebp) ! 55: #define MISSED -12(%ebp) ! 56: ! 57: #else /* BUILD_STACK_FRAMES */ ! 58: ! 59: #undef FRAME ! 60: #undef EMARF ! 61: #define FRAME ! 62: #define EMARF ! 63: #define L_PC (%esp) ! 64: #define L_ARG0 4(%esp) ! 65: #define L_ARG1 8(%esp) ! 66: ! 67: #endif /* BUILD_STACK_FRAMES */ ! 68: ! 69: ! 70: #define M_ILK (%edx) ! 71: #define M_LOCKED 1(%edx) ! 72: #define M_WAITERS 2(%edx) ! 73: #if MACH_LDEBUG ! 74: #define M_TYPE 4(%edx) ! 75: #define M_PC 8(%edx) ! 76: #define M_THREAD 12(%edx) ! 77: #endif /* MACH_LDEBUG */ ! 78: ! 79: #include <i386/AT386/mp/mp.h> ! 80: #if (NCPUS > 1) ! 81: #define CX(addr,reg) addr(,reg,4) ! 82: #else ! 83: #define CPU_NUMBER(reg) ! 84: #define CX(addr,reg) addr ! 85: #endif /* (NCPUS > 1) */ ! 86: ! 87: #if MACH_LDEBUG ! 88: /* ! 89: * Routines for general lock debugging. ! 90: */ ! 91: #define S_TYPE 4(%edx) ! 92: #define S_PC 8(%edx) ! 93: #define S_THREAD 12(%edx) ! 94: #define S_DURATIONH 16(%edx) ! 95: #define S_DURATIONL 20(%edx) ! 96: ! 97: /* ! 98: * Checks for expected lock types and calls "panic" on ! 99: * mismatch. Detects calls to Mutex functions with ! 100: * type simplelock and vice versa. ! 101: */ ! 102: #define CHECK_MUTEX_TYPE() \ ! 103: cmpl $MUTEX_TAG, M_TYPE ; \ ! 104: je 1f ; \ ! 105: pushl $2f ; \ ! 106: call EXT(panic) ; \ ! 107: hlt ; \ ! 108: .data ; \ ! 109: 2: String "not a mutex!" ; \ ! 110: .text ; \ ! 111: 1: ! 112: ! 113: #define CHECK_SIMPLE_LOCK_TYPE() \ ! 114: cmpl $SIMPLE_LOCK_TAG,S_TYPE ; \ ! 115: je 1f ; \ ! 116: pushl $2f ; \ ! 117: call EXT(panic) ; \ ! 118: hlt ; \ ! 119: .data ; \ ! 120: 2: String "not a simple lock!" ; \ ! 121: .text ; \ ! 122: 1: ! 123: ! 124: /* ! 125: * If one or more simplelocks are currently held by a thread, ! 126: * an attempt to acquire a mutex will cause this check to fail ! 127: * (since a mutex lock may context switch, holding a simplelock ! 128: * is not a good thing). ! 129: */ ! 130: #if 0 /*MACH_RT - 11/12/99 - [email protected] disable check for now*/ ! 131: #define CHECK_PREEMPTION_LEVEL() \ ! 132: movl $CPD_PREEMPTION_LEVEL,%eax ; \ ! 133: cmpl $0,%gs:(%eax) ; \ ! 134: je 1f ; \ ! 135: pushl $2f ; \ ! 136: call EXT(panic) ; \ ! 137: hlt ; \ ! 138: .data ; \ ! 139: 2: String "preemption_level != 0!" ; \ ! 140: .text ; \ ! 141: 1: ! 142: #else /* MACH_RT */ ! 143: #define CHECK_PREEMPTION_LEVEL() ! 144: #endif /* MACH_RT */ ! 145: ! 146: #define CHECK_NO_SIMPLELOCKS() \ ! 147: movl $CPD_SIMPLE_LOCK_COUNT,%eax ; \ ! 148: cmpl $0,%gs:(%eax) ; \ ! 149: je 1f ; \ ! 150: pushl $2f ; \ ! 151: call EXT(panic) ; \ ! 152: hlt ; \ ! 153: .data ; \ ! 154: 2: String "simple_locks_held!" ; \ ! 155: .text ; \ ! 156: 1: ! 157: ! 158: /* ! 159: * Verifies return to the correct thread in "unlock" situations. ! 160: */ ! 161: #define CHECK_THREAD(thd) \ ! 162: movl $CPD_ACTIVE_THREAD,%eax ; \ ! 163: movl %gs:(%eax),%ecx ; \ ! 164: testl %ecx,%ecx ; \ ! 165: je 1f ; \ ! 166: cmpl %ecx,thd ; \ ! 167: je 1f ; \ ! 168: pushl $2f ; \ ! 169: call EXT(panic) ; \ ! 170: hlt ; \ ! 171: .data ; \ ! 172: 2: String "wrong thread!" ; \ ! 173: .text ; \ ! 174: 1: ! 175: ! 176: #define CHECK_MYLOCK(thd) \ ! 177: movl $CPD_ACTIVE_THREAD,%eax ; \ ! 178: movl %gs:(%eax),%ecx ; \ ! 179: testl %ecx,%ecx ; \ ! 180: je 1f ; \ ! 181: cmpl %ecx,thd ; \ ! 182: jne 1f ; \ ! 183: pushl $2f ; \ ! 184: call EXT(panic) ; \ ! 185: hlt ; \ ! 186: .data ; \ ! 187: 2: String "mylock attempt!" ; \ ! 188: .text ; \ ! 189: 1: ! 190: ! 191: #define METER_SIMPLE_LOCK_LOCK(reg) \ ! 192: pushl reg ; \ ! 193: call EXT(meter_simple_lock) ; \ ! 194: popl reg ! 195: ! 196: #define METER_SIMPLE_LOCK_UNLOCK(reg) \ ! 197: pushl reg ; \ ! 198: call EXT(meter_simple_unlock) ; \ ! 199: popl reg ! 200: ! 201: #else /* MACH_LDEBUG */ ! 202: #define CHECK_MUTEX_TYPE() ! 203: #define CHECK_SIMPLE_LOCK_TYPE ! 204: #define CHECK_THREAD(thd) ! 205: #define CHECK_PREEMPTION_LEVEL() ! 206: #define CHECK_NO_SIMPLELOCKS() ! 207: #define CHECK_MYLOCK(thd) ! 208: #define METER_SIMPLE_LOCK_LOCK(reg) ! 209: #define METER_SIMPLE_LOCK_UNLOCK(reg) ! 210: #endif /* MACH_LDEBUG */ ! 211: ! 212: ! 213: /* ! 214: * void hw_lock_init(hw_lock_t) ! 215: * ! 216: * Initialize a hardware lock. ! 217: */ ! 218: ENTRY(hw_lock_init) ! 219: FRAME ! 220: movl L_ARG0,%edx /* fetch lock pointer */ ! 221: xorl %eax,%eax ! 222: movb %al,0(%edx) /* clear the lock */ ! 223: EMARF ! 224: ret ! 225: ! 226: /* ! 227: * void hw_lock_lock(hw_lock_t) ! 228: * ! 229: * Acquire lock, spinning until it becomes available. ! 230: * MACH_RT: also return with preemption disabled. ! 231: */ ! 232: ENTRY(hw_lock_lock) ! 233: FRAME ! 234: movl L_ARG0,%edx /* fetch lock pointer */ ! 235: ! 236: 1: DISABLE_PREEMPTION(%eax) ! 237: movb $1,%cl ! 238: xchgb 0(%edx),%cl /* try to acquire the HW lock */ ! 239: testb %cl,%cl /* success? */ ! 240: jne 3f ! 241: ! 242: EMARF /* if yes, then nothing left to do */ ! 243: ret ! 244: ! 245: 3: ENABLE_PREEMPTION(%eax) /* no reason we can't be preemptable now */ ! 246: ! 247: movb $1,%cl ! 248: 2: testb %cl,0(%edx) /* spin checking lock value in cache */ ! 249: jne 2b /* non-zero means locked, keep spinning */ ! 250: jmp 1b /* zero means unlocked, try to grab it */ ! 251: ! 252: /* ! 253: * void hw_lock_unlock(hw_lock_t) ! 254: * ! 255: * Unconditionally release lock. ! 256: * MACH_RT: release preemption level. ! 257: */ ! 258: ENTRY(hw_lock_unlock) ! 259: FRAME ! 260: movl L_ARG0,%edx /* fetch lock pointer */ ! 261: xorl %eax,%eax ! 262: xchgb 0(%edx),%al /* clear the lock... a mov instruction */ ! 263: /* ...might be cheaper and less paranoid */ ! 264: ENABLE_PREEMPTION(%eax) ! 265: EMARF ! 266: ret ! 267: ! 268: /* ! 269: * unsigned int hw_lock_try(hw_lock_t) ! 270: * MACH_RT: returns with preemption disabled on success. ! 271: */ ! 272: ENTRY(hw_lock_try) ! 273: FRAME ! 274: movl L_ARG0,%edx /* fetch lock pointer */ ! 275: ! 276: DISABLE_PREEMPTION(%eax) ! 277: movb $1,%cl ! 278: xchgb 0(%edx),%cl /* try to acquire the HW lock */ ! 279: testb %cl,%cl /* success? */ ! 280: jne 1f /* if yes, let the caller know */ ! 281: ! 282: movl $1,%eax /* success */ ! 283: EMARF ! 284: ret ! 285: ! 286: 1: ENABLE_PREEMPTION(%eax) /* failure: release preemption... */ ! 287: xorl %eax,%eax /* ...and return failure */ ! 288: EMARF ! 289: ret ! 290: ! 291: /* ! 292: * unsigned int hw_lock_held(hw_lock_t) ! 293: * MACH_RT: doesn't change preemption state. ! 294: * N.B. Racy, of course. ! 295: */ ! 296: ENTRY(hw_lock_held) ! 297: FRAME ! 298: movl L_ARG0,%edx /* fetch lock pointer */ ! 299: ! 300: movb $1,%cl ! 301: testb %cl,0(%edx) /* check lock value */ ! 302: jne 1f /* non-zero means locked */ ! 303: xorl %eax,%eax /* tell caller: lock wasn't locked */ ! 304: EMARF ! 305: ret ! 306: ! 307: 1: movl $1,%eax /* tell caller: lock was locked */ ! 308: EMARF ! 309: ret ! 310: ! 311: ! 312: ! 313: #if 0 ! 314: ! 315: ! 316: ENTRY(_usimple_lock_init) ! 317: FRAME ! 318: movl L_ARG0,%edx /* fetch lock pointer */ ! 319: xorl %eax,%eax ! 320: movb %al,USL_INTERLOCK(%edx) /* unlock the HW lock */ ! 321: EMARF ! 322: ret ! 323: ! 324: ENTRY(_simple_lock) ! 325: FRAME ! 326: movl L_ARG0,%edx /* fetch lock pointer */ ! 327: ! 328: CHECK_SIMPLE_LOCK_TYPE() ! 329: ! 330: DISABLE_PREEMPTION(%eax) ! 331: ! 332: sl_get_hw: ! 333: movb $1,%cl ! 334: xchgb USL_INTERLOCK(%edx),%cl /* try to acquire the HW lock */ ! 335: testb %cl,%cl /* did we succeed? */ ! 336: ! 337: #if MACH_LDEBUG ! 338: je 5f ! 339: CHECK_MYLOCK(S_THREAD) ! 340: jmp sl_get_hw ! 341: 5: ! 342: #else /* MACH_LDEBUG */ ! 343: jne sl_get_hw /* no, try again */ ! 344: #endif /* MACH_LDEBUG */ ! 345: ! 346: #if MACH_LDEBUG ! 347: movl L_PC,%ecx ! 348: movl %ecx,S_PC ! 349: movl $CPD_ACTIVE_THREAD,%eax ! 350: movl %gs:(%eax),%ecx ! 351: movl %ecx,S_THREAD ! 352: incl CX(EXT(simple_lock_count),%eax) ! 353: #if 0 ! 354: METER_SIMPLE_LOCK_LOCK(%edx) ! 355: #endif ! 356: #if NCPUS == 1 ! 357: pushf ! 358: pushl %edx ! 359: cli ! 360: call EXT(lock_stack_push) ! 361: popl %edx ! 362: popfl ! 363: #endif /* NCPUS == 1 */ ! 364: #endif /* MACH_LDEBUG */ ! 365: ! 366: EMARF ! 367: ret ! 368: ! 369: ENTRY(_simple_lock_try) ! 370: FRAME ! 371: movl L_ARG0,%edx /* fetch lock pointer */ ! 372: ! 373: CHECK_SIMPLE_LOCK_TYPE() ! 374: ! 375: DISABLE_PREEMPTION(%eax) ! 376: ! 377: movb $1,%cl ! 378: xchgb USL_INTERLOCK(%edx),%cl /* try to acquire the HW lock */ ! 379: testb %cl,%cl /* did we succeed? */ ! 380: jne 1f /* no, return failure */ ! 381: ! 382: #if MACH_LDEBUG ! 383: movl L_PC,%ecx ! 384: movl %ecx,S_PC ! 385: movl $CPD_ACTIVE_THREAD,%eax ! 386: movl %gs:(%eax),%ecx ! 387: movl %ecx,S_THREAD ! 388: incl CX(EXT(simple_lock_count),%eax) ! 389: #if 0 ! 390: METER_SIMPLE_LOCK_LOCK(%edx) ! 391: #endif ! 392: #if NCPUS == 1 ! 393: pushf ! 394: pushl %edx ! 395: cli ! 396: call EXT(lock_stack_push) ! 397: popl %edx ! 398: popfl ! 399: #endif /* NCPUS == 1 */ ! 400: #endif /* MACH_LDEBUG */ ! 401: ! 402: movl $1,%eax /* return success */ ! 403: ! 404: EMARF ! 405: ret ! 406: ! 407: 1: ! 408: ENABLE_PREEMPTION(%eax) ! 409: ! 410: xorl %eax,%eax /* and return failure */ ! 411: ! 412: EMARF ! 413: ret ! 414: ! 415: ENTRY(_simple_unlock) ! 416: FRAME ! 417: movl L_ARG0,%edx /* fetch lock pointer */ ! 418: ! 419: CHECK_SIMPLE_LOCK_TYPE() ! 420: CHECK_THREAD(S_THREAD) ! 421: ! 422: #if MACH_LDEBUG ! 423: xorl %eax,%eax ! 424: movl %eax,S_THREAD /* disown thread */ ! 425: MP_DISABLE_PREEMPTION(%eax) ! 426: CPU_NUMBER(%eax) ! 427: decl CX(EXT(simple_lock_count),%eax) ! 428: MP_ENABLE_PREEMPTION(%eax) ! 429: #if 0 ! 430: METER_SIMPLE_LOCK_UNLOCK(%edx) ! 431: #endif ! 432: #if NCPUS == 1 ! 433: pushf ! 434: pushl %edx ! 435: cli ! 436: call EXT(lock_stack_pop) ! 437: popl %edx ! 438: popfl ! 439: #endif /* NCPUS == 1 */ ! 440: #endif /* MACH_LDEBUG */ ! 441: ! 442: xorb %cl,%cl ! 443: xchgb USL_INTERLOCK(%edx),%cl /* unlock the HW lock */ ! 444: ! 445: ENABLE_PREEMPTION(%eax) ! 446: ! 447: EMARF ! 448: ret ! 449: ! 450: #endif /* 0 */ ! 451: ! 452: ! 453: ENTRY(mutex_init) ! 454: FRAME ! 455: movl L_ARG0,%edx /* fetch lock pointer */ ! 456: xorl %eax,%eax ! 457: movb %al,M_ILK /* clear interlock */ ! 458: movb %al,M_LOCKED /* clear locked flag */ ! 459: movw %ax,M_WAITERS /* init waiter count */ ! 460: ! 461: #if MACH_LDEBUG ! 462: movl $MUTEX_TAG,M_TYPE /* set lock type */ ! 463: movl %eax,M_PC /* init caller pc */ ! 464: movl %eax,M_THREAD /* and owning thread */ ! 465: #endif ! 466: #if ETAP_LOCK_TRACE ! 467: movl L_ARG1,%ecx /* fetch event type */ ! 468: pushl %ecx /* push event type */ ! 469: pushl %edx /* push mutex address */ ! 470: call EXT(etap_mutex_init) /* init ETAP data */ ! 471: addl $8,%esp ! 472: #endif /* ETAP_LOCK_TRACE */ ! 473: ! 474: EMARF ! 475: ret ! 476: ! 477: ENTRY(_mutex_lock) ! 478: FRAME ! 479: ! 480: #if ETAP_LOCK_TRACE ! 481: subl $12,%esp /* make room for locals */ ! 482: movl $0,SWT_HI /* set wait time to zero (HI) */ ! 483: movl $0,SWT_LO /* set wait time to zero (LO) */ ! 484: movl $0,MISSED /* clear local miss marker */ ! 485: #endif /* ETAP_LOCK_TRACE */ ! 486: ! 487: movl L_ARG0,%edx /* fetch lock pointer */ ! 488: ! 489: CHECK_MUTEX_TYPE() ! 490: CHECK_NO_SIMPLELOCKS() ! 491: CHECK_PREEMPTION_LEVEL() ! 492: ! 493: ml_retry: ! 494: DISABLE_PREEMPTION(%eax) ! 495: ! 496: ml_get_hw: ! 497: movb $1,%cl ! 498: xchgb %cl,M_ILK ! 499: testb %cl,%cl /* did we succeed? */ ! 500: jne ml_get_hw /* no, try again */ ! 501: ! 502: /* ! 503: / Beware of a race between this code path and the inline ASM fast-path locking ! 504: / sequence which attempts to lock a mutex by directly setting the locked flag ! 505: / ! 506: */ ! 507: ! 508: movb $1,%cl ! 509: xchgb %cl,M_LOCKED /* try to set locked flag */ ! 510: testb %cl,%cl /* is the mutex locked? */ ! 511: jne ml_fail /* yes, we lose */ ! 512: ! 513: #if MACH_LDEBUG ! 514: movl L_PC,%ecx ! 515: movl %ecx,M_PC ! 516: movl $CPD_ACTIVE_THREAD,%eax ! 517: movl %gs:(%eax),%ecx ! 518: movl %ecx,M_THREAD ! 519: testl %ecx,%ecx ! 520: je 3f ! 521: incl TH_MUTEX_COUNT(%ecx) ! 522: 3: ! 523: #endif ! 524: ! 525: xorb %cl,%cl ! 526: xchgb %cl,M_ILK ! 527: ! 528: ENABLE_PREEMPTION(%eax) ! 529: ! 530: #if ETAP_LOCK_TRACE ! 531: movl L_PC,%eax /* fetch pc */ ! 532: pushl SWT_LO /* push wait time (low) */ ! 533: pushl SWT_HI /* push wait time (high) */ ! 534: pushl %eax /* push pc */ ! 535: pushl %edx /* push mutex address */ ! 536: call EXT(etap_mutex_hold) /* collect hold timestamp */ ! 537: addl $16+12,%esp /* clean up stack, adjusting for locals */ ! 538: #endif /* ETAP_LOCK_TRACE */ ! 539: ! 540: EMARF ! 541: ret ! 542: ! 543: ml_fail: ! 544: #if ETAP_LOCK_TRACE ! 545: cmp $0,MISSED /* did we already take a wait timestamp? */ ! 546: jne ml_block /* yup. carry-on */ ! 547: pushl %edx /* push mutex address */ ! 548: call EXT(etap_mutex_miss) /* get wait timestamp */ ! 549: movl %eax,SWT_HI /* set wait time (high word) */ ! 550: movl %edx,SWT_LO /* set wait time (low word) */ ! 551: popl %edx /* clean up stack */ ! 552: movl $1,MISSED /* mark wait timestamp as taken */ ! 553: #endif /* ETAP_LOCK_TRACE */ ! 554: ! 555: ml_block: ! 556: CHECK_MYLOCK(M_THREAD) ! 557: pushl %edx /* push mutex address */ ! 558: call EXT(mutex_lock_wait) /* wait for the lock */ ! 559: addl $4,%esp ! 560: movl L_ARG0,%edx /* refetch lock pointer */ ! 561: jmp ml_retry /* and try again */ ! 562: ! 563: ENTRY(_mutex_try) ! 564: FRAME ! 565: ! 566: #if ETAP_LOCK_TRACE ! 567: subl $8,%esp /* make room for locals */ ! 568: movl $0,SWT_HI /* set wait time to zero (HI) */ ! 569: movl $0,SWT_LO /* set wait time to zero (LO) */ ! 570: #endif /* ETAP_LOCK_TRACE */ ! 571: ! 572: movl L_ARG0,%edx /* fetch lock pointer */ ! 573: ! 574: CHECK_MUTEX_TYPE() ! 575: CHECK_NO_SIMPLELOCKS() ! 576: ! 577: xorl %eax,%eax ! 578: movb $1,%al /* locked value for mutex */ ! 579: xchgb %al,M_LOCKED /* swap locked values */ ! 580: xorb $1,%al /* generate return value */ ! 581: ! 582: #if MACH_LDEBUG || ETAP_LOCK_TRACE ! 583: testl %eax,%eax /* did we succeed? */ ! 584: je 2f /* no, skip */ ! 585: #endif ! 586: ! 587: #if MACH_LDEBUG ! 588: movl L_PC,%ecx ! 589: movl %ecx,M_PC ! 590: movl $CPD_ACTIVE_THREAD,%ecx ! 591: movl %gs:(%ecx),%ecx ! 592: movl %ecx,M_THREAD ! 593: testl %ecx,%ecx ! 594: je 1f ! 595: incl TH_MUTEX_COUNT(%ecx) ! 596: 1: ! 597: #endif ! 598: ! 599: #if ETAP_LOCK_TRACE ! 600: movl L_PC,%eax /* fetch pc */ ! 601: pushl SWT_LO /* push wait time (low) */ ! 602: pushl SWT_HI /* push wait time (high) */ ! 603: pushl %eax /* push pc */ ! 604: pushl %edx /* push mutex address */ ! 605: call EXT(etap_mutex_hold) /* get start hold timestamp */ ! 606: addl $16,%esp /* clean up stack, adjusting for locals */ ! 607: movl $1,%eax /* put back successful return value */ ! 608: #endif /* ETAP_LOCK_TRACE */ ! 609: ! 610: #if MACH_LDEBUG || ETAP_LOCK_TRACE ! 611: 2: ! 612: #if ETAP_LOCK_TRACE ! 613: addl $8,%esp /* pop stack claimed on entry */ ! 614: #endif ! 615: #endif ! 616: ! 617: EMARF ! 618: ret ! 619: ! 620: ENTRY(mutex_unlock) ! 621: FRAME ! 622: movl L_ARG0,%edx /* fetch lock pointer */ ! 623: ! 624: #if ETAP_LOCK_TRACE ! 625: pushl %edx /* push mutex address */ ! 626: call EXT(etap_mutex_unlock) /* collect ETAP data */ ! 627: popl %edx /* restore mutex address */ ! 628: #endif /* ETAP_LOCK_TRACE */ ! 629: ! 630: CHECK_MUTEX_TYPE() ! 631: CHECK_THREAD(M_THREAD) ! 632: ! 633: DISABLE_PREEMPTION(%eax) ! 634: ! 635: mu_get_hw: ! 636: movb $1,%cl ! 637: xchgb %cl,M_ILK ! 638: testb %cl,%cl /* did we succeed? */ ! 639: jne mu_get_hw /* no, try again */ ! 640: ! 641: cmpw $0,M_WAITERS /* are there any waiters? */ ! 642: jne mu_wakeup /* yes, more work to do */ ! 643: ! 644: mu_doit: ! 645: #if MACH_LDEBUG ! 646: xorl %eax,%eax ! 647: movl %eax,M_THREAD /* disown thread */ ! 648: movl $CPD_ACTIVE_THREAD,%eax ! 649: movl %gs:(%eax),%ecx ! 650: testl %ecx,%ecx ! 651: je 0f ! 652: decl TH_MUTEX_COUNT(%ecx) ! 653: 0: ! 654: #endif ! 655: ! 656: xorb %cl,%cl ! 657: xchgb %cl,M_LOCKED /* unlock the mutex */ ! 658: ! 659: xorb %cl,%cl ! 660: xchgb %cl,M_ILK ! 661: ! 662: ENABLE_PREEMPTION(%eax) ! 663: ! 664: EMARF ! 665: ret ! 666: ! 667: mu_wakeup: ! 668: pushl %edx /* push mutex address */ ! 669: call EXT(mutex_unlock_wakeup)/* yes, wake a thread */ ! 670: addl $4,%esp ! 671: movl L_ARG0,%edx /* refetch lock pointer */ ! 672: jmp mu_doit ! 673: ! 674: ENTRY(interlock_unlock) ! 675: FRAME ! 676: movl L_ARG0,%edx ! 677: ! 678: xorb %cl,%cl ! 679: xchgb %cl,M_ILK ! 680: ! 681: ENABLE_PREEMPTION(%eax) ! 682: ! 683: EMARF ! 684: ret ! 685: ! 686: ! 687: ENTRY(_disable_preemption) ! 688: #if MACH_RT ! 689: _DISABLE_PREEMPTION(%eax) ! 690: #endif /* MACH_RT */ ! 691: ret ! 692: ! 693: ENTRY(_enable_preemption) ! 694: #if MACH_RT ! 695: #if MACH_ASSERT ! 696: movl $CPD_PREEMPTION_LEVEL,%eax ! 697: cmpl $0,%gs:(%eax) ! 698: jg 1f ! 699: pushl %gs:(%eax) ! 700: pushl $2f ! 701: call EXT(panic) ! 702: hlt ! 703: .data ! 704: 2: String "_enable_preemption: preemption_level(%d) < 0!" ! 705: .text ! 706: 1: ! 707: #endif /* MACH_ASSERT */ ! 708: _ENABLE_PREEMPTION(%eax) ! 709: #endif /* MACH_RT */ ! 710: ret ! 711: ! 712: ENTRY(_enable_preemption_no_check) ! 713: #if MACH_RT ! 714: #if MACH_ASSERT ! 715: movl $CPD_PREEMPTION_LEVEL,%eax ! 716: cmpl $0,%gs:(%eax) ! 717: jg 1f ! 718: pushl $2f ! 719: call EXT(panic) ! 720: hlt ! 721: .data ! 722: 2: String "_enable_preemption_no_check: preemption_level <= 0!" ! 723: .text ! 724: 1: ! 725: #endif /* MACH_ASSERT */ ! 726: _ENABLE_PREEMPTION_NO_CHECK(%eax) ! 727: #endif /* MACH_RT */ ! 728: ret ! 729: ! 730: ! 731: ENTRY(_mp_disable_preemption) ! 732: #if MACH_RT && NCPUS > 1 ! 733: _DISABLE_PREEMPTION(%eax) ! 734: #endif /* MACH_RT && NCPUS > 1*/ ! 735: ret ! 736: ! 737: ENTRY(_mp_enable_preemption) ! 738: #if MACH_RT && NCPUS > 1 ! 739: #if MACH_ASSERT ! 740: movl $CPD_PREEMPTION_LEVEL,%eax ! 741: cmpl $0,%gs:(%eax) ! 742: jg 1f ! 743: pushl %gs:(%eax) ! 744: pushl $2f ! 745: call EXT(panic) ! 746: hlt ! 747: .data ! 748: 2: String "_mp_enable_preemption: preemption_level (%d) <= 0!" ! 749: .text ! 750: 1: ! 751: #endif /* MACH_ASSERT */ ! 752: _ENABLE_PREEMPTION(%eax) ! 753: #endif /* MACH_RT && NCPUS > 1 */ ! 754: ret ! 755: ! 756: ENTRY(_mp_enable_preemption_no_check) ! 757: #if MACH_RT && NCPUS > 1 ! 758: #if MACH_ASSERT ! 759: movl $CPD_PREEMPTION_LEVEL,%eax ! 760: cmpl $0,%gs:(%eax) ! 761: jg 1f ! 762: pushl $2f ! 763: call EXT(panic) ! 764: hlt ! 765: .data ! 766: 2: String "_mp_enable_preemption_no_check: preemption_level <= 0!" ! 767: .text ! 768: 1: ! 769: #endif /* MACH_ASSERT */ ! 770: _ENABLE_PREEMPTION_NO_CHECK(%eax) ! 771: #endif /* MACH_RT && NCPUS > 1 */ ! 772: ret ! 773: ! 774: ! 775: ENTRY(i_bit_set) ! 776: movl S_ARG0,%edx ! 777: movl S_ARG1,%eax ! 778: lock ! 779: bts %dl,(%eax) ! 780: ret ! 781: ! 782: ENTRY(i_bit_clear) ! 783: movl S_ARG0,%edx ! 784: movl S_ARG1,%eax ! 785: lock ! 786: btr %dl,(%eax) ! 787: ret ! 788: ! 789: ENTRY(bit_lock) ! 790: movl S_ARG0,%ecx ! 791: movl S_ARG1,%eax ! 792: 1: ! 793: lock ! 794: bts %ecx,(%eax) ! 795: jb 1b ! 796: ret ! 797: ! 798: ENTRY(bit_lock_try) ! 799: movl S_ARG0,%ecx ! 800: movl S_ARG1,%eax ! 801: lock ! 802: bts %ecx,(%eax) ! 803: jb bit_lock_failed ! 804: ret /* %eax better not be null ! */ ! 805: bit_lock_failed: ! 806: xorl %eax,%eax ! 807: ret ! 808: ! 809: ENTRY(bit_unlock) ! 810: movl S_ARG0,%ecx ! 811: movl S_ARG1,%eax ! 812: lock ! 813: btr %ecx,(%eax) ! 814: ret
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.