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