runtime: disallow GC assists in non-preemptible contexts

Currently it's possible to perform GC work on a system stack or when
locks are held if there's an allocation that triggers an assist. This
is generally a bad idea because of the fragility of these contexts,
and it's incompatible with two changes we're about to make: one is to
yield after signaling mark completion (which we can't do from a
non-preemptible context) and the other is to make assists block if
there's no other way for them to pay off the assist debt.

This commit simply skips the assist if it's called from a
non-preemptible context. The allocation will still count toward the
assist debt, so it will be paid off by a later assist. There should be
little allocation from non-preemptible contexts, so this shouldn't
harm the overall assist mechanism.

Change-Id: I7bf0e6c73e659fe6b52f27437abf39d76b245c79
Reviewed-on: https://go-review.googlesource.com/12649
Reviewed-by: Russ Cox <rsc@golang.org>

diff --git a/src/runtime/mgcmark.go b/src/runtime/mgcmark.go
index 9212b2edc6e371fc336ade909ce20fd776a99e9a..62f08814390ff992c9b3ad53154956a059f311aa 100644 (file)
--- a/src/runtime/mgcmark.go
+++ b/src/runtime/mgcmark.go
@@ -160,6 +160,15 @@ func gcAssistAlloc(size uintptr, allowAssist bool) {
                return
        }
 
+       // Don't assist in non-preemptible contexts. These are
+       // generally fragile and won't allow the assist to block.
+       if getg() == gp.m.g0 {
+               return
+       }
+       if mp := getg().m; mp.locks > 0 || mp.preemptoff != "" {
+               return
+       }
+
        // Compute the amount of assist scan work we need to do.
        scanWork := int64(gcController.assistRatio*float64(gp.gcalloc)) - gp.gcscanwork
        // scanWork can be negative if the last assist scanned a large