[dev.power64] code review 152570049: all: merge default into dev.power64

src/runtime/select.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package runtime
 
 // This file contains the implementation of Go select statements.
 
 import "unsafe"
 
@@ skipping 350 matching lines @@
                 }
         }
 
         // wait for someone to wake us up
         gp.param = nil
         gopark(unsafe.Pointer(funcPC(selparkcommit)), unsafe.Pointer(sel), "select")
 
         // someone woke us up
         sellock(sel)
         sg = (*sudog)(gp.param)
+        gp.param = nil
 
         // pass 3 - dequeue from unsuccessful chans
         // otherwise they stack up on quiet channels
         // record the successful case, if any.
         // We singly-linked up the SudoGs in case order, so when
         // iterating through the linked list they are in reverse order.
         cas = nil
         sglist = gp.waiting
+        // Clear all selectdone and elem before unlinking from gp.waiting.
+        // They must be cleared before being put back into the sudog cache.
+        // Clear before unlinking, because if a stack copy happens after the unlink,
+        // they will not be updated, they will be left pointing to the old stack,
+        // which creates dangling pointers, which may be detected by the
+        // garbage collector.
+        for sg1 := gp.waiting; sg1 != nil; sg1 = sg1.waitlink {
+                sg1.selectdone = nil
+                sg1.elem = nil
+        }
         gp.waiting = nil
         for i := int(sel.ncase) - 1; i >= 0; i-- {
                 k = &scases[pollorder[i]]
                 if sglist.releasetime > 0 {
                         k.releasetime = sglist.releasetime
                 }
                 if sg == sglist {
                         cas = k
                 } else {
                         c = k._chan
                         if k.kind == _CaseSend {
-                                c.sendq.dequeueg(gp)
+                                c.sendq.dequeueSudoG(sglist)
                         } else {
-                                c.recvq.dequeueg(gp)
+                                c.recvq.dequeueSudoG(sglist)
                         }
                 }
                 sgnext = sglist.waitlink
                 releaseSudog(sglist)
                 sglist = sgnext
         }
 
         if cas == nil {
                 goto loop
         }
@@ skipping 96 matching lines @@
         selunlock(sel)
         if debugSelect {
                 print("syncrecv: sel=", sel, " c=", c, "\n")
         }
         if cas.receivedp != nil {
                 *cas.receivedp = true
         }
         if cas.elem != nil {
                 memmove(cas.elem, sg.elem, uintptr(c.elemsize))
         }
+        sg.elem = nil
         gp = sg.g
         gp.param = unsafe.Pointer(sg)
         if sg.releasetime != 0 {
                 sg.releasetime = cputicks()
         }
         goready(gp)
         goto retc
 
 rclose:
         // read at end of closed channel
@@ skipping 15 matching lines @@
                 raceReadObjectPC(c.elemtype, cas.elem, cas.pc, chansendpc)
                 racesync(c, sg)
         }
         selunlock(sel)
         if debugSelect {
                 print("syncsend: sel=", sel, " c=", c, "\n")
         }
         if sg.elem != nil {
                 memmove(sg.elem, cas.elem, uintptr(c.elemsize))
         }
+        sg.elem = nil
         gp = sg.g
         gp.param = unsafe.Pointer(sg)
         if sg.releasetime != 0 {
                 sg.releasetime = cputicks()
         }
         goready(gp)
 
 retc:
         if cas.releasetime > 0 {
                 blockevent(cas.releasetime-t0, 2)
@@ skipping 27 matching lines @@
 const (
         _             selectDir = iota
         selectSend              // case Chan <- Send
         selectRecv              // case <-Chan:
         selectDefault           // default
 )
 
 func reflect_rselect(cases []runtimeSelect) (chosen int, recvOK bool) {
         // flagNoScan is safe here, because all objects are also referenced from cases.
         size := selectsize(uintptr(len(cases)))
-        sel := (*_select)(gomallocgc(size, nil, flagNoScan))
+        sel := (*_select)(mallocgc(size, nil, flagNoScan))
         newselect(sel, int64(size), int32(len(cases)))
         r := new(bool)
         for i := range cases {
                 rc := &cases[i]
                 switch rc.dir {
                 case selectDefault:
                         selectdefaultImpl(sel, uintptr(i), 0)
                 case selectSend:
                         if rc.ch == nil {
                                 break
                         }
                         selectsendImpl(sel, rc.ch, uintptr(i), rc.val, 0)
                 case selectRecv:
                         if rc.ch == nil {
                                 break
                         }
                         selectrecvImpl(sel, rc.ch, uintptr(i), rc.val, r, 0)
                 }
         }
 
         pc, _ := selectgoImpl(sel)
         chosen = int(pc)
         recvOK = *r
         return
 }
 
-func (q *waitq) dequeueg(gp *g) {
+func (q *waitq) dequeueSudoG(s *sudog) {
         var prevsgp *sudog
         l := &q.first
         for {
                 sgp := *l
                 if sgp == nil {
                         return
                 }
-                if sgp.g == gp {
+                if sgp == s {
                         *l = sgp.next
                         if q.last == sgp {
                                 q.last = prevsgp
                         }
                         return
                 }
                 l = &sgp.next
                 prevsgp = sgp
         }
 }