Source file src/runtime/mfinal.go

     1  // Copyright 2009 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // Garbage collector: finalizers and block profiling.
     6  
     7  package runtime
     8  
     9  import (
    10  	"internal/abi"
    11  	"internal/goarch"
    12  	"runtime/internal/atomic"
    13  	"runtime/internal/sys"
    14  	"unsafe"
    15  )
    16  
    17  // finblock is an array of finalizers to be executed. finblocks are
    18  // arranged in a linked list for the finalizer queue.
    19  //
    20  // finblock is allocated from non-GC'd memory, so any heap pointers
    21  // must be specially handled. GC currently assumes that the finalizer
    22  // queue does not grow during marking (but it can shrink).
    23  type finblock struct {
    24  	_       sys.NotInHeap
    25  	alllink *finblock
    26  	next    *finblock
    27  	cnt     uint32
    28  	_       int32
    29  	fin     [(_FinBlockSize - 2*goarch.PtrSize - 2*4) / unsafe.Sizeof(finalizer{})]finalizer
    30  }
    31  
    32  var fingStatus atomic.Uint32
    33  
    34  // finalizer goroutine status.
    35  const (
    36  	fingUninitialized uint32 = iota
    37  	fingCreated       uint32 = 1 << (iota - 1)
    38  	fingRunningFinalizer
    39  	fingWait
    40  	fingWake
    41  )
    42  
    43  var finlock mutex  // protects the following variables
    44  var fing *g        // goroutine that runs finalizers
    45  var finq *finblock // list of finalizers that are to be executed
    46  var finc *finblock // cache of free blocks
    47  var finptrmask [_FinBlockSize / goarch.PtrSize / 8]byte
    48  
    49  var allfin *finblock // list of all blocks
    50  
    51  // NOTE: Layout known to queuefinalizer.
    52  type finalizer struct {
    53  	fn   *funcval       // function to call (may be a heap pointer)
    54  	arg  unsafe.Pointer // ptr to object (may be a heap pointer)
    55  	nret uintptr        // bytes of return values from fn
    56  	fint *_type         // type of first argument of fn
    57  	ot   *ptrtype       // type of ptr to object (may be a heap pointer)
    58  }
    59  
    60  var finalizer1 = [...]byte{
    61  	// Each Finalizer is 5 words, ptr ptr INT ptr ptr (INT = uintptr here)
    62  	// Each byte describes 8 words.
    63  	// Need 8 Finalizers described by 5 bytes before pattern repeats:
    64  	//	ptr ptr INT ptr ptr
    65  	//	ptr ptr INT ptr ptr
    66  	//	ptr ptr INT ptr ptr
    67  	//	ptr ptr INT ptr ptr
    68  	//	ptr ptr INT ptr ptr
    69  	//	ptr ptr INT ptr ptr
    70  	//	ptr ptr INT ptr ptr
    71  	//	ptr ptr INT ptr ptr
    72  	// aka
    73  	//
    74  	//	ptr ptr INT ptr ptr ptr ptr INT
    75  	//	ptr ptr ptr ptr INT ptr ptr ptr
    76  	//	ptr INT ptr ptr ptr ptr INT ptr
    77  	//	ptr ptr ptr INT ptr ptr ptr ptr
    78  	//	INT ptr ptr ptr ptr INT ptr ptr
    79  	//
    80  	// Assumptions about Finalizer layout checked below.
    81  	1<<0 | 1<<1 | 0<<2 | 1<<3 | 1<<4 | 1<<5 | 1<<6 | 0<<7,
    82  	1<<0 | 1<<1 | 1<<2 | 1<<3 | 0<<4 | 1<<5 | 1<<6 | 1<<7,
    83  	1<<0 | 0<<1 | 1<<2 | 1<<3 | 1<<4 | 1<<5 | 0<<6 | 1<<7,
    84  	1<<0 | 1<<1 | 1<<2 | 0<<3 | 1<<4 | 1<<5 | 1<<6 | 1<<7,
    85  	0<<0 | 1<<1 | 1<<2 | 1<<3 | 1<<4 | 0<<5 | 1<<6 | 1<<7,
    86  }
    87  
    88  // lockRankMayQueueFinalizer records the lock ranking effects of a
    89  // function that may call queuefinalizer.
    90  func lockRankMayQueueFinalizer() {
    91  	lockWithRankMayAcquire(&finlock, getLockRank(&finlock))
    92  }
    93  
    94  func queuefinalizer(p unsafe.Pointer, fn *funcval, nret uintptr, fint *_type, ot *ptrtype) {
    95  	if gcphase != _GCoff {
    96  		// Currently we assume that the finalizer queue won't
    97  		// grow during marking so we don't have to rescan it
    98  		// during mark termination. If we ever need to lift
    99  		// this assumption, we can do it by adding the
   100  		// necessary barriers to queuefinalizer (which it may
   101  		// have automatically).
   102  		throw("queuefinalizer during GC")
   103  	}
   104  
   105  	lock(&finlock)
   106  	if finq == nil || finq.cnt == uint32(len(finq.fin)) {
   107  		if finc == nil {
   108  			finc = (*finblock)(persistentalloc(_FinBlockSize, 0, &memstats.gcMiscSys))
   109  			finc.alllink = allfin
   110  			allfin = finc
   111  			if finptrmask[0] == 0 {
   112  				// Build pointer mask for Finalizer array in block.
   113  				// Check assumptions made in finalizer1 array above.
   114  				if (unsafe.Sizeof(finalizer{}) != 5*goarch.PtrSize ||
   115  					unsafe.Offsetof(finalizer{}.fn) != 0 ||
   116  					unsafe.Offsetof(finalizer{}.arg) != goarch.PtrSize ||
   117  					unsafe.Offsetof(finalizer{}.nret) != 2*goarch.PtrSize ||
   118  					unsafe.Offsetof(finalizer{}.fint) != 3*goarch.PtrSize ||
   119  					unsafe.Offsetof(finalizer{}.ot) != 4*goarch.PtrSize) {
   120  					throw("finalizer out of sync")
   121  				}
   122  				for i := range finptrmask {
   123  					finptrmask[i] = finalizer1[i%len(finalizer1)]
   124  				}
   125  			}
   126  		}
   127  		block := finc
   128  		finc = block.next
   129  		block.next = finq
   130  		finq = block
   131  	}
   132  	f := &finq.fin[finq.cnt]
   133  	atomic.Xadd(&finq.cnt, +1) // Sync with markroots
   134  	f.fn = fn
   135  	f.nret = nret
   136  	f.fint = fint
   137  	f.ot = ot
   138  	f.arg = p
   139  	unlock(&finlock)
   140  	fingStatus.Or(fingWake)
   141  }
   142  
   143  //go:nowritebarrier
   144  func iterate_finq(callback func(*funcval, unsafe.Pointer, uintptr, *_type, *ptrtype)) {
   145  	for fb := allfin; fb != nil; fb = fb.alllink {
   146  		for i := uint32(0); i < fb.cnt; i++ {
   147  			f := &fb.fin[i]
   148  			callback(f.fn, f.arg, f.nret, f.fint, f.ot)
   149  		}
   150  	}
   151  }
   152  
   153  func wakefing() *g {
   154  	if ok := fingStatus.CompareAndSwap(fingCreated|fingWait|fingWake, fingCreated); ok {
   155  		return fing
   156  	}
   157  	return nil
   158  }
   159  
   160  func createfing() {
   161  	// start the finalizer goroutine exactly once
   162  	if fingStatus.Load() == fingUninitialized && fingStatus.CompareAndSwap(fingUninitialized, fingCreated) {
   163  		go runfinq()
   164  	}
   165  }
   166  
   167  func finalizercommit(gp *g, lock unsafe.Pointer) bool {
   168  	unlock((*mutex)(lock))
   169  	// fingStatus should be modified after fing is put into a waiting state
   170  	// to avoid waking fing in running state, even if it is about to be parked.
   171  	fingStatus.Or(fingWait)
   172  	return true
   173  }
   174  
   175  // This is the goroutine that runs all of the finalizers.
   176  func runfinq() {
   177  	var (
   178  		frame    unsafe.Pointer
   179  		framecap uintptr
   180  		argRegs  int
   181  	)
   182  
   183  	gp := getg()
   184  	lock(&finlock)
   185  	fing = gp
   186  	unlock(&finlock)
   187  
   188  	for {
   189  		lock(&finlock)
   190  		fb := finq
   191  		finq = nil
   192  		if fb == nil {
   193  			gopark(finalizercommit, unsafe.Pointer(&finlock), waitReasonFinalizerWait, traceEvGoBlock, 1)
   194  			continue
   195  		}
   196  		argRegs = intArgRegs
   197  		unlock(&finlock)
   198  		if raceenabled {
   199  			racefingo()
   200  		}
   201  		for fb != nil {
   202  			for i := fb.cnt; i > 0; i-- {
   203  				f := &fb.fin[i-1]
   204  
   205  				var regs abi.RegArgs
   206  				// The args may be passed in registers or on stack. Even for
   207  				// the register case, we still need the spill slots.
   208  				// TODO: revisit if we remove spill slots.
   209  				//
   210  				// Unfortunately because we can have an arbitrary
   211  				// amount of returns and it would be complex to try and
   212  				// figure out how many of those can get passed in registers,
   213  				// just conservatively assume none of them do.
   214  				framesz := unsafe.Sizeof((any)(nil)) + f.nret
   215  				if framecap < framesz {
   216  					// The frame does not contain pointers interesting for GC,
   217  					// all not yet finalized objects are stored in finq.
   218  					// If we do not mark it as FlagNoScan,
   219  					// the last finalized object is not collected.
   220  					frame = mallocgc(framesz, nil, true)
   221  					framecap = framesz
   222  				}
   223  
   224  				if f.fint == nil {
   225  					throw("missing type in runfinq")
   226  				}
   227  				r := frame
   228  				if argRegs > 0 {
   229  					r = unsafe.Pointer(&regs.Ints)
   230  				} else {
   231  					// frame is effectively uninitialized
   232  					// memory. That means we have to clear
   233  					// it before writing to it to avoid
   234  					// confusing the write barrier.
   235  					*(*[2]uintptr)(frame) = [2]uintptr{}
   236  				}
   237  				switch f.fint.kind & kindMask {
   238  				case kindPtr:
   239  					// direct use of pointer
   240  					*(*unsafe.Pointer)(r) = f.arg
   241  				case kindInterface:
   242  					ityp := (*interfacetype)(unsafe.Pointer(f.fint))
   243  					// set up with empty interface
   244  					(*eface)(r)._type = &f.ot.typ
   245  					(*eface)(r).data = f.arg
   246  					if len(ityp.mhdr) != 0 {
   247  						// convert to interface with methods
   248  						// this conversion is guaranteed to succeed - we checked in SetFinalizer
   249  						(*iface)(r).tab = assertE2I(ityp, (*eface)(r)._type)
   250  					}
   251  				default:
   252  					throw("bad kind in runfinq")
   253  				}
   254  				fingStatus.Or(fingRunningFinalizer)
   255  				reflectcall(nil, unsafe.Pointer(f.fn), frame, uint32(framesz), uint32(framesz), uint32(framesz), &regs)
   256  				fingStatus.And(^fingRunningFinalizer)
   257  
   258  				// Drop finalizer queue heap references
   259  				// before hiding them from markroot.
   260  				// This also ensures these will be
   261  				// clear if we reuse the finalizer.
   262  				f.fn = nil
   263  				f.arg = nil
   264  				f.ot = nil
   265  				atomic.Store(&fb.cnt, i-1)
   266  			}
   267  			next := fb.next
   268  			lock(&finlock)
   269  			fb.next = finc
   270  			finc = fb
   271  			unlock(&finlock)
   272  			fb = next
   273  		}
   274  	}
   275  }
   276  
   277  // SetFinalizer sets the finalizer associated with obj to the provided
   278  // finalizer function. When the garbage collector finds an unreachable block
   279  // with an associated finalizer, it clears the association and runs
   280  // finalizer(obj) in a separate goroutine. This makes obj reachable again,
   281  // but now without an associated finalizer. Assuming that SetFinalizer
   282  // is not called again, the next time the garbage collector sees
   283  // that obj is unreachable, it will free obj.
   284  //
   285  // SetFinalizer(obj, nil) clears any finalizer associated with obj.
   286  //
   287  // The argument obj must be a pointer to an object allocated by calling
   288  // new, by taking the address of a composite literal, or by taking the
   289  // address of a local variable.
   290  // The argument finalizer must be a function that takes a single argument
   291  // to which obj's type can be assigned, and can have arbitrary ignored return
   292  // values. If either of these is not true, SetFinalizer may abort the
   293  // program.
   294  //
   295  // Finalizers are run in dependency order: if A points at B, both have
   296  // finalizers, and they are otherwise unreachable, only the finalizer
   297  // for A runs; once A is freed, the finalizer for B can run.
   298  // If a cyclic structure includes a block with a finalizer, that
   299  // cycle is not guaranteed to be garbage collected and the finalizer
   300  // is not guaranteed to run, because there is no ordering that
   301  // respects the dependencies.
   302  //
   303  // The finalizer is scheduled to run at some arbitrary time after the
   304  // program can no longer reach the object to which obj points.
   305  // There is no guarantee that finalizers will run before a program exits,
   306  // so typically they are useful only for releasing non-memory resources
   307  // associated with an object during a long-running program.
   308  // For example, an os.File object could use a finalizer to close the
   309  // associated operating system file descriptor when a program discards
   310  // an os.File without calling Close, but it would be a mistake
   311  // to depend on a finalizer to flush an in-memory I/O buffer such as a
   312  // bufio.Writer, because the buffer would not be flushed at program exit.
   313  //
   314  // It is not guaranteed that a finalizer will run if the size of *obj is
   315  // zero bytes, because it may share same address with other zero-size
   316  // objects in memory. See https://go.dev/ref/spec#Size_and_alignment_guarantees.
   317  //
   318  // It is not guaranteed that a finalizer will run for objects allocated
   319  // in initializers for package-level variables. Such objects may be
   320  // linker-allocated, not heap-allocated.
   321  //
   322  // Note that because finalizers may execute arbitrarily far into the future
   323  // after an object is no longer referenced, the runtime is allowed to perform
   324  // a space-saving optimization that batches objects together in a single
   325  // allocation slot. The finalizer for an unreferenced object in such an
   326  // allocation may never run if it always exists in the same batch as a
   327  // referenced object. Typically, this batching only happens for tiny
   328  // (on the order of 16 bytes or less) and pointer-free objects.
   329  //
   330  // A finalizer may run as soon as an object becomes unreachable.
   331  // In order to use finalizers correctly, the program must ensure that
   332  // the object is reachable until it is no longer required.
   333  // Objects stored in global variables, or that can be found by tracing
   334  // pointers from a global variable, are reachable. For other objects,
   335  // pass the object to a call of the KeepAlive function to mark the
   336  // last point in the function where the object must be reachable.
   337  //
   338  // For example, if p points to a struct, such as os.File, that contains
   339  // a file descriptor d, and p has a finalizer that closes that file
   340  // descriptor, and if the last use of p in a function is a call to
   341  // syscall.Write(p.d, buf, size), then p may be unreachable as soon as
   342  // the program enters syscall.Write. The finalizer may run at that moment,
   343  // closing p.d, causing syscall.Write to fail because it is writing to
   344  // a closed file descriptor (or, worse, to an entirely different
   345  // file descriptor opened by a different goroutine). To avoid this problem,
   346  // call KeepAlive(p) after the call to syscall.Write.
   347  //
   348  // A single goroutine runs all finalizers for a program, sequentially.
   349  // If a finalizer must run for a long time, it should do so by starting
   350  // a new goroutine.
   351  //
   352  // In the terminology of the Go memory model, a call
   353  // SetFinalizer(x, f) “synchronizes before” the finalization call f(x).
   354  // However, there is no guarantee that KeepAlive(x) or any other use of x
   355  // “synchronizes before” f(x), so in general a finalizer should use a mutex
   356  // or other synchronization mechanism if it needs to access mutable state in x.
   357  // For example, consider a finalizer that inspects a mutable field in x
   358  // that is modified from time to time in the main program before x
   359  // becomes unreachable and the finalizer is invoked.
   360  // The modifications in the main program and the inspection in the finalizer
   361  // need to use appropriate synchronization, such as mutexes or atomic updates,
   362  // to avoid read-write races.
   363  func SetFinalizer(obj any, finalizer any) {
   364  	if debug.sbrk != 0 {
   365  		// debug.sbrk never frees memory, so no finalizers run
   366  		// (and we don't have the data structures to record them).
   367  		return
   368  	}
   369  	e := efaceOf(&obj)
   370  	etyp := e._type
   371  	if etyp == nil {
   372  		throw("runtime.SetFinalizer: first argument is nil")
   373  	}
   374  	if etyp.kind&kindMask != kindPtr {
   375  		throw("runtime.SetFinalizer: first argument is " + etyp.string() + ", not pointer")
   376  	}
   377  	ot := (*ptrtype)(unsafe.Pointer(etyp))
   378  	if ot.elem == nil {
   379  		throw("nil elem type!")
   380  	}
   381  
   382  	if inUserArenaChunk(uintptr(e.data)) {
   383  		// Arena-allocated objects are not eligible for finalizers.
   384  		throw("runtime.SetFinalizer: first argument was allocated into an arena")
   385  	}
   386  
   387  	// find the containing object
   388  	base, _, _ := findObject(uintptr(e.data), 0, 0)
   389  
   390  	if base == 0 {
   391  		// 0-length objects are okay.
   392  		if e.data == unsafe.Pointer(&zerobase) {
   393  			return
   394  		}
   395  
   396  		// Global initializers might be linker-allocated.
   397  		//	var Foo = &Object{}
   398  		//	func main() {
   399  		//		runtime.SetFinalizer(Foo, nil)
   400  		//	}
   401  		// The relevant segments are: noptrdata, data, bss, noptrbss.
   402  		// We cannot assume they are in any order or even contiguous,
   403  		// due to external linking.
   404  		for datap := &firstmoduledata; datap != nil; datap = datap.next {
   405  			if datap.noptrdata <= uintptr(e.data) && uintptr(e.data) < datap.enoptrdata ||
   406  				datap.data <= uintptr(e.data) && uintptr(e.data) < datap.edata ||
   407  				datap.bss <= uintptr(e.data) && uintptr(e.data) < datap.ebss ||
   408  				datap.noptrbss <= uintptr(e.data) && uintptr(e.data) < datap.enoptrbss {
   409  				return
   410  			}
   411  		}
   412  		throw("runtime.SetFinalizer: pointer not in allocated block")
   413  	}
   414  
   415  	if uintptr(e.data) != base {
   416  		// As an implementation detail we allow to set finalizers for an inner byte
   417  		// of an object if it could come from tiny alloc (see mallocgc for details).
   418  		if ot.elem == nil || ot.elem.ptrdata != 0 || ot.elem.size >= maxTinySize {
   419  			throw("runtime.SetFinalizer: pointer not at beginning of allocated block")
   420  		}
   421  	}
   422  
   423  	f := efaceOf(&finalizer)
   424  	ftyp := f._type
   425  	if ftyp == nil {
   426  		// switch to system stack and remove finalizer
   427  		systemstack(func() {
   428  			removefinalizer(e.data)
   429  		})
   430  		return
   431  	}
   432  
   433  	if ftyp.kind&kindMask != kindFunc {
   434  		throw("runtime.SetFinalizer: second argument is " + ftyp.string() + ", not a function")
   435  	}
   436  	ft := (*functype)(unsafe.Pointer(ftyp))
   437  	if ft.dotdotdot() {
   438  		throw("runtime.SetFinalizer: cannot pass " + etyp.string() + " to finalizer " + ftyp.string() + " because dotdotdot")
   439  	}
   440  	if ft.inCount != 1 {
   441  		throw("runtime.SetFinalizer: cannot pass " + etyp.string() + " to finalizer " + ftyp.string())
   442  	}
   443  	fint := ft.in()[0]
   444  	switch {
   445  	case fint == etyp:
   446  		// ok - same type
   447  		goto okarg
   448  	case fint.kind&kindMask == kindPtr:
   449  		if (fint.uncommon() == nil || etyp.uncommon() == nil) && (*ptrtype)(unsafe.Pointer(fint)).elem == ot.elem {
   450  			// ok - not same type, but both pointers,
   451  			// one or the other is unnamed, and same element type, so assignable.
   452  			goto okarg
   453  		}
   454  	case fint.kind&kindMask == kindInterface:
   455  		ityp := (*interfacetype)(unsafe.Pointer(fint))
   456  		if len(ityp.mhdr) == 0 {
   457  			// ok - satisfies empty interface
   458  			goto okarg
   459  		}
   460  		if iface := assertE2I2(ityp, *efaceOf(&obj)); iface.tab != nil {
   461  			goto okarg
   462  		}
   463  	}
   464  	throw("runtime.SetFinalizer: cannot pass " + etyp.string() + " to finalizer " + ftyp.string())
   465  okarg:
   466  	// compute size needed for return parameters
   467  	nret := uintptr(0)
   468  	for _, t := range ft.out() {
   469  		nret = alignUp(nret, uintptr(t.align)) + uintptr(t.size)
   470  	}
   471  	nret = alignUp(nret, goarch.PtrSize)
   472  
   473  	// make sure we have a finalizer goroutine
   474  	createfing()
   475  
   476  	systemstack(func() {
   477  		if !addfinalizer(e.data, (*funcval)(f.data), nret, fint, ot) {
   478  			throw("runtime.SetFinalizer: finalizer already set")
   479  		}
   480  	})
   481  }
   482  
   483  // Mark KeepAlive as noinline so that it is easily detectable as an intrinsic.
   484  //
   485  //go:noinline
   486  
   487  // KeepAlive marks its argument as currently reachable.
   488  // This ensures that the object is not freed, and its finalizer is not run,
   489  // before the point in the program where KeepAlive is called.
   490  //
   491  // A very simplified example showing where KeepAlive is required:
   492  //
   493  //	type File struct { d int }
   494  //	d, err := syscall.Open("/file/path", syscall.O_RDONLY, 0)
   495  //	// ... do something if err != nil ...
   496  //	p := &File{d}
   497  //	runtime.SetFinalizer(p, func(p *File) { syscall.Close(p.d) })
   498  //	var buf [10]byte
   499  //	n, err := syscall.Read(p.d, buf[:])
   500  //	// Ensure p is not finalized until Read returns.
   501  //	runtime.KeepAlive(p)
   502  //	// No more uses of p after this point.
   503  //
   504  // Without the KeepAlive call, the finalizer could run at the start of
   505  // syscall.Read, closing the file descriptor before syscall.Read makes
   506  // the actual system call.
   507  //
   508  // Note: KeepAlive should only be used to prevent finalizers from
   509  // running prematurely. In particular, when used with unsafe.Pointer,
   510  // the rules for valid uses of unsafe.Pointer still apply.
   511  func KeepAlive(x any) {
   512  	// Introduce a use of x that the compiler can't eliminate.
   513  	// This makes sure x is alive on entry. We need x to be alive
   514  	// on entry for "defer runtime.KeepAlive(x)"; see issue 21402.
   515  	if cgoAlwaysFalse {
   516  		println(x)
   517  	}
   518  }
   519  

View as plain text