libgo/go/runtime/os_linux.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 package runtime
   6
   7 import (
   8         "runtime/internal/sys"
   9         "unsafe"
  10 )
  11
  12 type mOS struct {
  13         unused byte
  14 }
  15
  16 func futex(addr unsafe.Pointer, op int32, val uint32, ts, addr2 unsafe.Pointer, val3 uint32) int32 {
  17         return int32(syscall(_SYS_futex, uintptr(addr), uintptr(op), uintptr(val), uintptr(ts), uintptr(addr2), uintptr(val3)))
  18 }
  19
  20 // Linux futex.
  21 //
  22 //      futexsleep(uint32 *addr, uint32 val)
  23 //      futexwakeup(uint32 *addr)
  24 //
  25 // Futexsleep atomically checks if *addr == val and if so, sleeps on addr.
  26 // Futexwakeup wakes up threads sleeping on addr.
  27 // Futexsleep is allowed to wake up spuriously.
  28
  29 const (
  30         _FUTEX_WAIT = 0
  31         _FUTEX_WAKE = 1
  32 )
  33
  34 // Atomically,
  35 //      if(*addr == val) sleep
  36 // Might be woken up spuriously; that's allowed.
  37 // Don't sleep longer than ns; ns < 0 means forever.
  38 //go:nosplit
  39 func futexsleep(addr *uint32, val uint32, ns int64) {
  40         var ts timespec
  41
  42         // Some Linux kernels have a bug where futex of
  43         // FUTEX_WAIT returns an internal error code
  44         // as an errno. Libpthread ignores the return value
  45         // here, and so can we: as it says a few lines up,
  46         // spurious wakeups are allowed.
  47         if ns < 0 {
  48                 futex(unsafe.Pointer(addr), _FUTEX_WAIT, val, nil, nil, 0)
  49                 return
  50         }
  51
  52         // It's difficult to live within the no-split stack limits here.
  53         // On ARM and 386, a 64-bit divide invokes a general software routine
  54         // that needs more stack than we can afford. So we use timediv instead.
  55         // But on real 64-bit systems, where words are larger but the stack limit
  56         // is not, even timediv is too heavy, and we really need to use just an
  57         // ordinary machine instruction.
  58         if sys.PtrSize == 8 {
  59                 ts.set_sec(ns / 1000000000)
  60                 ts.set_nsec(int32(ns % 1000000000))
  61         } else {
  62                 ts.tv_nsec = 0
  63                 ts.set_sec(int64(timediv(ns, 1000000000, (*int32)(unsafe.Pointer(&ts.tv_nsec)))))
  64         }
  65         futex(unsafe.Pointer(addr), _FUTEX_WAIT, val, unsafe.Pointer(&ts), nil, 0)
  66 }
  67
  68 // If any procs are sleeping on addr, wake up at most cnt.
  69 //go:nosplit
  70 func futexwakeup(addr *uint32, cnt uint32) {
  71         ret := futex(unsafe.Pointer(addr), _FUTEX_WAKE, cnt, nil, nil, 0)
  72         if ret >= 0 {
  73                 return
  74         }
  75
  76         // I don't know that futex wakeup can return
  77         // EAGAIN or EINTR, but if it does, it would be
  78         // safe to loop and call futex again.
  79         systemstack(func() {
  80                 print("futexwakeup addr=", addr, " returned ", ret, "\n")
  81         })
  82
  83         *(*int32)(unsafe.Pointer(uintptr(0x1006))) = 0x1006
  84 }
  85
  86 const (
  87         _AT_NULL   = 0  // End of vector
  88         _AT_PAGESZ = 6  // System physical page size
  89         _AT_HWCAP  = 16 // hardware capability bit vector
  90         _AT_RANDOM = 25 // introduced in 2.6.29
  91         _AT_HWCAP2 = 26 // hardware capability bit vector 2
  92 )
  93
  94 var procAuxv = []byte("/proc/self/auxv\x00")
  95
  96 func sysargs(argc int32, argv **byte) {
  97         n := argc + 1
  98
  99         // skip over argv, envp to get to auxv
 100         for argv_index(argv, n) != nil {
 101                 n++
 102         }
 103
 104         // skip NULL separator
 105         n++
 106
 107         // now argv+n is auxv
 108         auxv := (*[1 << 28]uintptr)(add(unsafe.Pointer(argv), uintptr(n)*sys.PtrSize))
 109         if sysauxv(auxv[:]) == 0 {
 110                 // In some situations we don't get a loader-provided
 111                 // auxv, such as when loaded as a library on Android.
 112                 // Fall back to /proc/self/auxv.
 113                 fd := open(&procAuxv[0], 0 /* O_RDONLY */, 0)
 114                 if fd < 0 {
 115                         // On Android, /proc/self/auxv might be unreadable (issue 9229), so we fallback to
 116                         // try using mincore to detect the physical page size.
 117                         // mincore should return EINVAL when address is not a multiple of system page size.
 118                         const size = 256 << 10 // size of memory region to allocate
 119                         p := mmap(nil, size, _PROT_READ|_PROT_WRITE, _MAP_ANON|_MAP_PRIVATE, -1, 0)
 120                         if uintptr(p) < 4096 {
 121                                 return
 122                         }
 123                         var n uintptr
 124                         for n = 4 << 10; n < size; n <<= 1 {
 125                                 err := mincore(unsafe.Pointer(uintptr(p)+n), 1, &addrspace_vec[0])
 126                                 if err == 0 {
 127                                         physPageSize = n
 128                                         break
 129                                 }
 130                         }
 131                         if physPageSize == 0 {
 132                                 physPageSize = size
 133                         }
 134                         munmap(p, size)
 135                         return
 136                 }
 137                 var buf [128]uintptr
 138                 n := read(fd, noescape(unsafe.Pointer(&buf[0])), int32(unsafe.Sizeof(buf)))
 139                 closefd(fd)
 140                 if n < 0 {
 141                         return
 142                 }
 143                 // Make sure buf is terminated, even if we didn't read
 144                 // the whole file.
 145                 buf[len(buf)-2] = _AT_NULL
 146                 sysauxv(buf[:])
 147         }
 148 }
 149
 150 func sysauxv(auxv []uintptr) int {
 151         var i int
 152         for ; auxv[i] != _AT_NULL; i += 2 {
 153                 tag, val := auxv[i], auxv[i+1]
 154                 switch tag {
 155                 case _AT_RANDOM:
 156                         // The kernel provides a pointer to 16-bytes
 157                         // worth of random data.
 158                         startupRandomData = (*[16]byte)(unsafe.Pointer(val))[:]
 159
 160                 case _AT_PAGESZ:
 161                         physPageSize = val
 162                 }
 163
 164                 // Commented out for gccgo for now.
 165                 // archauxv(tag, val)
 166         }
 167         return i / 2
 168 }