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