src/syscall/syscall_darwin.go

   1 // Copyright 2009,2010 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 // Darwin system calls.
   6 // This file is compiled as ordinary Go code,
   7 // but it is also input to mksyscall,
   8 // which parses the //sys lines and generates system call stubs.
   9 // Note that sometimes we use a lowercase //sys name and wrap
  10 // it in our own nicer implementation, either here or in
  11 // syscall_bsd.go or syscall_unix.go.
  12
  13 package syscall
  14
  15 import "unsafe"
  16
  17 type SockaddrDatalink struct {
  18         Len    uint8
  19         Family uint8
  20         Index  uint16
  21         Type   uint8
  22         Nlen   uint8
  23         Alen   uint8
  24         Slen   uint8
  25         Data   [12]int8
  26         raw    RawSockaddrDatalink
  27 }
  28
  29 // Translate "kern.hostname" to []_C_int{0,1,2,3}.
  30 func nametomib(name string) (mib []_C_int, err error) {
  31         const siz = unsafe.Sizeof(mib[0])
  32
  33         // NOTE(rsc): It seems strange to set the buffer to have
  34         // size CTL_MAXNAME+2 but use only CTL_MAXNAME
  35         // as the size. I don't know why the +2 is here, but the
  36         // kernel uses +2 for its own implementation of this function.
  37         // I am scared that if we don't include the +2 here, the kernel
  38         // will silently write 2 words farther than we specify
  39         // and we'll get memory corruption.
  40         var buf [CTL_MAXNAME + 2]_C_int
  41         n := uintptr(CTL_MAXNAME) * siz
  42
  43         p := (*byte)(unsafe.Pointer(&buf[0]))
  44         bytes, err := ByteSliceFromString(name)
  45         if err != nil {
  46                 return nil, err
  47         }
  48
  49         // Magic sysctl: "setting" 0.3 to a string name
  50         // lets you read back the array of integers form.
  51         if err = sysctl([]_C_int{0, 3}, p, &n, &bytes[0], uintptr(len(name))); err != nil {
  52                 return nil, err
  53         }
  54         return buf[0 : n/siz], nil
  55 }
  56
  57 func direntIno(buf []byte) (uint64, bool) {
  58         return readInt(buf, unsafe.Offsetof(Dirent{}.Ino), unsafe.Sizeof(Dirent{}.Ino))
  59 }
  60
  61 func direntReclen(buf []byte) (uint64, bool) {
  62         return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen))
  63 }
  64
  65 func direntNamlen(buf []byte) (uint64, bool) {
  66         return readInt(buf, unsafe.Offsetof(Dirent{}.Namlen), unsafe.Sizeof(Dirent{}.Namlen))
  67 }
  68
  69 func PtraceAttach(pid int) (err error) { return ptrace(PT_ATTACH, pid, 0, 0) }
  70 func PtraceDetach(pid int) (err error) { return ptrace(PT_DETACH, pid, 0, 0) }
  71
  72 const (
  73         attrBitMapCount = 5
  74         attrCmnModtime  = 0x00000400
  75         attrCmnAcctime  = 0x00001000
  76 )
  77
  78 type attrList struct {
  79         bitmapCount uint16
  80         _           uint16
  81         CommonAttr  uint32
  82         VolAttr     uint32
  83         DirAttr     uint32
  84         FileAttr    uint32
  85         Forkattr    uint32
  86 }
  87
  88 //sysnb pipe(p *[2]int32) (err error)
  89
  90 func Pipe(p []int) (err error) {
  91         if len(p) != 2 {
  92                 return EINVAL
  93         }
  94         var q [2]int32
  95         err = pipe(&q)
  96         p[0] = int(q[0])
  97         p[1] = int(q[1])
  98         return
  99 }
 100
 101 func Getfsstat(buf []Statfs_t, flags int) (n int, err error) {
 102         var _p0 unsafe.Pointer
 103         var bufsize uintptr
 104         if len(buf) > 0 {
 105                 _p0 = unsafe.Pointer(&buf[0])
 106                 bufsize = unsafe.Sizeof(Statfs_t{}) * uintptr(len(buf))
 107         }
 108         r0, _, e1 := syscall(funcPC(libc_getfsstat_trampoline), uintptr(_p0), bufsize, uintptr(flags))
 109         n = int(r0)
 110         if e1 != 0 {
 111                 err = e1
 112         }
 113         return
 114 }
 115
 116 func libc_getfsstat_trampoline()
 117
 118 //go:linkname libc_getfsstat libc_getfsstat
 119 //go:cgo_import_dynamic libc_getfsstat getfsstat "/usr/lib/libSystem.B.dylib"
 120
 121 func setattrlistTimes(path string, times []Timespec) error {
 122         _p0, err := BytePtrFromString(path)
 123         if err != nil {
 124                 return err
 125         }
 126
 127         var attrList attrList
 128         attrList.bitmapCount = attrBitMapCount
 129         attrList.CommonAttr = attrCmnModtime | attrCmnAcctime
 130
 131         // order is mtime, atime: the opposite of Chtimes
 132         attributes := [2]Timespec{times[1], times[0]}
 133         const options = 0
 134         _, _, e1 := syscall6(
 135                 funcPC(libc_setattrlist_trampoline),
 136                 uintptr(unsafe.Pointer(_p0)),
 137                 uintptr(unsafe.Pointer(&attrList)),
 138                 uintptr(unsafe.Pointer(&attributes)),
 139                 uintptr(unsafe.Sizeof(attributes)),
 140                 uintptr(options),
 141                 0,
 142         )
 143         if e1 != 0 {
 144                 return e1
 145         }
 146         return nil
 147 }
 148
 149 func libc_setattrlist_trampoline()
 150
 151 //go:linkname libc_setattrlist libc_setattrlist
 152 //go:cgo_import_dynamic libc_setattrlist setattrlist "/usr/lib/libSystem.B.dylib"
 153
 154 func utimensat(dirfd int, path string, times *[2]Timespec, flag int) error {
 155         // Darwin doesn't support SYS_UTIMENSAT
 156         return ENOSYS
 157 }
 158
 159 /*
 160  * Wrapped
 161  */
 162
 163 //sys   kill(pid int, signum int, posix int) (err error)
 164
 165 func Kill(pid int, signum Signal) (err error) { return kill(pid, int(signum), 1) }
 166
 167 /*
 168  * Exposed directly
 169  */
 170 //sys   Access(path string, mode uint32) (err error)
 171 //sys   Adjtime(delta *Timeval, olddelta *Timeval) (err error)
 172 //sys   Chdir(path string) (err error)
 173 //sys   Chflags(path string, flags int) (err error)
 174 //sys   Chmod(path string, mode uint32) (err error)
 175 //sys   Chown(path string, uid int, gid int) (err error)
 176 //sys   Chroot(path string) (err error)
 177 //sys   Close(fd int) (err error)
 178 //sys   closedir(dir uintptr) (err error)
 179 //sys   Dup(fd int) (nfd int, err error)
 180 //sys   Dup2(from int, to int) (err error)
 181 //sys   Exchangedata(path1 string, path2 string, options int) (err error)
 182 //sys   Fchdir(fd int) (err error)
 183 //sys   Fchflags(fd int, flags int) (err error)
 184 //sys   Fchmod(fd int, mode uint32) (err error)
 185 //sys   Fchown(fd int, uid int, gid int) (err error)
 186 //sys   Flock(fd int, how int) (err error)
 187 //sys   Fpathconf(fd int, name int) (val int, err error)
 188 //sys   Fsync(fd int) (err error)
 189 //  Fsync is not called for os.File.Sync(). Please see internal/poll/fd_fsync_darwin.go
 190 //sys   Ftruncate(fd int, length int64) (err error)
 191 //sys   Getdtablesize() (size int)
 192 //sysnb Getegid() (egid int)
 193 //sysnb Geteuid() (uid int)
 194 //sysnb Getgid() (gid int)
 195 //sysnb Getpgid(pid int) (pgid int, err error)
 196 //sysnb Getpgrp() (pgrp int)
 197 //sysnb Getpid() (pid int)
 198 //sysnb Getppid() (ppid int)
 199 //sys   Getpriority(which int, who int) (prio int, err error)
 200 //sysnb Getrlimit(which int, lim *Rlimit) (err error)
 201 //sysnb Getrusage(who int, rusage *Rusage) (err error)
 202 //sysnb Getsid(pid int) (sid int, err error)
 203 //sysnb Getuid() (uid int)
 204 //sysnb Issetugid() (tainted bool)
 205 //sys   Kqueue() (fd int, err error)
 206 //sys   Lchown(path string, uid int, gid int) (err error)
 207 //sys   Link(path string, link string) (err error)
 208 //sys   Listen(s int, backlog int) (err error)
 209 //sys   Mkdir(path string, mode uint32) (err error)
 210 //sys   Mkfifo(path string, mode uint32) (err error)
 211 //sys   Mknod(path string, mode uint32, dev int) (err error)
 212 //sys   Mlock(b []byte) (err error)
 213 //sys   Mlockall(flags int) (err error)
 214 //sys   Mprotect(b []byte, prot int) (err error)
 215 //sys   Munlock(b []byte) (err error)
 216 //sys   Munlockall() (err error)
 217 //sys   Open(path string, mode int, perm uint32) (fd int, err error)
 218 //sys   Pathconf(path string, name int) (val int, err error)
 219 //sys   Pread(fd int, p []byte, offset int64) (n int, err error)
 220 //sys   Pwrite(fd int, p []byte, offset int64) (n int, err error)
 221 //sys   read(fd int, p []byte) (n int, err error)
 222 //sys   readdir_r(dir uintptr, entry *Dirent, result **Dirent) (res Errno)
 223 //sys   Readlink(path string, buf []byte) (n int, err error)
 224 //sys   Rename(from string, to string) (err error)
 225 //sys   Revoke(path string) (err error)
 226 //sys   Rmdir(path string) (err error)
 227 //sys   Seek(fd int, offset int64, whence int) (newoffset int64, err error) = SYS_lseek
 228 //sys   Select(n int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (err error)
 229 //sys   Setegid(egid int) (err error)
 230 //sysnb Seteuid(euid int) (err error)
 231 //sysnb Setgid(gid int) (err error)
 232 //sys   Setlogin(name string) (err error)
 233 //sysnb Setpgid(pid int, pgid int) (err error)
 234 //sys   Setpriority(which int, who int, prio int) (err error)
 235 //sys   Setprivexec(flag int) (err error)
 236 //sysnb Setregid(rgid int, egid int) (err error)
 237 //sysnb Setreuid(ruid int, euid int) (err error)
 238 //sysnb Setrlimit(which int, lim *Rlimit) (err error)
 239 //sysnb Setsid() (pid int, err error)
 240 //sysnb Settimeofday(tp *Timeval) (err error)
 241 //sysnb Setuid(uid int) (err error)
 242 //sys   Symlink(path string, link string) (err error)
 243 //sys   Sync() (err error)
 244 //sys   Truncate(path string, length int64) (err error)
 245 //sys   Umask(newmask int) (oldmask int)
 246 //sys   Undelete(path string) (err error)
 247 //sys   Unlink(path string) (err error)
 248 //sys   Unmount(path string, flags int) (err error)
 249 //sys   write(fd int, p []byte) (n int, err error)
 250 //sys   writev(fd int, iovecs []Iovec) (cnt uintptr, err error)
 251 //sys   mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error)
 252 //sys   munmap(addr uintptr, length uintptr) (err error)
 253 //sysnb fork() (pid int, err error)
 254 //sysnb ioctl(fd int, req int, arg int) (err error)
 255 //sysnb ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) = SYS_ioctl
 256 //sysnb execve(path *byte, argv **byte, envp **byte) (err error)
 257 //sysnb exit(res int) (err error)
 258 //sys   sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error)
 259 //sys   fcntlPtr(fd int, cmd int, arg unsafe.Pointer) (val int, err error) = SYS_fcntl
 260 //sys   unlinkat(fd int, path string, flags int) (err error)
 261 //sys   openat(fd int, path string, flags int, perm uint32) (fdret int, err error)
 262 //sys   getcwd(buf []byte) (n int, err error)
 263
 264 func init() {
 265         execveDarwin = execve
 266 }
 267
 268 func fdopendir(fd int) (dir uintptr, err error) {
 269         r0, _, e1 := syscallPtr(funcPC(libc_fdopendir_trampoline), uintptr(fd), 0, 0)
 270         dir = uintptr(r0)
 271         if e1 != 0 {
 272                 err = errnoErr(e1)
 273         }
 274         return
 275 }
 276
 277 func libc_fdopendir_trampoline()
 278
 279 //go:linkname libc_fdopendir libc_fdopendir
 280 //go:cgo_import_dynamic libc_fdopendir fdopendir "/usr/lib/libSystem.B.dylib"
 281
 282 func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
 283         r0, _, e1 := syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
 284         n = int(r0)
 285         if e1 != 0 {
 286                 err = errnoErr(e1)
 287         }
 288         return
 289 }
 290
 291 func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
 292         r0, _, e1 := syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
 293         n = int(r0)
 294         if e1 != 0 {
 295                 err = errnoErr(e1)
 296         }
 297         return
 298 }
 299
 300 func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) {
 301         // Simulate Getdirentries using fdopendir/readdir_r/closedir.
 302         // We store the number of entries to skip in the seek
 303         // offset of fd. See issue #31368.
 304         // It's not the full required semantics, but should handle the case
 305         // of calling Getdirentries or ReadDirent repeatedly.
 306         // It won't handle assigning the results of lseek to *basep, or handle
 307         // the directory being edited underfoot.
 308         skip, err := Seek(fd, 0, 1 /* SEEK_CUR */)
 309         if err != nil {
 310                 return 0, err
 311         }
 312
 313         // We need to duplicate the incoming file descriptor
 314         // because the caller expects to retain control of it, but
 315         // fdopendir expects to take control of its argument.
 316         // Just Dup'ing the file descriptor is not enough, as the
 317         // result shares underlying state. Use openat to make a really
 318         // new file descriptor referring to the same directory.
 319         fd2, err := openat(fd, ".", O_RDONLY, 0)
 320         if err != nil {
 321                 return 0, err
 322         }
 323         d, err := fdopendir(fd2)
 324         if err != nil {
 325                 Close(fd2)
 326                 return 0, err
 327         }
 328         defer closedir(d)
 329
 330         var cnt int64
 331         for {
 332                 var entry Dirent
 333                 var entryp *Dirent
 334                 e := readdir_r(d, &entry, &entryp)
 335                 if e != 0 {
 336                         return n, errnoErr(e)
 337                 }
 338                 if entryp == nil {
 339                         break
 340                 }
 341                 if skip > 0 {
 342                         skip--
 343                         cnt++
 344                         continue
 345                 }
 346                 reclen := int(entry.Reclen)
 347                 if reclen > len(buf) {
 348                         // Not enough room. Return for now.
 349                         // The counter will let us know where we should start up again.
 350                         // Note: this strategy for suspending in the middle and
 351                         // restarting is O(n^2) in the length of the directory. Oh well.
 352                         break
 353                 }
 354                 // Copy entry into return buffer.
 355                 s := struct {
 356                         ptr unsafe.Pointer
 357                         siz int
 358                         cap int
 359                 }{ptr: unsafe.Pointer(&entry), siz: reclen, cap: reclen}
 360                 copy(buf, *(*[]byte)(unsafe.Pointer(&s)))
 361                 buf = buf[reclen:]
 362                 n += reclen
 363                 cnt++
 364         }
 365         // Set the seek offset of the input fd to record
 366         // how many files we've already returned.
 367         _, err = Seek(fd, cnt, 0 /* SEEK_SET */)
 368         if err != nil {
 369                 return n, err
 370         }
 371
 372         return n, nil
 373 }
 374
 375 // Implemented in the runtime package (runtime/sys_darwin.go)
 376 func syscall(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
 377 func syscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
 378 func syscall6X(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
 379 func rawSyscall(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
 380 func rawSyscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
 381 func syscallPtr(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
 382
 383 // Find the entry point for f. See comments in runtime/proc.go for the
 384 // function of the same name.
 385 //go:nosplit
 386 func funcPC(f func()) uintptr {
 387         return **(**uintptr)(unsafe.Pointer(&f))
 388 }