Category

Development Platform
Home > SourceCode/Document > Windows Develop > View Code
x4intrlk.s
Package: win2ksrc.rar　[view]
Upload User: caisha3
Upload Date: 2013-09-21
Package Size: 208739k
Code Size: 31k
Category:

Windows Develop

Development Platform:

Visual C++

x4intrlk.s：Code Content
  1. //       TITLE("Interlocked Support")
  2. //++
  3. //
  4. // Copyright (c) 1990  Microsoft Corporation
  5. //
  6. // Module Name:
  7. //
  8. //    intrlock.s
  9. //
  10. // Abstract:
  11. //
  12. //    This module implements functions to support interlocked operations.
  13. //    Interlocked operations can only operate on nonpaged data and the
  14. //    specified spinlock cannot be used for any other purpose.
  15. //
  16. // Author:
  17. //
  18. //    David N. Cutler (davec) 26-Mar-1990
  19. //
  20. // Environment:
  21. //
  22. //    Kernel mode.
  23. //
  24. // Revision History:
  25. //
  26. //--
  28. #include "ksmips.h"
  30.         SBTTL("Interlocked Add Large Integer")
  31. //++
  32. //
  33. // LARGE_INTEGER
  34. // ExInterlockedAddLargeInteger (
  35. //    IN PLARGE_INTEGER Addend,
  36. //    IN LARGE_INTEGER Increment,
  37. //    IN PKSPIN_LOCK Lock
  38. //    )
  39. //
  40. // Routine Description:
  41. //
  42. //    This function performs an interlocked add of an increment value to an
  43. //    addend variable of type large integer. The initial value of the addend
  44. //    variable is returned as the function value.
  45. //
  46. // Arguments:
  47. //
  48. //    Addend (a1) - Supplies a pointer to a variable whose value is to be
  49. //       adjusted by the increment value.
  50. //
  51. //    Increment (a2, a3) - Supplies the increment value to be added to the
  52. //       addend variable.
  53. //
  54. //    Lock (4 * 4(sp)) - Supplies a pointer to a spin lock to be used to
  55. //       synchronize access to the addend variable.
  56. //
  57. // Return Value:
  58. //
  59. //    The initial value of the addend variable is stored at the address
  60. //    supplied by a0.
  61. //
  62. // Implementation Note:
  63. //
  64. //    The arithmetic for this function is performed as if this were an
  65. //    unsigned large integer since this routine may not incur an overflow
  66. //    exception.
  67. //
  68. //--
  70.         LEAF_ENTRY(ExInterlockedAddLargeInteger)
  72.         lw      t0,4 * 4(sp)            // get address of spin lock
  74. 5:      DISABLE_INTERRUPTS(t1)          // disable interrupts
  76. #if !defined(NT_UP)
  78. 10:     ll      t2,0(t0)                // get current lock value
  79.         move    t3,t0                   // set ownership value
  80.         bne     zero,t2,20f             // if ne, spin lock owned
  81.         sc      t3,0(t0)                // set spin lock owned
  82.         beq     zero,t3,10b             // if eq, store conditional failed
  84. #endif
  86.         lw      t2,0(a1)                // get low part of addend value
  87.         lw      t3,4(a1)                // get high part of addend value
  88.         addu    a2,t2,a2                // add low parts of large integer
  89.         addu    a3,t3,a3                // add high parts of large integer
  90.         sltu    t4,a2,t2                // generate carry from low part
  91.         addu    a3,a3,t4                // add carry to high part
  92.         sw      a2,0(a1)                // store low part of result
  93.         sw      a3,4(a1)                // store high part of result
  95. #if !defined(NT_UP)
  97.         sw      zero,0(t0)              // set spin lock not owned
  99. #endif
  101.         ENABLE_INTERRUPTS(t1)           // enable interrupts
  103.         sw      t2,0(a0)                // set low part of initial value
  104.         sw      t3,4(a0)                // set high part of initial value
  105.         move    v0,a0                   // set function return register
  106.         j       ra                      // return
  108. #if !defined(NT_UP)
  110. 20:     ENABLE_INTERRUPTS(t1)           // enable interrupts
  111.         b       5b                      // try again
  113. #endif
  115.         .end    ExInterlockedAddLargeInteger
  117.         SBTTL("Interlocked Add Large Statistic")
  118. //++
  119. //
  120. // VOID
  121. // ExInterlockedAddLargeStatistic (
  122. //    IN PLARGE_INTEGER Addend,
  123. //    IN ULONG Increment
  124. //    )
  125. //
  126. // Routine Description:
  127. //
  128. //    This function performs an interlocked add of an increment value to an
  129. //    addend variable of type large integer.
  130. //
  131. // Arguments:
  132. //
  133. //    Addend (a0) - Supplies a pointer to a variable whose value is to be
  134. //       adjusted by the increment value.
  135. //
  136. //    Increment (a1) - Supplies the increment value to be added to the
  137. //       addend variable.
  138. //
  139. // Return Value:
  140. //
  141. //    None.
  142. //
  143. // Implementation Note:
  144. //
  145. //    The arithmetic for this function is performed as if this were an
  146. //    unsigned large integer since this routine may not incur an overflow
  147. //    exception.
  148. //
  149. //--
  151.         LEAF_ENTRY(ExInterlockedAddLargeStatistic)
  153. 10:     lld     t0,0(a0)                // get large statistic value
  154.         daddu   t0,t0,a1                // add increment
  155.         scd     t0,0(a0)                // store large statistic value
  156.         beq     zero,t0,10b             // if eq, store conditional failed
  157.         j       ra                      //
  159.         .end    ExInterlockedAddLargeStatistic
  161.         SBTTL("Interlocked Add Unsigned Long")
  162. //++
  163. //
  164. // ULONG
  165. // ExInterlockedAddUlong (
  166. //    IN PULONG Addend,
  167. //    IN ULONG Increment,
  168. //    IN PKSPIN_LOCK Lock
  169. //    )
  170. //
  171. // Routine Description:
  172. //
  173. //    This function performs an interlocked add of an increment value to an
  174. //    addend variable of type unsigned long. The initial value of the addend
  175. //    variable is returned as the function value.
  176. //
  177. // Arguments:
  178. //
  179. //    Addend (a0) - Supplies a pointer to a variable whose value is to be
  180. //       adjusted by the increment value.
  181. //
  182. //    Increment (a1) - Supplies the increment value to be added to the
  183. //       addend variable.
  184. //
  185. //    Lock (a2) - Supplies a pointer to a spin lock to be used to synchronize
  186. //       access to the addend variable.
  187. //
  188. // Return Value:
  189. //
  190. //    The initial value of the addend variable.
  191. //
  192. //--
  194.         LEAF_ENTRY(ExInterlockedAddUlong)
  197. 5:      DISABLE_INTERRUPTS(t0)          // disable interrupts
  199. #if !defined(NT_UP)
  201. 10:     ll      t1,0(a2)                // get current lock value
  202.         move    t2,a2                   // set ownership value
  203.         bne     zero,t1,20f             // if ne, spin lock owned
  204.         sc      t2,0(a2)                // set spin lock owned
  205.         beq     zero,t2,10b             // if eq, store conditional failed
  207. #endif
  209.         lw      v0,0(a0)                // get initial addend value
  210.         addu    t1,v0,a1                // compute adjusted value
  211.         sw      t1,0(a0)                // set updated addend value
  213. #if !defined(NT_UP)
  215.         sw      zero,0(a2)              // set spin lock not owned
  217. #endif
  219.         ENABLE_INTERRUPTS(t0)           // enable interrupts
  221.         j       ra                      // return
  223. #if !defined(NT_UP)
  225. 20:     ENABLE_INTERRUPTS(t0)           // enable interrupts
  227.         b       5b                      // try again
  229. #endif
  231.         .end    ExInterlockedAddUlong
  233.         SBTTL("Interlocked Exchange Unsigned Long")
  234. //++
  235. //
  236. // ULONG
  237. // ExInterlockedExchangeUlong (
  238. //    IN PULONG Source,
  239. //    IN ULONG Value,
  240. //    IN PKSPIN_LOCK Lock
  241. //    )
  242. //
  243. // Routine Description:
  244. //
  245. //    This function performs an interlocked exchange of a longword value with
  246. //    a longword in memory and returns the memory value.
  247. //
  248. //    N.B. There is an alternate entry point provided for this routine which
  249. //         is MIPS target specific and whose prototype does not include the
  250. //         spinlock parameter. Since the routine never refers to the spinlock
  251. //         parameter, no additional code is required.
  252. //
  253. // Arguments:
  254. //
  255. //    Source (a0) - Supplies a pointer to a variable whose value is to be
  256. //       exchanged.
  257. //
  258. //    Value (a1) - Supplies the value to exchange with the source value.
  259. //
  260. //    Lock (a2) - Supplies a pointer to a spin lock to be used to synchronize
  261. //       access to the source variable.
  262. //
  263. // Return Value:
  264. //
  265. //    The source value is returned as the function value.
  266. //
  267. //--
  269.         LEAF_ENTRY(ExInterlockedExchangeUlong)
  271.         ALTERNATE_ENTRY(ExMipsInterlockedExchangeUlong)
  273. 10:     ll      v0,0(a0)                // get current source value
  274.         move    t1,a1                   // set exchange value
  275.         sc      t1,0(a0)                // set new source value
  276.         beq     zero,t1,10b             // if eq, store conditional failed
  278.         j       ra                      // return
  280.         .end    ExInterlockedExchangeUlong
  282.         SBTTL("Interlocked Exchange Add Large Integer")
  283. //++
  284. //
  285. // LARGE_INTEGER
  286. // ExpInterlockedExchangeAddLargeInteger (
  287. //    IN PLARGE_INTEGER Addend,
  288. //    IN LARGE_INTEGER Increment,
  289. //    IN PKSPIN_LOCK Lock
  290. //    )
  291. //
  292. // Routine Description:
  293. //
  294. //    This function performs an interlocked add of an increment value to an
  295. //    addend variable of type large integer. The initial value of the addend
  296. //    variable is returned as the function value.
  297. //
  298. // Arguments:
  299. //
  300. //    Addend (a1) - Supplies a pointer to a variable whose value is to be
  301. //       adjusted by the increment value.
  302. //
  303. //    Increment (a2, a3) - Supplies the increment value to be added to the
  304. //       addend variable.
  305. //
  306. // Return Value:
  307. //
  308. //    The initial value of the addend variable is stored at the address
  309. //    supplied by a0.
  310. //
  311. // Implementation Note:
  312. //
  313. //    The arithmetic for this function is performed as if this were an
  314. //    unsigned large integer since this routine may not incur an overflow
  315. //    exception.
  316. //
  317. //--
  319.         LEAF_ENTRY(ExpInterlockedExchangeAddLargeInteger)
  321.         dsll    a2,a2,32                // merge low and high parts of
  322.         dsrl    a2,a2,32                // increment value
  323.         dsll    a3,a3,32                //
  324.         or      a2,a2,a3                //
  325. 10:     lld     a3,0(a1)                // get addend value
  326.         daddu   v0,a3,a2                // add increment
  327.         scd     v0,0(a1)                // store addend value
  328.         beq     zero,v0,10b             // if eq, store conditional failed
  329.         sd      a3,0(a0)                //
  330.         move    v0,a0                   // set function return register
  331.         j       ra                      // return
  333.         .end    ExpInterlockedExchangeAddLargeInteger
  335.         SBTTL("Interlocked Decrement Long")
  336. //++
  337. //
  338. // INTERLOCKED_RESULT
  339. // ExInterlockedDecrementLong (
  340. //    IN PLONG Addend,
  341. //    IN PKSPIN_LOCK Lock
  342. //    )
  343. //
  344. // Routine Description:
  345. //
  346. //    This function performs an interlocked decrement on an addend variable
  347. //    of type signed long. The sign and whether the result is zero is returned
  348. //    as the function value.
  349. //
  350. //    N.B. There is an alternate entry point provided for this routine which
  351. //         is MIPS target specific and whose prototype does not include the
  352. //         spinlock parameter. Since the routine never refers to the spinlock
  353. //         parameter, no additional code is required.
  354. //
  355. // Arguments:
  356. //
  357. //    Addend (a0) - Supplies a pointer to a variable whose value is to be
  358. //       decremented.
  359. //
  360. //    Lock (a1) - Supplies a pointer to a spin lock to be used to synchronize
  361. //       access to the addend variable.
  362. //
  363. // Return Value:
  364. //
  365. //    RESULT_NEGATIVE is returned if the resultant addend value is negative.
  366. //    RESULT_ZERO is returned if the resultant addend value is zero.
  367. //    RESULT_POSITIVE is returned if the resultant addend value is positive.
  368. //
  369. //--
  371.         LEAF_ENTRY(ExInterlockedDecrementLong)
  373.         ALTERNATE_ENTRY(ExMipsInterlockedDecrementLong)
  375. 10:     ll      t1,0(a0)                // get current addend value
  376.         subu    t2,t1,1                 // decrement addend value
  377.         sc      t2,0(a0)                // set new addend value
  378.         beq     zero,t2,10b             // if eq, store conditional failed
  379.         subu    v0,t1,1                 // decrement addend value
  380.         sltu    t0,zero,v0              // check if result is nonzero
  381.         sra     v0,v0,31                // sign extend result value
  382.         subu    v0,v0,t0                // compute negative, zero, or positive
  384.         j       ra                      // return
  386.         .end    ExInterlockedDecrementLong
  388.         SBTTL("Interlocked Increment Long")
  389. //++
  390. //
  391. // INTERLOCKED_RESULT
  392. // ExInterlockedIncrementLong (
  393. //    IN PLONG Addend,
  394. //    IN PKSPIN_LOCK Lock
  395. //    )
  396. //
  397. // Routine Description:
  398. //
  399. //    This function performs an interlocked increment on an addend variable
  400. //    of type signed long. The sign and whether the result is zero is returned
  401. //    as the function value.
  402. //
  403. //    N.B. There is an alternate entry point provided for this routine which
  404. //         is MIPS target specific and whose prototype does not include the
  405. //         spinlock parameter. Since the routine never refers to the spinlock
  406. //         parameter, no additional code is required.
  407. //
  408. // Arguments:
  409. //
  410. //    Addend (a0) - Supplies a pointer to a variable whose value is to be
  411. //       incremented.
  412. //
  413. //    Lock (a1) - Supplies a pointer to a spin lock to be used to synchronize
  414. //       access to the addend variable.
  415. //
  416. // Return Value:
  417. //
  418. //    RESULT_NEGATIVE is returned if the resultant addend value is negative.
  419. //    RESULT_ZERO is returned if the resultant addend value is zero.
  420. //    RESULT_POSITIVE is returned if the resultant addend value is positive.
  421. //
  422. //--
  424.         LEAF_ENTRY(ExInterlockedIncrementLong)
  426.         ALTERNATE_ENTRY(ExMipsInterlockedIncrementLong)
  428. 10:     ll      t1,0(a0)                // get current addend value
  429.         addu    t2,t1,1                 // increment addend value
  430.         sc      t2,0(a0)                // set new addend value
  431.         beq     zero,t2,10b             // if eq, store conditional failed
  432.         addu    v0,t1,1                 // increment addend value
  433.         sltu    t0,zero,v0              // check if result is nonzero
  434.         sra     v0,v0,31                // sign extend result value
  435.         subu    v0,v0,t0                // compute negative, zero, or positive
  437.         j       ra                      // return
  439.         .end    ExInterlockedIncrementLong
  441.         SBTTL("Interlocked Insert Head List")
  442. //++
  443. //
  444. // PLIST_ENTRY
  445. // ExInterlockedInsertHeadList (
  446. //    IN PLIST_ENTRY ListHead,
  447. //    IN PLIST_ENTRY ListEntry,
  448. //    IN PKSPIN_LOCK Lock
  449. //    )
  450. //
  451. // Routine Description:
  452. //
  453. //    This function inserts an entry at the head of a doubly linked list
  454. //    so that access to the list is synchronized in a multiprocessor system.
  455. //
  456. // Arguments:
  457. //
  458. //    ListHead (a0) - Supplies a pointer to the head of the doubly linked
  459. //       list into which an entry is to be inserted.
  460. //
  461. //    ListEntry (a1) - Supplies a pointer to the entry to be inserted at the
  462. //       head of the list.
  463. //
  464. //    Lock (a2) - Supplies a pointer to a spin lock to be used to synchronize
  465. //       access to the list.
  466. //
  467. // Return Value:
  468. //
  469. //    Pointer to entry that was at the head of the list or NULL if the list
  470. //    was empty.
  471. //
  472. //--
  474.         LEAF_ENTRY(ExInterlockedInsertHeadList)
  476. 5:      DISABLE_INTERRUPTS(t0)          // disable interrupts
  478. #if !defined(NT_UP)
  480. 10:     ll      t2,0(a2)                // get current lock value
  481.         move    t3,a2                   // set ownership value
  482.         bne     zero,t2,20f             // if ne, spin lock owned
  483.         sc      t3,0(a2)                // set spin lock owned
  484.         beq     zero,t3,10b             // if eq, store conditional failed
  486. #endif
  488.         lw      t2,LsFlink(a0)          // get address of next entry
  489.         sw      t2,LsFlink(a1)          // store next link in entry
  490.         sw      a0,LsBlink(a1)          // store previous link in entry
  491.         sw      a1,LsBlink(t2)          // store previous link in next
  492.         sw      a1,LsFlink(a0)          // store next link in head
  493.         xor     v0,t2,a0                // check if list was empty
  494.         beq     v0,zero,15f             // if eq, list was null
  495.         move    v0,t2                   // return previous entry at head
  496. 15:
  498. #if !defined(NT_UP)
  500.         sw      zero,0(a2)              // set spin lock not owned
  502. #endif
  504.         ENABLE_INTERRUPTS(t0)           // enable interrupts
  506.         j       ra                      // return
  508. #if !defined(NT_UP)
  510. 20:     ENABLE_INTERRUPTS(t0)           // enable interrupts
  512.         b       5b                      // try again
  514. #endif
  516.         .end    ExInterlockedInsertHeadList
  518.         SBTTL("Interlocked Insert Tail List")
  519. //++
  520. //
  521. // PLIST_ENTRY
  522. // ExInterlockedInsertTailList (
  523. //    IN PLIST_ENTRY ListHead,
  524. //    IN PLIST_ENTRY ListEntry,
  525. //    IN PKSPIN_LOCK Lock
  526. //    )
  527. //
  528. // Routine Description:
  529. //
  530. //    This function inserts an entry at the tail of a doubly linked list
  531. //    so that access to the list is synchronized in a multiprocessor system.
  532. //
  533. // Arguments:
  534. //
  535. //    ListHead (a0) - Supplies a pointer to the head of the doubly linked
  536. //       list into which an entry is to be inserted.
  537. //
  538. //    ListEntry (a1) - Supplies a pointer to the entry to be inserted at the
  539. //       tail of the list.
  540. //
  541. //    Lock (a2) - Supplies a pointer to a spin lock to be used to synchronize
  542. //       access to the list.
  543. //
  544. // Return Value:
  545. //
  546. //    Pointer to entry that was at the tail of the list or NULL if the list
  547. //    was empty.
  548. //
  549. //--
  551.         LEAF_ENTRY(ExInterlockedInsertTailList)
  553. 5:      DISABLE_INTERRUPTS(t0)          // disable interrupts
  555. #if !defined(NT_UP)
  557. 10:     ll      t2,0(a2)                // get current lock value
  558.         move    t3,a2                   // set ownership value
  559.         bne     zero,t2,20f             // if ne, spin lock owned
  560.         sc      t3,0(a2)                // set spin lock owned
  561.         beq     zero,t3,10b             // if eq, store conditional failed
  563. #endif
  565.         lw      t2,LsBlink(a0)          // get address of previous entry
  566.         sw      a0,LsFlink(a1)          // store next link in entry
  567.         sw      t2,LsBlink(a1)          // store previous link in entry
  568.         sw      a1,LsBlink(a0)          // store previous link in next
  569.         sw      a1,LsFlink(t2)          // store next link in head
  570.         xor     v0,t2,a0                // check is list was emptyr
  571.         beq     v0,zero,15f             // if eq, list was empty
  572.         move    v0,t2                   // return previous entry at tail
  573. 15:
  575. #if !defined(NT_UP)
  577.         sw      zero,0(a2)              // set spin lock not owned
  579. #endif
  581.         ENABLE_INTERRUPTS(t0)           // enable interrupts
  583.         j       ra                      // return
  586. #if !defined(NT_UP)
  588. 20:     ENABLE_INTERRUPTS(t0)           // enable interrupts
  590.         b       5b                      // try again
  592. #endif
  594.         .end    ExInterlockedInsertTailList
  596.         SBTTL("Interlocked Remove Head List")
  597. //++
  598. //
  599. // PLIST_ENTRY
  600. // ExInterlockedRemoveHeadList (
  601. //    IN PLIST_ENTRY ListHead,
  602. //    IN PKSPIN_LOCK Lock
  603. //    )
  604. //
  605. // Routine Description:
  606. //
  607. //    This function removes an entry from the head of a doubly linked list
  608. //    so that access to the list is synchronized in a multiprocessor system.
  609. //    If there are no entries in the list, then a value of NULL is returned.
  610. //    Otherwise, the address of the entry that is removed is returned as the
  611. //    function value.
  612. //
  613. // Arguments:
  614. //
  615. //    ListHead (a0) - Supplies a pointer to the head of the doubly linked
  616. //       list from which an entry is to be removed.
  617. //
  618. //    Lock (a1) - Supplies a pointer to a spin lock to be used to synchronize
  619. //       access to the list.
  620. //
  621. // Return Value:
  622. //
  623. //    The address of the entry removed from the list, or NULL if the list is
  624. //    empty.
  625. //
  626. //--
  628.         LEAF_ENTRY(ExInterlockedRemoveHeadList)
  630. 5:      DISABLE_INTERRUPTS(t0)          // disable interrupts
  632. #if !defined(NT_UP)
  634. 10:     ll      t2,0(a1)                // get current lock value
  635.         move    t3,a1                   // set ownership value
  636.         bne     zero,t2,30f             // if ne, spin lock owned
  637.         sc      t3,0(a1)                // set spin lock owned
  638.         beq     zero,t3,10b             // if eq, store conditional failed
  640. #endif
  642.         lw      t2,LsFlink(a0)          // get address of next entry
  643.         move    v0,zero                 // assume list is empty
  644.         beq     t2,a0,20f               // if eq, list is empty
  645.         lw      t3,LsFlink(t2)          // get address of next entry
  646.         sw      t3,LsFlink(a0)          // store address of next in head
  647.         sw      a0,LsBlink(t3)          // store address of previous in next
  648.         move    v0,t2                   // set address of entry removed
  649. 20:                                     //
  651. #if !defined(NT_UP)
  653.         sw      zero,0(a1)              // set spin lock not owned
  655. #endif
  657.         ENABLE_INTERRUPTS(t0)           // enable interrupts
  659.         j       ra                      // return
  662. #if !defined(NT_UP)
  664. 30:     ENABLE_INTERRUPTS(t0)           // enable interrupts
  666.         b       5b                      // try again
  668. #endif
  670.         .end    ExInterlockedRemoveHeadList
  672.         SBTTL("Interlocked Pop Entry List")
  673. //++
  674. //
  675. // PSINGLE_LIST_ENTRY
  676. // ExInterlockedPopEntryList (
  677. //    IN PSINGLE_LIST_ENTRY ListHead,
  678. //    IN PKSPIN_LOCK Lock
  679. //    )
  680. //
  681. // Routine Description:
  682. //
  683. //    This function removes an entry from the front of a singly linked list
  684. //    so that access to the list is synchronized in a multiprocessor system.
  685. //    If there are no entries in the list, then a value of NULL is returned.
  686. //    Otherwise, the address of the entry that is removed is returned as the
  687. //    function value.
  688. //
  689. // Arguments:
  690. //
  691. //    ListHead (a0) - Supplies a pointer to the head of the singly linked
  692. //       list from which an entry is to be removed.
  693. //
  694. //    Lock (a1) - Supplies a pointer to a spin lock to be used to synchronize
  695. //       access to the list.
  696. //
  697. // Return Value:
  698. //
  699. //    The address of the entry removed from the list, or NULL if the list is
  700. //    empty.
  701. //
  702. //--
  704.         LEAF_ENTRY(ExInterlockedPopEntryList)
  706. 5:      DISABLE_INTERRUPTS(t0)          // disable interrupts
  708. #if !defined(NT_UP)
  710. 10:     ll      t2,0(a1)                // get current lock value
  711.         move    t3,a1                   // set ownership value
  712.         bne     zero,t2,30f             // if ne, spin lock owned
  713.         sc      t3,0(a1)                // set spin lock owned
  714.         beq     zero,t3,10b             // if eq, store conditional failed
  716. #endif
  718.         lw      v0,0(a0)                // get address of next entry
  719.         beq     zero,v0,20f             // if eq, list is empty
  720.         lw      t2,0(v0)                // get address of next entry
  721.         sw      t2,0(a0)                // store address of next in head
  722. 20:                                     //
  724. #if !defined(NT_UP)
  726.         sw      zero,0(a1)              // set spin lock not owned
  728. #endif
  730.         ENABLE_INTERRUPTS(t0)           // enable interrupts
  732.         j       ra                      // return
  734. #if !defined(NT_UP)
  736. 30:     ENABLE_INTERRUPTS(t0)           // enable interrupts
  738.         b       5b                      // try again
  740. #endif
  742.         .end    ExInterlockedPopEntryList
  744.         SBTTL("Interlocked Push Entry List")
  745. //++
  746. //
  747. // PSINGLE_LIST_ENTRY
  748. // ExInterlockedPushEntryList (
  749. //    IN PSINGLE_LIST_ENTRY ListHead,
  750. //    IN PSINGLE_LIST_ENTRY ListEntry,
  751. //    IN PKSPIN_LOCK Lock
  752. //    )
  753. //
  754. // Routine Description:
  755. //
  756. //    This function inserts an entry at the head of a singly linked list
  757. //    so that access to the list is synchronized in a multiprocessor system.
  758. //
  759. // Arguments:
  760. //
  761. //    ListHead (a0) - Supplies a pointer to the head of the singly linked
  762. //       list into which an entry is to be inserted.
  763. //
  764. //    ListEntry (a1) - Supplies a pointer to the entry to be inserted at the
  765. //       head of the list.
  766. //
  767. //    Lock (a2) - Supplies a pointer to a spin lock to be used to synchronize
  768. //       access to the list.
  769. //
  770. // Return Value:
  771. //
  772. //    Previous contents of ListHead.  NULL implies list went from empty
  773. //       to not empty.
  774. //
  775. //--
  777.         LEAF_ENTRY(ExInterlockedPushEntryList)
  779. 5:      DISABLE_INTERRUPTS(t0)          // disable interrupts
  781. #if !defined(NT_UP)
  783. 10:     ll      t2,0(a2)                // get current lock value
  784.         move    t3,a2                   // set ownership value
  785.         bne     zero,t2,20f             // if ne, spin lock owned
  786.         sc      t3,0(a2)                // set spin lock owned
  787.         beq     zero,t3,10b             // if eq, store conditional failed
  789. #endif
  791.         lw      v0,0(a0)                // get address of first entry (return value also)
  792.         sw      v0,0(a1)                // set address of next in new entry
  793.         sw      a1,0(a0)                // set address of first entry
  795. #if !defined(NT_UP)
  797.         sw      zero,0(a2)              // set spin lock not owned
  799. #endif
  801.         ENABLE_INTERRUPTS(t0)           // enable interrupts
  803.         j       ra                      // return
  805. #if !defined(NT_UP)
  807. 20:     ENABLE_INTERRUPTS(t0)           // enable interrupts
  809.         b       5b                      // try again
  811. #endif
  813.         .end    ExInterlockedPushEntryList
  815.         SBTTL("Interlocked Pop Entry Sequenced List")
  816. //++
  817. //
  818. // PSINGLE_LIST_ENTRY
  819. // ExpInterlockedPopEntrySList (
  820. //    IN PSLIST_HEADER ListHead
  821. //    )
  822. //
  823. // Routine Description:
  824. //
  825. //    This function removes an entry from the front of a sequenced singly
  826. //    linked list so that access to the list is synchronized in a MP system.
  827. //    If there are no entries in the list, then a value of NULL is returned.
  828. //    Otherwise, the address of the entry that is removed is returned as the
  829. //    function value.
  830. //
  831. // Arguments:
  832. //
  833. //    ListHead (a0) - Supplies a pointer to the sequenced listhead from which
  834. //       an entry is to be removed.
  835. //
  836. // Return Value:
  837. //
  838. //    The address of the entry removed from the list, or NULL if the list is
  839. //    empty.
  840. //
  841. //--
  843.         LEAF_ENTRY(ExpInterlockedPopEntrySList)
  845.         .set    noreorder
  846.         .set    noat
  848. //
  849. // N.B. The following code is the continuation address should a fault
  850. //      occur in the rare case described below.
  851. //
  853.         ALTERNATE_ENTRY(ExpInterlockedPopEntrySListResume)
  855. 10:     ld      t0,0(a0)                // get next entry address and sequence
  856. 20:     dsll    v0,t0,32                // sign extend next entry address
  857.         dsra    v0,v0,32                //
  858.         beq     zero,v0,30f             // if eq, list is empty
  859.         dsrl    t1,t0,32                // shift sequence to low 32-bits
  861. //
  862. // N.B. It is possible for the following instruction to fault in the rare
  863. //      case where the first entry in the list is allocated on another
  864. //      processor and freed between the time the free pointer is read above
  865. //      and the following instruction. When this happens, the access fault
  866. //      code continues execution above at the resumption address and the
  867. //      entire operation is retried.
  868. //
  870.         ALTERNATE_ENTRY(ExpInterlockedPopEntrySListFault)
  872.         lwu     t2,0(v0)                // get address of successor entry
  873.         lld     t3,0(a0)                // reload next entry address and sequence
  874.         li      t4,0xffff               // decrement list depth and
  875.         addu    t1,t1,t4                // increment sequence number
  876.         dsll    t1,t1,32                // merge successor address and sequence
  877.         bne     t0,t3,10b               // if ne, listhead has changed
  878.         or      t1,t1,t2                //
  879.         scd     t1,0(a0)                // store next emtry address and sequence
  880.         beql    zero,t1,20b             // if eq, store conditional failed
  881.         ld      t0,0(a0)                // get next entry address and sequence
  882.         .set    at
  883.         .set    reorder
  885. 30:     j       ra                      // return
  887.         .end    ExpInterlockedPopEntrySList
  889.         SBTTL("Interlocked Push Entry Sequenced List")
  890. //++
  891. //
  892. // PSINGLE_LIST_ENTRY
  893. // ExpInterlockedPushEntrySList (
  894. //    IN PSLIST_HEADER ListHead,
  895. //    IN PSINGLE_LIST_ENTRY ListEntry
  896. //    )
  897. //
  898. // Routine Description:
  899. //
  900. //    This function inserts an entry at the head of a sequenced singly linked
  901. //    list so that access to the list is synchronized in an MP system.
  902. //
  903. // Arguments:
  904. //
  905. //    ListHead (a0) - Supplies a pointer to the sequenced listhead into which
  906. //       an entry is to be inserted.
  907. //
  908. //    ListEntry (a1) - Supplies a pointer to the entry to be inserted at the
  909. //       head of the list.
  910. //
  911. // Return Value:
  912. //
  913. //    Previous contents of ListHead.  NULL implies list went from empty
  914. //       to not empty.
  915. //
  916. //--
  918.         LEAF_ENTRY(ExpInterlockedPushEntrySList)
  920.         .set    noreorder
  921.         .set    noat
  922. 10:     ld      t0,0(a0)                // get next entry address and sequence
  923. 20:     dsll    v0,t0,32                // sign extend next entry address
  924.         dsra    v0,v0,32                //
  925.         dsrl    t1,t0,32                // shift sequence to low 32-bits
  926.         sw      v0,0(a1)                // set next link in new first entry
  927.         dsll    t2,a1,32                // zero extend new first entry
  928.         dsrl    t2,t2,32                //
  929.         lld     t3,0(a0)                // reload next entry address and sequence
  930.         lui     t4,1                    // get sequence adjustment value
  931.         addu    t1,t1,1                 // increment list depth
  932.         addu    t1,t1,t4                // increment sequence number
  933.         dsll    t1,t1,32                // merge new first entry address and sequence
  934.         bne     t0,t3,10b               // if ne, listhead has changed
  935.         or      t1,t1,t2                //
  936.         scd     t1,0(a0)                // store next emtry address and sequence
  937.         beql    zero,t1,20b             // if eq, store conditional failed
  938.         ld      t0,0(a0)                // get next entry address and sequence
  939.         .set    at
  940.         .set    reorder
  942.         j       ra                      // return
  944.         .end    ExpInterlockedPushEntrySList
  946.         SBTTL("Interlocked Compare Exchange 64-bits")
  947. //++
  948. //
  949. // ULONGLONG
  950. // ExpInterlockedCompareExchange64 (
  951. //    IN PULONGLONG Destination,
  952. //    IN PULONGLONG Exchange,
  953. //    IN PULONGLONG Comperand
  954. //    )
  955. //
  956. // Routine Description:
  957. //
  958. //    This function performs an interlocked compare and exchange of 64-bits.
  959. //
  960. // Arguments:
  961. //
  962. //    Destination (a0) - Supplies a pointer to the destination variable.
  963. //
  964. //    Exchange (a1) - Supplies a pointer to the exchange value.
  965. //
  966. //    Comperand (a2) - Supplies a pointer to the comperand value.
  967. //
  968. // Return Value:
  969. //
  970. //    The current destination value are returned as the function value.
  971. //
  972. //--
  974.         LEAF_ENTRY(ExpInterlockedCompareExchange64)
  976.         .set    noreorder
  977.         .set    noat
  978.         ld      t0,0(a1)                // get exchange value
  979.         ld      t1,0(a2)                // get comperand value
  980.         lld     v0,0(a0)                // get current destination value
  981. 10:     move    t2,t0                   // set exchange value
  982.         bne     v0,t1,20f               // if ne, current and comperand mismatch
  983.         dsra    v1,v0,32                // extract high part of result
  984.         scd     t2,0(a0)                // store exchange value
  985.         beql    zero,t2,10b             // if eq, store conditional failed
  986.         lld     v0,0(a0)                // get next entry address and sequence
  987. 20:     dsll    v0,v0,32                // extract low part of result
  988.         j       ra                      // return
  989.         dsra    v0,v0,32                //
  990.         .set    at
  991.         .set    reorder
  993.         .end    ExpInterlockedCompareExchange64