github.com/nibnait/go-learn@v0.0.0-20220227013611-dfa47ea6d2da/src/pkg/mod/golang.org/x/sys@v0.0.0-20210630005230-0f9fa26af87c/unix/syscall_linux.go (about) 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 // Linux 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 10 // wrap it in our own nicer implementation. 11 12 package unix 13 14 import ( 15 "encoding/binary" 16 "runtime" 17 "syscall" 18 "unsafe" 19 ) 20 21 /* 22 * Wrapped 23 */ 24 25 func Access(path string, mode uint32) (err error) { 26 return Faccessat(AT_FDCWD, path, mode, 0) 27 } 28 29 func Chmod(path string, mode uint32) (err error) { 30 return Fchmodat(AT_FDCWD, path, mode, 0) 31 } 32 33 func Chown(path string, uid int, gid int) (err error) { 34 return Fchownat(AT_FDCWD, path, uid, gid, 0) 35 } 36 37 func Creat(path string, mode uint32) (fd int, err error) { 38 return Open(path, O_CREAT|O_WRONLY|O_TRUNC, mode) 39 } 40 41 //sys FanotifyInit(flags uint, event_f_flags uint) (fd int, err error) 42 //sys fanotifyMark(fd int, flags uint, mask uint64, dirFd int, pathname *byte) (err error) 43 44 func FanotifyMark(fd int, flags uint, mask uint64, dirFd int, pathname string) (err error) { 45 if pathname == "" { 46 return fanotifyMark(fd, flags, mask, dirFd, nil) 47 } 48 p, err := BytePtrFromString(pathname) 49 if err != nil { 50 return err 51 } 52 return fanotifyMark(fd, flags, mask, dirFd, p) 53 } 54 55 //sys fchmodat(dirfd int, path string, mode uint32) (err error) 56 57 func Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) { 58 // Linux fchmodat doesn't support the flags parameter. Mimick glibc's behavior 59 // and check the flags. Otherwise the mode would be applied to the symlink 60 // destination which is not what the user expects. 61 if flags&^AT_SYMLINK_NOFOLLOW != 0 { 62 return EINVAL 63 } else if flags&AT_SYMLINK_NOFOLLOW != 0 { 64 return EOPNOTSUPP 65 } 66 return fchmodat(dirfd, path, mode) 67 } 68 69 //sys ioctl(fd int, req uint, arg uintptr) (err error) 70 71 // ioctl itself should not be exposed directly, but additional get/set 72 // functions for specific types are permissible. 73 // These are defined in ioctl.go and ioctl_linux.go. 74 75 //sys Linkat(olddirfd int, oldpath string, newdirfd int, newpath string, flags int) (err error) 76 77 func Link(oldpath string, newpath string) (err error) { 78 return Linkat(AT_FDCWD, oldpath, AT_FDCWD, newpath, 0) 79 } 80 81 func Mkdir(path string, mode uint32) (err error) { 82 return Mkdirat(AT_FDCWD, path, mode) 83 } 84 85 func Mknod(path string, mode uint32, dev int) (err error) { 86 return Mknodat(AT_FDCWD, path, mode, dev) 87 } 88 89 func Open(path string, mode int, perm uint32) (fd int, err error) { 90 return openat(AT_FDCWD, path, mode|O_LARGEFILE, perm) 91 } 92 93 //sys openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) 94 95 func Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) { 96 return openat(dirfd, path, flags|O_LARGEFILE, mode) 97 } 98 99 //sys openat2(dirfd int, path string, open_how *OpenHow, size int) (fd int, err error) 100 101 func Openat2(dirfd int, path string, how *OpenHow) (fd int, err error) { 102 return openat2(dirfd, path, how, SizeofOpenHow) 103 } 104 105 //sys ppoll(fds *PollFd, nfds int, timeout *Timespec, sigmask *Sigset_t) (n int, err error) 106 107 func Ppoll(fds []PollFd, timeout *Timespec, sigmask *Sigset_t) (n int, err error) { 108 if len(fds) == 0 { 109 return ppoll(nil, 0, timeout, sigmask) 110 } 111 return ppoll(&fds[0], len(fds), timeout, sigmask) 112 } 113 114 //sys Readlinkat(dirfd int, path string, buf []byte) (n int, err error) 115 116 func Readlink(path string, buf []byte) (n int, err error) { 117 return Readlinkat(AT_FDCWD, path, buf) 118 } 119 120 func Rename(oldpath string, newpath string) (err error) { 121 return Renameat(AT_FDCWD, oldpath, AT_FDCWD, newpath) 122 } 123 124 func Rmdir(path string) error { 125 return Unlinkat(AT_FDCWD, path, AT_REMOVEDIR) 126 } 127 128 //sys Symlinkat(oldpath string, newdirfd int, newpath string) (err error) 129 130 func Symlink(oldpath string, newpath string) (err error) { 131 return Symlinkat(oldpath, AT_FDCWD, newpath) 132 } 133 134 func Unlink(path string) error { 135 return Unlinkat(AT_FDCWD, path, 0) 136 } 137 138 //sys Unlinkat(dirfd int, path string, flags int) (err error) 139 140 func Utimes(path string, tv []Timeval) error { 141 if tv == nil { 142 err := utimensat(AT_FDCWD, path, nil, 0) 143 if err != ENOSYS { 144 return err 145 } 146 return utimes(path, nil) 147 } 148 if len(tv) != 2 { 149 return EINVAL 150 } 151 var ts [2]Timespec 152 ts[0] = NsecToTimespec(TimevalToNsec(tv[0])) 153 ts[1] = NsecToTimespec(TimevalToNsec(tv[1])) 154 err := utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0) 155 if err != ENOSYS { 156 return err 157 } 158 return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) 159 } 160 161 //sys utimensat(dirfd int, path string, times *[2]Timespec, flags int) (err error) 162 163 func UtimesNano(path string, ts []Timespec) error { 164 if ts == nil { 165 err := utimensat(AT_FDCWD, path, nil, 0) 166 if err != ENOSYS { 167 return err 168 } 169 return utimes(path, nil) 170 } 171 if len(ts) != 2 { 172 return EINVAL 173 } 174 err := utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0) 175 if err != ENOSYS { 176 return err 177 } 178 // If the utimensat syscall isn't available (utimensat was added to Linux 179 // in 2.6.22, Released, 8 July 2007) then fall back to utimes 180 var tv [2]Timeval 181 for i := 0; i < 2; i++ { 182 tv[i] = NsecToTimeval(TimespecToNsec(ts[i])) 183 } 184 return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) 185 } 186 187 func UtimesNanoAt(dirfd int, path string, ts []Timespec, flags int) error { 188 if ts == nil { 189 return utimensat(dirfd, path, nil, flags) 190 } 191 if len(ts) != 2 { 192 return EINVAL 193 } 194 return utimensat(dirfd, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), flags) 195 } 196 197 func Futimesat(dirfd int, path string, tv []Timeval) error { 198 if tv == nil { 199 return futimesat(dirfd, path, nil) 200 } 201 if len(tv) != 2 { 202 return EINVAL 203 } 204 return futimesat(dirfd, path, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) 205 } 206 207 func Futimes(fd int, tv []Timeval) (err error) { 208 // Believe it or not, this is the best we can do on Linux 209 // (and is what glibc does). 210 return Utimes("/proc/self/fd/"+itoa(fd), tv) 211 } 212 213 const ImplementsGetwd = true 214 215 //sys Getcwd(buf []byte) (n int, err error) 216 217 func Getwd() (wd string, err error) { 218 var buf [PathMax]byte 219 n, err := Getcwd(buf[0:]) 220 if err != nil { 221 return "", err 222 } 223 // Getcwd returns the number of bytes written to buf, including the NUL. 224 if n < 1 || n > len(buf) || buf[n-1] != 0 { 225 return "", EINVAL 226 } 227 return string(buf[0 : n-1]), nil 228 } 229 230 func Getgroups() (gids []int, err error) { 231 n, err := getgroups(0, nil) 232 if err != nil { 233 return nil, err 234 } 235 if n == 0 { 236 return nil, nil 237 } 238 239 // Sanity check group count. Max is 1<<16 on Linux. 240 if n < 0 || n > 1<<20 { 241 return nil, EINVAL 242 } 243 244 a := make([]_Gid_t, n) 245 n, err = getgroups(n, &a[0]) 246 if err != nil { 247 return nil, err 248 } 249 gids = make([]int, n) 250 for i, v := range a[0:n] { 251 gids[i] = int(v) 252 } 253 return 254 } 255 256 func Setgroups(gids []int) (err error) { 257 if len(gids) == 0 { 258 return setgroups(0, nil) 259 } 260 261 a := make([]_Gid_t, len(gids)) 262 for i, v := range gids { 263 a[i] = _Gid_t(v) 264 } 265 return setgroups(len(a), &a[0]) 266 } 267 268 type WaitStatus uint32 269 270 // Wait status is 7 bits at bottom, either 0 (exited), 271 // 0x7F (stopped), or a signal number that caused an exit. 272 // The 0x80 bit is whether there was a core dump. 273 // An extra number (exit code, signal causing a stop) 274 // is in the high bits. At least that's the idea. 275 // There are various irregularities. For example, the 276 // "continued" status is 0xFFFF, distinguishing itself 277 // from stopped via the core dump bit. 278 279 const ( 280 mask = 0x7F 281 core = 0x80 282 exited = 0x00 283 stopped = 0x7F 284 shift = 8 285 ) 286 287 func (w WaitStatus) Exited() bool { return w&mask == exited } 288 289 func (w WaitStatus) Signaled() bool { return w&mask != stopped && w&mask != exited } 290 291 func (w WaitStatus) Stopped() bool { return w&0xFF == stopped } 292 293 func (w WaitStatus) Continued() bool { return w == 0xFFFF } 294 295 func (w WaitStatus) CoreDump() bool { return w.Signaled() && w&core != 0 } 296 297 func (w WaitStatus) ExitStatus() int { 298 if !w.Exited() { 299 return -1 300 } 301 return int(w>>shift) & 0xFF 302 } 303 304 func (w WaitStatus) Signal() syscall.Signal { 305 if !w.Signaled() { 306 return -1 307 } 308 return syscall.Signal(w & mask) 309 } 310 311 func (w WaitStatus) StopSignal() syscall.Signal { 312 if !w.Stopped() { 313 return -1 314 } 315 return syscall.Signal(w>>shift) & 0xFF 316 } 317 318 func (w WaitStatus) TrapCause() int { 319 if w.StopSignal() != SIGTRAP { 320 return -1 321 } 322 return int(w>>shift) >> 8 323 } 324 325 //sys wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) 326 327 func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) { 328 var status _C_int 329 wpid, err = wait4(pid, &status, options, rusage) 330 if wstatus != nil { 331 *wstatus = WaitStatus(status) 332 } 333 return 334 } 335 336 func Mkfifo(path string, mode uint32) error { 337 return Mknod(path, mode|S_IFIFO, 0) 338 } 339 340 func Mkfifoat(dirfd int, path string, mode uint32) error { 341 return Mknodat(dirfd, path, mode|S_IFIFO, 0) 342 } 343 344 func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) { 345 if sa.Port < 0 || sa.Port > 0xFFFF { 346 return nil, 0, EINVAL 347 } 348 sa.raw.Family = AF_INET 349 p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) 350 p[0] = byte(sa.Port >> 8) 351 p[1] = byte(sa.Port) 352 for i := 0; i < len(sa.Addr); i++ { 353 sa.raw.Addr[i] = sa.Addr[i] 354 } 355 return unsafe.Pointer(&sa.raw), SizeofSockaddrInet4, nil 356 } 357 358 func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) { 359 if sa.Port < 0 || sa.Port > 0xFFFF { 360 return nil, 0, EINVAL 361 } 362 sa.raw.Family = AF_INET6 363 p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) 364 p[0] = byte(sa.Port >> 8) 365 p[1] = byte(sa.Port) 366 sa.raw.Scope_id = sa.ZoneId 367 for i := 0; i < len(sa.Addr); i++ { 368 sa.raw.Addr[i] = sa.Addr[i] 369 } 370 return unsafe.Pointer(&sa.raw), SizeofSockaddrInet6, nil 371 } 372 373 func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) { 374 name := sa.Name 375 n := len(name) 376 if n >= len(sa.raw.Path) { 377 return nil, 0, EINVAL 378 } 379 sa.raw.Family = AF_UNIX 380 for i := 0; i < n; i++ { 381 sa.raw.Path[i] = int8(name[i]) 382 } 383 // length is family (uint16), name, NUL. 384 sl := _Socklen(2) 385 if n > 0 { 386 sl += _Socklen(n) + 1 387 } 388 if sa.raw.Path[0] == '@' { 389 sa.raw.Path[0] = 0 390 // Don't count trailing NUL for abstract address. 391 sl-- 392 } 393 394 return unsafe.Pointer(&sa.raw), sl, nil 395 } 396 397 // SockaddrLinklayer implements the Sockaddr interface for AF_PACKET type sockets. 398 type SockaddrLinklayer struct { 399 Protocol uint16 400 Ifindex int 401 Hatype uint16 402 Pkttype uint8 403 Halen uint8 404 Addr [8]byte 405 raw RawSockaddrLinklayer 406 } 407 408 func (sa *SockaddrLinklayer) sockaddr() (unsafe.Pointer, _Socklen, error) { 409 if sa.Ifindex < 0 || sa.Ifindex > 0x7fffffff { 410 return nil, 0, EINVAL 411 } 412 sa.raw.Family = AF_PACKET 413 sa.raw.Protocol = sa.Protocol 414 sa.raw.Ifindex = int32(sa.Ifindex) 415 sa.raw.Hatype = sa.Hatype 416 sa.raw.Pkttype = sa.Pkttype 417 sa.raw.Halen = sa.Halen 418 for i := 0; i < len(sa.Addr); i++ { 419 sa.raw.Addr[i] = sa.Addr[i] 420 } 421 return unsafe.Pointer(&sa.raw), SizeofSockaddrLinklayer, nil 422 } 423 424 // SockaddrNetlink implements the Sockaddr interface for AF_NETLINK type sockets. 425 type SockaddrNetlink struct { 426 Family uint16 427 Pad uint16 428 Pid uint32 429 Groups uint32 430 raw RawSockaddrNetlink 431 } 432 433 func (sa *SockaddrNetlink) sockaddr() (unsafe.Pointer, _Socklen, error) { 434 sa.raw.Family = AF_NETLINK 435 sa.raw.Pad = sa.Pad 436 sa.raw.Pid = sa.Pid 437 sa.raw.Groups = sa.Groups 438 return unsafe.Pointer(&sa.raw), SizeofSockaddrNetlink, nil 439 } 440 441 // SockaddrHCI implements the Sockaddr interface for AF_BLUETOOTH type sockets 442 // using the HCI protocol. 443 type SockaddrHCI struct { 444 Dev uint16 445 Channel uint16 446 raw RawSockaddrHCI 447 } 448 449 func (sa *SockaddrHCI) sockaddr() (unsafe.Pointer, _Socklen, error) { 450 sa.raw.Family = AF_BLUETOOTH 451 sa.raw.Dev = sa.Dev 452 sa.raw.Channel = sa.Channel 453 return unsafe.Pointer(&sa.raw), SizeofSockaddrHCI, nil 454 } 455 456 // SockaddrL2 implements the Sockaddr interface for AF_BLUETOOTH type sockets 457 // using the L2CAP protocol. 458 type SockaddrL2 struct { 459 PSM uint16 460 CID uint16 461 Addr [6]uint8 462 AddrType uint8 463 raw RawSockaddrL2 464 } 465 466 func (sa *SockaddrL2) sockaddr() (unsafe.Pointer, _Socklen, error) { 467 sa.raw.Family = AF_BLUETOOTH 468 psm := (*[2]byte)(unsafe.Pointer(&sa.raw.Psm)) 469 psm[0] = byte(sa.PSM) 470 psm[1] = byte(sa.PSM >> 8) 471 for i := 0; i < len(sa.Addr); i++ { 472 sa.raw.Bdaddr[i] = sa.Addr[len(sa.Addr)-1-i] 473 } 474 cid := (*[2]byte)(unsafe.Pointer(&sa.raw.Cid)) 475 cid[0] = byte(sa.CID) 476 cid[1] = byte(sa.CID >> 8) 477 sa.raw.Bdaddr_type = sa.AddrType 478 return unsafe.Pointer(&sa.raw), SizeofSockaddrL2, nil 479 } 480 481 // SockaddrRFCOMM implements the Sockaddr interface for AF_BLUETOOTH type sockets 482 // using the RFCOMM protocol. 483 // 484 // Server example: 485 // 486 // fd, _ := Socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM) 487 // _ = unix.Bind(fd, &unix.SockaddrRFCOMM{ 488 // Channel: 1, 489 // Addr: [6]uint8{0, 0, 0, 0, 0, 0}, // BDADDR_ANY or 00:00:00:00:00:00 490 // }) 491 // _ = Listen(fd, 1) 492 // nfd, sa, _ := Accept(fd) 493 // fmt.Printf("conn addr=%v fd=%d", sa.(*unix.SockaddrRFCOMM).Addr, nfd) 494 // Read(nfd, buf) 495 // 496 // Client example: 497 // 498 // fd, _ := Socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM) 499 // _ = Connect(fd, &SockaddrRFCOMM{ 500 // Channel: 1, 501 // Addr: [6]byte{0x11, 0x22, 0x33, 0xaa, 0xbb, 0xcc}, // CC:BB:AA:33:22:11 502 // }) 503 // Write(fd, []byte(`hello`)) 504 type SockaddrRFCOMM struct { 505 // Addr represents a bluetooth address, byte ordering is little-endian. 506 Addr [6]uint8 507 508 // Channel is a designated bluetooth channel, only 1-30 are available for use. 509 // Since Linux 2.6.7 and further zero value is the first available channel. 510 Channel uint8 511 512 raw RawSockaddrRFCOMM 513 } 514 515 func (sa *SockaddrRFCOMM) sockaddr() (unsafe.Pointer, _Socklen, error) { 516 sa.raw.Family = AF_BLUETOOTH 517 sa.raw.Channel = sa.Channel 518 sa.raw.Bdaddr = sa.Addr 519 return unsafe.Pointer(&sa.raw), SizeofSockaddrRFCOMM, nil 520 } 521 522 // SockaddrCAN implements the Sockaddr interface for AF_CAN type sockets. 523 // The RxID and TxID fields are used for transport protocol addressing in 524 // (CAN_TP16, CAN_TP20, CAN_MCNET, and CAN_ISOTP), they can be left with 525 // zero values for CAN_RAW and CAN_BCM sockets as they have no meaning. 526 // 527 // The SockaddrCAN struct must be bound to the socket file descriptor 528 // using Bind before the CAN socket can be used. 529 // 530 // // Read one raw CAN frame 531 // fd, _ := Socket(AF_CAN, SOCK_RAW, CAN_RAW) 532 // addr := &SockaddrCAN{Ifindex: index} 533 // Bind(fd, addr) 534 // frame := make([]byte, 16) 535 // Read(fd, frame) 536 // 537 // The full SocketCAN documentation can be found in the linux kernel 538 // archives at: https://www.kernel.org/doc/Documentation/networking/can.txt 539 type SockaddrCAN struct { 540 Ifindex int 541 RxID uint32 542 TxID uint32 543 raw RawSockaddrCAN 544 } 545 546 func (sa *SockaddrCAN) sockaddr() (unsafe.Pointer, _Socklen, error) { 547 if sa.Ifindex < 0 || sa.Ifindex > 0x7fffffff { 548 return nil, 0, EINVAL 549 } 550 sa.raw.Family = AF_CAN 551 sa.raw.Ifindex = int32(sa.Ifindex) 552 rx := (*[4]byte)(unsafe.Pointer(&sa.RxID)) 553 for i := 0; i < 4; i++ { 554 sa.raw.Addr[i] = rx[i] 555 } 556 tx := (*[4]byte)(unsafe.Pointer(&sa.TxID)) 557 for i := 0; i < 4; i++ { 558 sa.raw.Addr[i+4] = tx[i] 559 } 560 return unsafe.Pointer(&sa.raw), SizeofSockaddrCAN, nil 561 } 562 563 // SockaddrCANJ1939 implements the Sockaddr interface for AF_CAN using J1939 564 // protocol (https://en.wikipedia.org/wiki/SAE_J1939). For more information 565 // on the purposes of the fields, check the official linux kernel documentation 566 // available here: https://www.kernel.org/doc/Documentation/networking/j1939.rst 567 type SockaddrCANJ1939 struct { 568 Ifindex int 569 Name uint64 570 PGN uint32 571 Addr uint8 572 raw RawSockaddrCAN 573 } 574 575 func (sa *SockaddrCANJ1939) sockaddr() (unsafe.Pointer, _Socklen, error) { 576 if sa.Ifindex < 0 || sa.Ifindex > 0x7fffffff { 577 return nil, 0, EINVAL 578 } 579 sa.raw.Family = AF_CAN 580 sa.raw.Ifindex = int32(sa.Ifindex) 581 n := (*[8]byte)(unsafe.Pointer(&sa.Name)) 582 for i := 0; i < 8; i++ { 583 sa.raw.Addr[i] = n[i] 584 } 585 p := (*[4]byte)(unsafe.Pointer(&sa.PGN)) 586 for i := 0; i < 4; i++ { 587 sa.raw.Addr[i+8] = p[i] 588 } 589 sa.raw.Addr[12] = sa.Addr 590 return unsafe.Pointer(&sa.raw), SizeofSockaddrCAN, nil 591 } 592 593 // SockaddrALG implements the Sockaddr interface for AF_ALG type sockets. 594 // SockaddrALG enables userspace access to the Linux kernel's cryptography 595 // subsystem. The Type and Name fields specify which type of hash or cipher 596 // should be used with a given socket. 597 // 598 // To create a file descriptor that provides access to a hash or cipher, both 599 // Bind and Accept must be used. Once the setup process is complete, input 600 // data can be written to the socket, processed by the kernel, and then read 601 // back as hash output or ciphertext. 602 // 603 // Here is an example of using an AF_ALG socket with SHA1 hashing. 604 // The initial socket setup process is as follows: 605 // 606 // // Open a socket to perform SHA1 hashing. 607 // fd, _ := unix.Socket(unix.AF_ALG, unix.SOCK_SEQPACKET, 0) 608 // addr := &unix.SockaddrALG{Type: "hash", Name: "sha1"} 609 // unix.Bind(fd, addr) 610 // // Note: unix.Accept does not work at this time; must invoke accept() 611 // // manually using unix.Syscall. 612 // hashfd, _, _ := unix.Syscall(unix.SYS_ACCEPT, uintptr(fd), 0, 0) 613 // 614 // Once a file descriptor has been returned from Accept, it may be used to 615 // perform SHA1 hashing. The descriptor is not safe for concurrent use, but 616 // may be re-used repeatedly with subsequent Write and Read operations. 617 // 618 // When hashing a small byte slice or string, a single Write and Read may 619 // be used: 620 // 621 // // Assume hashfd is already configured using the setup process. 622 // hash := os.NewFile(hashfd, "sha1") 623 // // Hash an input string and read the results. Each Write discards 624 // // previous hash state. Read always reads the current state. 625 // b := make([]byte, 20) 626 // for i := 0; i < 2; i++ { 627 // io.WriteString(hash, "Hello, world.") 628 // hash.Read(b) 629 // fmt.Println(hex.EncodeToString(b)) 630 // } 631 // // Output: 632 // // 2ae01472317d1935a84797ec1983ae243fc6aa28 633 // // 2ae01472317d1935a84797ec1983ae243fc6aa28 634 // 635 // For hashing larger byte slices, or byte streams such as those read from 636 // a file or socket, use Sendto with MSG_MORE to instruct the kernel to update 637 // the hash digest instead of creating a new one for a given chunk and finalizing it. 638 // 639 // // Assume hashfd and addr are already configured using the setup process. 640 // hash := os.NewFile(hashfd, "sha1") 641 // // Hash the contents of a file. 642 // f, _ := os.Open("/tmp/linux-4.10-rc7.tar.xz") 643 // b := make([]byte, 4096) 644 // for { 645 // n, err := f.Read(b) 646 // if err == io.EOF { 647 // break 648 // } 649 // unix.Sendto(hashfd, b[:n], unix.MSG_MORE, addr) 650 // } 651 // hash.Read(b) 652 // fmt.Println(hex.EncodeToString(b)) 653 // // Output: 85cdcad0c06eef66f805ecce353bec9accbeecc5 654 // 655 // For more information, see: http://www.chronox.de/crypto-API/crypto/userspace-if.html. 656 type SockaddrALG struct { 657 Type string 658 Name string 659 Feature uint32 660 Mask uint32 661 raw RawSockaddrALG 662 } 663 664 func (sa *SockaddrALG) sockaddr() (unsafe.Pointer, _Socklen, error) { 665 // Leave room for NUL byte terminator. 666 if len(sa.Type) > 13 { 667 return nil, 0, EINVAL 668 } 669 if len(sa.Name) > 63 { 670 return nil, 0, EINVAL 671 } 672 673 sa.raw.Family = AF_ALG 674 sa.raw.Feat = sa.Feature 675 sa.raw.Mask = sa.Mask 676 677 typ, err := ByteSliceFromString(sa.Type) 678 if err != nil { 679 return nil, 0, err 680 } 681 name, err := ByteSliceFromString(sa.Name) 682 if err != nil { 683 return nil, 0, err 684 } 685 686 copy(sa.raw.Type[:], typ) 687 copy(sa.raw.Name[:], name) 688 689 return unsafe.Pointer(&sa.raw), SizeofSockaddrALG, nil 690 } 691 692 // SockaddrVM implements the Sockaddr interface for AF_VSOCK type sockets. 693 // SockaddrVM provides access to Linux VM sockets: a mechanism that enables 694 // bidirectional communication between a hypervisor and its guest virtual 695 // machines. 696 type SockaddrVM struct { 697 // CID and Port specify a context ID and port address for a VM socket. 698 // Guests have a unique CID, and hosts may have a well-known CID of: 699 // - VMADDR_CID_HYPERVISOR: refers to the hypervisor process. 700 // - VMADDR_CID_LOCAL: refers to local communication (loopback). 701 // - VMADDR_CID_HOST: refers to other processes on the host. 702 CID uint32 703 Port uint32 704 Flags uint8 705 raw RawSockaddrVM 706 } 707 708 func (sa *SockaddrVM) sockaddr() (unsafe.Pointer, _Socklen, error) { 709 sa.raw.Family = AF_VSOCK 710 sa.raw.Port = sa.Port 711 sa.raw.Cid = sa.CID 712 sa.raw.Flags = sa.Flags 713 714 return unsafe.Pointer(&sa.raw), SizeofSockaddrVM, nil 715 } 716 717 type SockaddrXDP struct { 718 Flags uint16 719 Ifindex uint32 720 QueueID uint32 721 SharedUmemFD uint32 722 raw RawSockaddrXDP 723 } 724 725 func (sa *SockaddrXDP) sockaddr() (unsafe.Pointer, _Socklen, error) { 726 sa.raw.Family = AF_XDP 727 sa.raw.Flags = sa.Flags 728 sa.raw.Ifindex = sa.Ifindex 729 sa.raw.Queue_id = sa.QueueID 730 sa.raw.Shared_umem_fd = sa.SharedUmemFD 731 732 return unsafe.Pointer(&sa.raw), SizeofSockaddrXDP, nil 733 } 734 735 // This constant mirrors the #define of PX_PROTO_OE in 736 // linux/if_pppox.h. We're defining this by hand here instead of 737 // autogenerating through mkerrors.sh because including 738 // linux/if_pppox.h causes some declaration conflicts with other 739 // includes (linux/if_pppox.h includes linux/in.h, which conflicts 740 // with netinet/in.h). Given that we only need a single zero constant 741 // out of that file, it's cleaner to just define it by hand here. 742 const px_proto_oe = 0 743 744 type SockaddrPPPoE struct { 745 SID uint16 746 Remote []byte 747 Dev string 748 raw RawSockaddrPPPoX 749 } 750 751 func (sa *SockaddrPPPoE) sockaddr() (unsafe.Pointer, _Socklen, error) { 752 if len(sa.Remote) != 6 { 753 return nil, 0, EINVAL 754 } 755 if len(sa.Dev) > IFNAMSIZ-1 { 756 return nil, 0, EINVAL 757 } 758 759 *(*uint16)(unsafe.Pointer(&sa.raw[0])) = AF_PPPOX 760 // This next field is in host-endian byte order. We can't use the 761 // same unsafe pointer cast as above, because this value is not 762 // 32-bit aligned and some architectures don't allow unaligned 763 // access. 764 // 765 // However, the value of px_proto_oe is 0, so we can use 766 // encoding/binary helpers to write the bytes without worrying 767 // about the ordering. 768 binary.BigEndian.PutUint32(sa.raw[2:6], px_proto_oe) 769 // This field is deliberately big-endian, unlike the previous 770 // one. The kernel expects SID to be in network byte order. 771 binary.BigEndian.PutUint16(sa.raw[6:8], sa.SID) 772 copy(sa.raw[8:14], sa.Remote) 773 for i := 14; i < 14+IFNAMSIZ; i++ { 774 sa.raw[i] = 0 775 } 776 copy(sa.raw[14:], sa.Dev) 777 return unsafe.Pointer(&sa.raw), SizeofSockaddrPPPoX, nil 778 } 779 780 // SockaddrTIPC implements the Sockaddr interface for AF_TIPC type sockets. 781 // For more information on TIPC, see: http://tipc.sourceforge.net/. 782 type SockaddrTIPC struct { 783 // Scope is the publication scopes when binding service/service range. 784 // Should be set to TIPC_CLUSTER_SCOPE or TIPC_NODE_SCOPE. 785 Scope int 786 787 // Addr is the type of address used to manipulate a socket. Addr must be 788 // one of: 789 // - *TIPCSocketAddr: "id" variant in the C addr union 790 // - *TIPCServiceRange: "nameseq" variant in the C addr union 791 // - *TIPCServiceName: "name" variant in the C addr union 792 // 793 // If nil, EINVAL will be returned when the structure is used. 794 Addr TIPCAddr 795 796 raw RawSockaddrTIPC 797 } 798 799 // TIPCAddr is implemented by types that can be used as an address for 800 // SockaddrTIPC. It is only implemented by *TIPCSocketAddr, *TIPCServiceRange, 801 // and *TIPCServiceName. 802 type TIPCAddr interface { 803 tipcAddrtype() uint8 804 tipcAddr() [12]byte 805 } 806 807 func (sa *TIPCSocketAddr) tipcAddr() [12]byte { 808 var out [12]byte 809 copy(out[:], (*(*[unsafe.Sizeof(TIPCSocketAddr{})]byte)(unsafe.Pointer(sa)))[:]) 810 return out 811 } 812 813 func (sa *TIPCSocketAddr) tipcAddrtype() uint8 { return TIPC_SOCKET_ADDR } 814 815 func (sa *TIPCServiceRange) tipcAddr() [12]byte { 816 var out [12]byte 817 copy(out[:], (*(*[unsafe.Sizeof(TIPCServiceRange{})]byte)(unsafe.Pointer(sa)))[:]) 818 return out 819 } 820 821 func (sa *TIPCServiceRange) tipcAddrtype() uint8 { return TIPC_SERVICE_RANGE } 822 823 func (sa *TIPCServiceName) tipcAddr() [12]byte { 824 var out [12]byte 825 copy(out[:], (*(*[unsafe.Sizeof(TIPCServiceName{})]byte)(unsafe.Pointer(sa)))[:]) 826 return out 827 } 828 829 func (sa *TIPCServiceName) tipcAddrtype() uint8 { return TIPC_SERVICE_ADDR } 830 831 func (sa *SockaddrTIPC) sockaddr() (unsafe.Pointer, _Socklen, error) { 832 if sa.Addr == nil { 833 return nil, 0, EINVAL 834 } 835 836 sa.raw.Family = AF_TIPC 837 sa.raw.Scope = int8(sa.Scope) 838 sa.raw.Addrtype = sa.Addr.tipcAddrtype() 839 sa.raw.Addr = sa.Addr.tipcAddr() 840 841 return unsafe.Pointer(&sa.raw), SizeofSockaddrTIPC, nil 842 } 843 844 // SockaddrL2TPIP implements the Sockaddr interface for IPPROTO_L2TP/AF_INET sockets. 845 type SockaddrL2TPIP struct { 846 Addr [4]byte 847 ConnId uint32 848 raw RawSockaddrL2TPIP 849 } 850 851 func (sa *SockaddrL2TPIP) sockaddr() (unsafe.Pointer, _Socklen, error) { 852 sa.raw.Family = AF_INET 853 sa.raw.Conn_id = sa.ConnId 854 for i := 0; i < len(sa.Addr); i++ { 855 sa.raw.Addr[i] = sa.Addr[i] 856 } 857 return unsafe.Pointer(&sa.raw), SizeofSockaddrL2TPIP, nil 858 } 859 860 // SockaddrL2TPIP6 implements the Sockaddr interface for IPPROTO_L2TP/AF_INET6 sockets. 861 type SockaddrL2TPIP6 struct { 862 Addr [16]byte 863 ZoneId uint32 864 ConnId uint32 865 raw RawSockaddrL2TPIP6 866 } 867 868 func (sa *SockaddrL2TPIP6) sockaddr() (unsafe.Pointer, _Socklen, error) { 869 sa.raw.Family = AF_INET6 870 sa.raw.Conn_id = sa.ConnId 871 sa.raw.Scope_id = sa.ZoneId 872 for i := 0; i < len(sa.Addr); i++ { 873 sa.raw.Addr[i] = sa.Addr[i] 874 } 875 return unsafe.Pointer(&sa.raw), SizeofSockaddrL2TPIP6, nil 876 } 877 878 // SockaddrIUCV implements the Sockaddr interface for AF_IUCV sockets. 879 type SockaddrIUCV struct { 880 UserID string 881 Name string 882 raw RawSockaddrIUCV 883 } 884 885 func (sa *SockaddrIUCV) sockaddr() (unsafe.Pointer, _Socklen, error) { 886 sa.raw.Family = AF_IUCV 887 // These are EBCDIC encoded by the kernel, but we still need to pad them 888 // with blanks. Initializing with blanks allows the caller to feed in either 889 // a padded or an unpadded string. 890 for i := 0; i < 8; i++ { 891 sa.raw.Nodeid[i] = ' ' 892 sa.raw.User_id[i] = ' ' 893 sa.raw.Name[i] = ' ' 894 } 895 if len(sa.UserID) > 8 || len(sa.Name) > 8 { 896 return nil, 0, EINVAL 897 } 898 for i, b := range []byte(sa.UserID[:]) { 899 sa.raw.User_id[i] = int8(b) 900 } 901 for i, b := range []byte(sa.Name[:]) { 902 sa.raw.Name[i] = int8(b) 903 } 904 return unsafe.Pointer(&sa.raw), SizeofSockaddrIUCV, nil 905 } 906 907 type SockaddrNFC struct { 908 DeviceIdx uint32 909 TargetIdx uint32 910 NFCProtocol uint32 911 raw RawSockaddrNFC 912 } 913 914 func (sa *SockaddrNFC) sockaddr() (unsafe.Pointer, _Socklen, error) { 915 sa.raw.Sa_family = AF_NFC 916 sa.raw.Dev_idx = sa.DeviceIdx 917 sa.raw.Target_idx = sa.TargetIdx 918 sa.raw.Nfc_protocol = sa.NFCProtocol 919 return unsafe.Pointer(&sa.raw), SizeofSockaddrNFC, nil 920 } 921 922 type SockaddrNFCLLCP struct { 923 DeviceIdx uint32 924 TargetIdx uint32 925 NFCProtocol uint32 926 DestinationSAP uint8 927 SourceSAP uint8 928 ServiceName string 929 raw RawSockaddrNFCLLCP 930 } 931 932 func (sa *SockaddrNFCLLCP) sockaddr() (unsafe.Pointer, _Socklen, error) { 933 sa.raw.Sa_family = AF_NFC 934 sa.raw.Dev_idx = sa.DeviceIdx 935 sa.raw.Target_idx = sa.TargetIdx 936 sa.raw.Nfc_protocol = sa.NFCProtocol 937 sa.raw.Dsap = sa.DestinationSAP 938 sa.raw.Ssap = sa.SourceSAP 939 if len(sa.ServiceName) > len(sa.raw.Service_name) { 940 return nil, 0, EINVAL 941 } 942 copy(sa.raw.Service_name[:], sa.ServiceName) 943 sa.raw.SetServiceNameLen(len(sa.ServiceName)) 944 return unsafe.Pointer(&sa.raw), SizeofSockaddrNFCLLCP, nil 945 } 946 947 var socketProtocol = func(fd int) (int, error) { 948 return GetsockoptInt(fd, SOL_SOCKET, SO_PROTOCOL) 949 } 950 951 func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) { 952 switch rsa.Addr.Family { 953 case AF_NETLINK: 954 pp := (*RawSockaddrNetlink)(unsafe.Pointer(rsa)) 955 sa := new(SockaddrNetlink) 956 sa.Family = pp.Family 957 sa.Pad = pp.Pad 958 sa.Pid = pp.Pid 959 sa.Groups = pp.Groups 960 return sa, nil 961 962 case AF_PACKET: 963 pp := (*RawSockaddrLinklayer)(unsafe.Pointer(rsa)) 964 sa := new(SockaddrLinklayer) 965 sa.Protocol = pp.Protocol 966 sa.Ifindex = int(pp.Ifindex) 967 sa.Hatype = pp.Hatype 968 sa.Pkttype = pp.Pkttype 969 sa.Halen = pp.Halen 970 for i := 0; i < len(sa.Addr); i++ { 971 sa.Addr[i] = pp.Addr[i] 972 } 973 return sa, nil 974 975 case AF_UNIX: 976 pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa)) 977 sa := new(SockaddrUnix) 978 if pp.Path[0] == 0 { 979 // "Abstract" Unix domain socket. 980 // Rewrite leading NUL as @ for textual display. 981 // (This is the standard convention.) 982 // Not friendly to overwrite in place, 983 // but the callers below don't care. 984 pp.Path[0] = '@' 985 } 986 987 // Assume path ends at NUL. 988 // This is not technically the Linux semantics for 989 // abstract Unix domain sockets--they are supposed 990 // to be uninterpreted fixed-size binary blobs--but 991 // everyone uses this convention. 992 n := 0 993 for n < len(pp.Path) && pp.Path[n] != 0 { 994 n++ 995 } 996 bytes := (*[len(pp.Path)]byte)(unsafe.Pointer(&pp.Path[0]))[0:n] 997 sa.Name = string(bytes) 998 return sa, nil 999 1000 case AF_INET: 1001 proto, err := socketProtocol(fd) 1002 if err != nil { 1003 return nil, err 1004 } 1005 1006 switch proto { 1007 case IPPROTO_L2TP: 1008 pp := (*RawSockaddrL2TPIP)(unsafe.Pointer(rsa)) 1009 sa := new(SockaddrL2TPIP) 1010 sa.ConnId = pp.Conn_id 1011 for i := 0; i < len(sa.Addr); i++ { 1012 sa.Addr[i] = pp.Addr[i] 1013 } 1014 return sa, nil 1015 default: 1016 pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa)) 1017 sa := new(SockaddrInet4) 1018 p := (*[2]byte)(unsafe.Pointer(&pp.Port)) 1019 sa.Port = int(p[0])<<8 + int(p[1]) 1020 for i := 0; i < len(sa.Addr); i++ { 1021 sa.Addr[i] = pp.Addr[i] 1022 } 1023 return sa, nil 1024 } 1025 1026 case AF_INET6: 1027 proto, err := socketProtocol(fd) 1028 if err != nil { 1029 return nil, err 1030 } 1031 1032 switch proto { 1033 case IPPROTO_L2TP: 1034 pp := (*RawSockaddrL2TPIP6)(unsafe.Pointer(rsa)) 1035 sa := new(SockaddrL2TPIP6) 1036 sa.ConnId = pp.Conn_id 1037 sa.ZoneId = pp.Scope_id 1038 for i := 0; i < len(sa.Addr); i++ { 1039 sa.Addr[i] = pp.Addr[i] 1040 } 1041 return sa, nil 1042 default: 1043 pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa)) 1044 sa := new(SockaddrInet6) 1045 p := (*[2]byte)(unsafe.Pointer(&pp.Port)) 1046 sa.Port = int(p[0])<<8 + int(p[1]) 1047 sa.ZoneId = pp.Scope_id 1048 for i := 0; i < len(sa.Addr); i++ { 1049 sa.Addr[i] = pp.Addr[i] 1050 } 1051 return sa, nil 1052 } 1053 1054 case AF_VSOCK: 1055 pp := (*RawSockaddrVM)(unsafe.Pointer(rsa)) 1056 sa := &SockaddrVM{ 1057 CID: pp.Cid, 1058 Port: pp.Port, 1059 Flags: pp.Flags, 1060 } 1061 return sa, nil 1062 case AF_BLUETOOTH: 1063 proto, err := socketProtocol(fd) 1064 if err != nil { 1065 return nil, err 1066 } 1067 // only BTPROTO_L2CAP and BTPROTO_RFCOMM can accept connections 1068 switch proto { 1069 case BTPROTO_L2CAP: 1070 pp := (*RawSockaddrL2)(unsafe.Pointer(rsa)) 1071 sa := &SockaddrL2{ 1072 PSM: pp.Psm, 1073 CID: pp.Cid, 1074 Addr: pp.Bdaddr, 1075 AddrType: pp.Bdaddr_type, 1076 } 1077 return sa, nil 1078 case BTPROTO_RFCOMM: 1079 pp := (*RawSockaddrRFCOMM)(unsafe.Pointer(rsa)) 1080 sa := &SockaddrRFCOMM{ 1081 Channel: pp.Channel, 1082 Addr: pp.Bdaddr, 1083 } 1084 return sa, nil 1085 } 1086 case AF_XDP: 1087 pp := (*RawSockaddrXDP)(unsafe.Pointer(rsa)) 1088 sa := &SockaddrXDP{ 1089 Flags: pp.Flags, 1090 Ifindex: pp.Ifindex, 1091 QueueID: pp.Queue_id, 1092 SharedUmemFD: pp.Shared_umem_fd, 1093 } 1094 return sa, nil 1095 case AF_PPPOX: 1096 pp := (*RawSockaddrPPPoX)(unsafe.Pointer(rsa)) 1097 if binary.BigEndian.Uint32(pp[2:6]) != px_proto_oe { 1098 return nil, EINVAL 1099 } 1100 sa := &SockaddrPPPoE{ 1101 SID: binary.BigEndian.Uint16(pp[6:8]), 1102 Remote: pp[8:14], 1103 } 1104 for i := 14; i < 14+IFNAMSIZ; i++ { 1105 if pp[i] == 0 { 1106 sa.Dev = string(pp[14:i]) 1107 break 1108 } 1109 } 1110 return sa, nil 1111 case AF_TIPC: 1112 pp := (*RawSockaddrTIPC)(unsafe.Pointer(rsa)) 1113 1114 sa := &SockaddrTIPC{ 1115 Scope: int(pp.Scope), 1116 } 1117 1118 // Determine which union variant is present in pp.Addr by checking 1119 // pp.Addrtype. 1120 switch pp.Addrtype { 1121 case TIPC_SERVICE_RANGE: 1122 sa.Addr = (*TIPCServiceRange)(unsafe.Pointer(&pp.Addr)) 1123 case TIPC_SERVICE_ADDR: 1124 sa.Addr = (*TIPCServiceName)(unsafe.Pointer(&pp.Addr)) 1125 case TIPC_SOCKET_ADDR: 1126 sa.Addr = (*TIPCSocketAddr)(unsafe.Pointer(&pp.Addr)) 1127 default: 1128 return nil, EINVAL 1129 } 1130 1131 return sa, nil 1132 case AF_IUCV: 1133 pp := (*RawSockaddrIUCV)(unsafe.Pointer(rsa)) 1134 1135 var user [8]byte 1136 var name [8]byte 1137 1138 for i := 0; i < 8; i++ { 1139 user[i] = byte(pp.User_id[i]) 1140 name[i] = byte(pp.Name[i]) 1141 } 1142 1143 sa := &SockaddrIUCV{ 1144 UserID: string(user[:]), 1145 Name: string(name[:]), 1146 } 1147 return sa, nil 1148 1149 case AF_CAN: 1150 proto, err := socketProtocol(fd) 1151 if err != nil { 1152 return nil, err 1153 } 1154 1155 pp := (*RawSockaddrCAN)(unsafe.Pointer(rsa)) 1156 1157 switch proto { 1158 case CAN_J1939: 1159 sa := &SockaddrCANJ1939{ 1160 Ifindex: int(pp.Ifindex), 1161 } 1162 name := (*[8]byte)(unsafe.Pointer(&sa.Name)) 1163 for i := 0; i < 8; i++ { 1164 name[i] = pp.Addr[i] 1165 } 1166 pgn := (*[4]byte)(unsafe.Pointer(&sa.PGN)) 1167 for i := 0; i < 4; i++ { 1168 pgn[i] = pp.Addr[i+8] 1169 } 1170 addr := (*[1]byte)(unsafe.Pointer(&sa.Addr)) 1171 addr[0] = pp.Addr[12] 1172 return sa, nil 1173 default: 1174 sa := &SockaddrCAN{ 1175 Ifindex: int(pp.Ifindex), 1176 } 1177 rx := (*[4]byte)(unsafe.Pointer(&sa.RxID)) 1178 for i := 0; i < 4; i++ { 1179 rx[i] = pp.Addr[i] 1180 } 1181 tx := (*[4]byte)(unsafe.Pointer(&sa.TxID)) 1182 for i := 0; i < 4; i++ { 1183 tx[i] = pp.Addr[i+4] 1184 } 1185 return sa, nil 1186 } 1187 case AF_NFC: 1188 proto, err := socketProtocol(fd) 1189 if err != nil { 1190 return nil, err 1191 } 1192 switch proto { 1193 case NFC_SOCKPROTO_RAW: 1194 pp := (*RawSockaddrNFC)(unsafe.Pointer(rsa)) 1195 sa := &SockaddrNFC{ 1196 DeviceIdx: pp.Dev_idx, 1197 TargetIdx: pp.Target_idx, 1198 NFCProtocol: pp.Nfc_protocol, 1199 } 1200 return sa, nil 1201 case NFC_SOCKPROTO_LLCP: 1202 pp := (*RawSockaddrNFCLLCP)(unsafe.Pointer(rsa)) 1203 if uint64(pp.Service_name_len) > uint64(len(pp.Service_name)) { 1204 return nil, EINVAL 1205 } 1206 sa := &SockaddrNFCLLCP{ 1207 DeviceIdx: pp.Dev_idx, 1208 TargetIdx: pp.Target_idx, 1209 NFCProtocol: pp.Nfc_protocol, 1210 DestinationSAP: pp.Dsap, 1211 SourceSAP: pp.Ssap, 1212 ServiceName: string(pp.Service_name[:pp.Service_name_len]), 1213 } 1214 return sa, nil 1215 default: 1216 return nil, EINVAL 1217 } 1218 } 1219 return nil, EAFNOSUPPORT 1220 } 1221 1222 func Accept(fd int) (nfd int, sa Sockaddr, err error) { 1223 var rsa RawSockaddrAny 1224 var len _Socklen = SizeofSockaddrAny 1225 // Try accept4 first for Android, then try accept for kernel older than 2.6.28 1226 nfd, err = accept4(fd, &rsa, &len, 0) 1227 if err == ENOSYS { 1228 nfd, err = accept(fd, &rsa, &len) 1229 } 1230 if err != nil { 1231 return 1232 } 1233 sa, err = anyToSockaddr(fd, &rsa) 1234 if err != nil { 1235 Close(nfd) 1236 nfd = 0 1237 } 1238 return 1239 } 1240 1241 func Accept4(fd int, flags int) (nfd int, sa Sockaddr, err error) { 1242 var rsa RawSockaddrAny 1243 var len _Socklen = SizeofSockaddrAny 1244 nfd, err = accept4(fd, &rsa, &len, flags) 1245 if err != nil { 1246 return 1247 } 1248 if len > SizeofSockaddrAny { 1249 panic("RawSockaddrAny too small") 1250 } 1251 sa, err = anyToSockaddr(fd, &rsa) 1252 if err != nil { 1253 Close(nfd) 1254 nfd = 0 1255 } 1256 return 1257 } 1258 1259 func Getsockname(fd int) (sa Sockaddr, err error) { 1260 var rsa RawSockaddrAny 1261 var len _Socklen = SizeofSockaddrAny 1262 if err = getsockname(fd, &rsa, &len); err != nil { 1263 return 1264 } 1265 return anyToSockaddr(fd, &rsa) 1266 } 1267 1268 func GetsockoptIPMreqn(fd, level, opt int) (*IPMreqn, error) { 1269 var value IPMreqn 1270 vallen := _Socklen(SizeofIPMreqn) 1271 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) 1272 return &value, err 1273 } 1274 1275 func GetsockoptUcred(fd, level, opt int) (*Ucred, error) { 1276 var value Ucred 1277 vallen := _Socklen(SizeofUcred) 1278 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) 1279 return &value, err 1280 } 1281 1282 func GetsockoptTCPInfo(fd, level, opt int) (*TCPInfo, error) { 1283 var value TCPInfo 1284 vallen := _Socklen(SizeofTCPInfo) 1285 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) 1286 return &value, err 1287 } 1288 1289 // GetsockoptString returns the string value of the socket option opt for the 1290 // socket associated with fd at the given socket level. 1291 func GetsockoptString(fd, level, opt int) (string, error) { 1292 buf := make([]byte, 256) 1293 vallen := _Socklen(len(buf)) 1294 err := getsockopt(fd, level, opt, unsafe.Pointer(&buf[0]), &vallen) 1295 if err != nil { 1296 if err == ERANGE { 1297 buf = make([]byte, vallen) 1298 err = getsockopt(fd, level, opt, unsafe.Pointer(&buf[0]), &vallen) 1299 } 1300 if err != nil { 1301 return "", err 1302 } 1303 } 1304 return string(buf[:vallen-1]), nil 1305 } 1306 1307 func GetsockoptTpacketStats(fd, level, opt int) (*TpacketStats, error) { 1308 var value TpacketStats 1309 vallen := _Socklen(SizeofTpacketStats) 1310 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) 1311 return &value, err 1312 } 1313 1314 func GetsockoptTpacketStatsV3(fd, level, opt int) (*TpacketStatsV3, error) { 1315 var value TpacketStatsV3 1316 vallen := _Socklen(SizeofTpacketStatsV3) 1317 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) 1318 return &value, err 1319 } 1320 1321 func SetsockoptIPMreqn(fd, level, opt int, mreq *IPMreqn) (err error) { 1322 return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq)) 1323 } 1324 1325 func SetsockoptPacketMreq(fd, level, opt int, mreq *PacketMreq) error { 1326 return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq)) 1327 } 1328 1329 // SetsockoptSockFprog attaches a classic BPF or an extended BPF program to a 1330 // socket to filter incoming packets. See 'man 7 socket' for usage information. 1331 func SetsockoptSockFprog(fd, level, opt int, fprog *SockFprog) error { 1332 return setsockopt(fd, level, opt, unsafe.Pointer(fprog), unsafe.Sizeof(*fprog)) 1333 } 1334 1335 func SetsockoptCanRawFilter(fd, level, opt int, filter []CanFilter) error { 1336 var p unsafe.Pointer 1337 if len(filter) > 0 { 1338 p = unsafe.Pointer(&filter[0]) 1339 } 1340 return setsockopt(fd, level, opt, p, uintptr(len(filter)*SizeofCanFilter)) 1341 } 1342 1343 func SetsockoptTpacketReq(fd, level, opt int, tp *TpacketReq) error { 1344 return setsockopt(fd, level, opt, unsafe.Pointer(tp), unsafe.Sizeof(*tp)) 1345 } 1346 1347 func SetsockoptTpacketReq3(fd, level, opt int, tp *TpacketReq3) error { 1348 return setsockopt(fd, level, opt, unsafe.Pointer(tp), unsafe.Sizeof(*tp)) 1349 } 1350 1351 // Keyctl Commands (http://man7.org/linux/man-pages/man2/keyctl.2.html) 1352 1353 // KeyctlInt calls keyctl commands in which each argument is an int. 1354 // These commands are KEYCTL_REVOKE, KEYCTL_CHOWN, KEYCTL_CLEAR, KEYCTL_LINK, 1355 // KEYCTL_UNLINK, KEYCTL_NEGATE, KEYCTL_SET_REQKEY_KEYRING, KEYCTL_SET_TIMEOUT, 1356 // KEYCTL_ASSUME_AUTHORITY, KEYCTL_SESSION_TO_PARENT, KEYCTL_REJECT, 1357 // KEYCTL_INVALIDATE, and KEYCTL_GET_PERSISTENT. 1358 //sys KeyctlInt(cmd int, arg2 int, arg3 int, arg4 int, arg5 int) (ret int, err error) = SYS_KEYCTL 1359 1360 // KeyctlBuffer calls keyctl commands in which the third and fourth 1361 // arguments are a buffer and its length, respectively. 1362 // These commands are KEYCTL_UPDATE, KEYCTL_READ, and KEYCTL_INSTANTIATE. 1363 //sys KeyctlBuffer(cmd int, arg2 int, buf []byte, arg5 int) (ret int, err error) = SYS_KEYCTL 1364 1365 // KeyctlString calls keyctl commands which return a string. 1366 // These commands are KEYCTL_DESCRIBE and KEYCTL_GET_SECURITY. 1367 func KeyctlString(cmd int, id int) (string, error) { 1368 // We must loop as the string data may change in between the syscalls. 1369 // We could allocate a large buffer here to reduce the chance that the 1370 // syscall needs to be called twice; however, this is unnecessary as 1371 // the performance loss is negligible. 1372 var buffer []byte 1373 for { 1374 // Try to fill the buffer with data 1375 length, err := KeyctlBuffer(cmd, id, buffer, 0) 1376 if err != nil { 1377 return "", err 1378 } 1379 1380 // Check if the data was written 1381 if length <= len(buffer) { 1382 // Exclude the null terminator 1383 return string(buffer[:length-1]), nil 1384 } 1385 1386 // Make a bigger buffer if needed 1387 buffer = make([]byte, length) 1388 } 1389 } 1390 1391 // Keyctl commands with special signatures. 1392 1393 // KeyctlGetKeyringID implements the KEYCTL_GET_KEYRING_ID command. 1394 // See the full documentation at: 1395 // http://man7.org/linux/man-pages/man3/keyctl_get_keyring_ID.3.html 1396 func KeyctlGetKeyringID(id int, create bool) (ringid int, err error) { 1397 createInt := 0 1398 if create { 1399 createInt = 1 1400 } 1401 return KeyctlInt(KEYCTL_GET_KEYRING_ID, id, createInt, 0, 0) 1402 } 1403 1404 // KeyctlSetperm implements the KEYCTL_SETPERM command. The perm value is the 1405 // key handle permission mask as described in the "keyctl setperm" section of 1406 // http://man7.org/linux/man-pages/man1/keyctl.1.html. 1407 // See the full documentation at: 1408 // http://man7.org/linux/man-pages/man3/keyctl_setperm.3.html 1409 func KeyctlSetperm(id int, perm uint32) error { 1410 _, err := KeyctlInt(KEYCTL_SETPERM, id, int(perm), 0, 0) 1411 return err 1412 } 1413 1414 //sys keyctlJoin(cmd int, arg2 string) (ret int, err error) = SYS_KEYCTL 1415 1416 // KeyctlJoinSessionKeyring implements the KEYCTL_JOIN_SESSION_KEYRING command. 1417 // See the full documentation at: 1418 // http://man7.org/linux/man-pages/man3/keyctl_join_session_keyring.3.html 1419 func KeyctlJoinSessionKeyring(name string) (ringid int, err error) { 1420 return keyctlJoin(KEYCTL_JOIN_SESSION_KEYRING, name) 1421 } 1422 1423 //sys keyctlSearch(cmd int, arg2 int, arg3 string, arg4 string, arg5 int) (ret int, err error) = SYS_KEYCTL 1424 1425 // KeyctlSearch implements the KEYCTL_SEARCH command. 1426 // See the full documentation at: 1427 // http://man7.org/linux/man-pages/man3/keyctl_search.3.html 1428 func KeyctlSearch(ringid int, keyType, description string, destRingid int) (id int, err error) { 1429 return keyctlSearch(KEYCTL_SEARCH, ringid, keyType, description, destRingid) 1430 } 1431 1432 //sys keyctlIOV(cmd int, arg2 int, payload []Iovec, arg5 int) (err error) = SYS_KEYCTL 1433 1434 // KeyctlInstantiateIOV implements the KEYCTL_INSTANTIATE_IOV command. This 1435 // command is similar to KEYCTL_INSTANTIATE, except that the payload is a slice 1436 // of Iovec (each of which represents a buffer) instead of a single buffer. 1437 // See the full documentation at: 1438 // http://man7.org/linux/man-pages/man3/keyctl_instantiate_iov.3.html 1439 func KeyctlInstantiateIOV(id int, payload []Iovec, ringid int) error { 1440 return keyctlIOV(KEYCTL_INSTANTIATE_IOV, id, payload, ringid) 1441 } 1442 1443 //sys keyctlDH(cmd int, arg2 *KeyctlDHParams, buf []byte) (ret int, err error) = SYS_KEYCTL 1444 1445 // KeyctlDHCompute implements the KEYCTL_DH_COMPUTE command. This command 1446 // computes a Diffie-Hellman shared secret based on the provide params. The 1447 // secret is written to the provided buffer and the returned size is the number 1448 // of bytes written (returning an error if there is insufficient space in the 1449 // buffer). If a nil buffer is passed in, this function returns the minimum 1450 // buffer length needed to store the appropriate data. Note that this differs 1451 // from KEYCTL_READ's behavior which always returns the requested payload size. 1452 // See the full documentation at: 1453 // http://man7.org/linux/man-pages/man3/keyctl_dh_compute.3.html 1454 func KeyctlDHCompute(params *KeyctlDHParams, buffer []byte) (size int, err error) { 1455 return keyctlDH(KEYCTL_DH_COMPUTE, params, buffer) 1456 } 1457 1458 // KeyctlRestrictKeyring implements the KEYCTL_RESTRICT_KEYRING command. This 1459 // command limits the set of keys that can be linked to the keyring, regardless 1460 // of keyring permissions. The command requires the "setattr" permission. 1461 // 1462 // When called with an empty keyType the command locks the keyring, preventing 1463 // any further keys from being linked to the keyring. 1464 // 1465 // The "asymmetric" keyType defines restrictions requiring key payloads to be 1466 // DER encoded X.509 certificates signed by keys in another keyring. Restrictions 1467 // for "asymmetric" include "builtin_trusted", "builtin_and_secondary_trusted", 1468 // "key_or_keyring:<key>", and "key_or_keyring:<key>:chain". 1469 // 1470 // As of Linux 4.12, only the "asymmetric" keyType defines type-specific 1471 // restrictions. 1472 // 1473 // See the full documentation at: 1474 // http://man7.org/linux/man-pages/man3/keyctl_restrict_keyring.3.html 1475 // http://man7.org/linux/man-pages/man2/keyctl.2.html 1476 func KeyctlRestrictKeyring(ringid int, keyType string, restriction string) error { 1477 if keyType == "" { 1478 return keyctlRestrictKeyring(KEYCTL_RESTRICT_KEYRING, ringid) 1479 } 1480 return keyctlRestrictKeyringByType(KEYCTL_RESTRICT_KEYRING, ringid, keyType, restriction) 1481 } 1482 1483 //sys keyctlRestrictKeyringByType(cmd int, arg2 int, keyType string, restriction string) (err error) = SYS_KEYCTL 1484 //sys keyctlRestrictKeyring(cmd int, arg2 int) (err error) = SYS_KEYCTL 1485 1486 func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) { 1487 var msg Msghdr 1488 var rsa RawSockaddrAny 1489 msg.Name = (*byte)(unsafe.Pointer(&rsa)) 1490 msg.Namelen = uint32(SizeofSockaddrAny) 1491 var iov Iovec 1492 if len(p) > 0 { 1493 iov.Base = &p[0] 1494 iov.SetLen(len(p)) 1495 } 1496 var dummy byte 1497 if len(oob) > 0 { 1498 if len(p) == 0 { 1499 var sockType int 1500 sockType, err = GetsockoptInt(fd, SOL_SOCKET, SO_TYPE) 1501 if err != nil { 1502 return 1503 } 1504 // receive at least one normal byte 1505 if sockType != SOCK_DGRAM { 1506 iov.Base = &dummy 1507 iov.SetLen(1) 1508 } 1509 } 1510 msg.Control = &oob[0] 1511 msg.SetControllen(len(oob)) 1512 } 1513 msg.Iov = &iov 1514 msg.Iovlen = 1 1515 if n, err = recvmsg(fd, &msg, flags); err != nil { 1516 return 1517 } 1518 oobn = int(msg.Controllen) 1519 recvflags = int(msg.Flags) 1520 // source address is only specified if the socket is unconnected 1521 if rsa.Addr.Family != AF_UNSPEC { 1522 from, err = anyToSockaddr(fd, &rsa) 1523 } 1524 return 1525 } 1526 1527 func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) { 1528 _, err = SendmsgN(fd, p, oob, to, flags) 1529 return 1530 } 1531 1532 func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) { 1533 var ptr unsafe.Pointer 1534 var salen _Socklen 1535 if to != nil { 1536 var err error 1537 ptr, salen, err = to.sockaddr() 1538 if err != nil { 1539 return 0, err 1540 } 1541 } 1542 var msg Msghdr 1543 msg.Name = (*byte)(ptr) 1544 msg.Namelen = uint32(salen) 1545 var iov Iovec 1546 if len(p) > 0 { 1547 iov.Base = &p[0] 1548 iov.SetLen(len(p)) 1549 } 1550 var dummy byte 1551 if len(oob) > 0 { 1552 if len(p) == 0 { 1553 var sockType int 1554 sockType, err = GetsockoptInt(fd, SOL_SOCKET, SO_TYPE) 1555 if err != nil { 1556 return 0, err 1557 } 1558 // send at least one normal byte 1559 if sockType != SOCK_DGRAM { 1560 iov.Base = &dummy 1561 iov.SetLen(1) 1562 } 1563 } 1564 msg.Control = &oob[0] 1565 msg.SetControllen(len(oob)) 1566 } 1567 msg.Iov = &iov 1568 msg.Iovlen = 1 1569 if n, err = sendmsg(fd, &msg, flags); err != nil { 1570 return 0, err 1571 } 1572 if len(oob) > 0 && len(p) == 0 { 1573 n = 0 1574 } 1575 return n, nil 1576 } 1577 1578 // BindToDevice binds the socket associated with fd to device. 1579 func BindToDevice(fd int, device string) (err error) { 1580 return SetsockoptString(fd, SOL_SOCKET, SO_BINDTODEVICE, device) 1581 } 1582 1583 //sys ptrace(request int, pid int, addr uintptr, data uintptr) (err error) 1584 1585 func ptracePeek(req int, pid int, addr uintptr, out []byte) (count int, err error) { 1586 // The peek requests are machine-size oriented, so we wrap it 1587 // to retrieve arbitrary-length data. 1588 1589 // The ptrace syscall differs from glibc's ptrace. 1590 // Peeks returns the word in *data, not as the return value. 1591 1592 var buf [SizeofPtr]byte 1593 1594 // Leading edge. PEEKTEXT/PEEKDATA don't require aligned 1595 // access (PEEKUSER warns that it might), but if we don't 1596 // align our reads, we might straddle an unmapped page 1597 // boundary and not get the bytes leading up to the page 1598 // boundary. 1599 n := 0 1600 if addr%SizeofPtr != 0 { 1601 err = ptrace(req, pid, addr-addr%SizeofPtr, uintptr(unsafe.Pointer(&buf[0]))) 1602 if err != nil { 1603 return 0, err 1604 } 1605 n += copy(out, buf[addr%SizeofPtr:]) 1606 out = out[n:] 1607 } 1608 1609 // Remainder. 1610 for len(out) > 0 { 1611 // We use an internal buffer to guarantee alignment. 1612 // It's not documented if this is necessary, but we're paranoid. 1613 err = ptrace(req, pid, addr+uintptr(n), uintptr(unsafe.Pointer(&buf[0]))) 1614 if err != nil { 1615 return n, err 1616 } 1617 copied := copy(out, buf[0:]) 1618 n += copied 1619 out = out[copied:] 1620 } 1621 1622 return n, nil 1623 } 1624 1625 func PtracePeekText(pid int, addr uintptr, out []byte) (count int, err error) { 1626 return ptracePeek(PTRACE_PEEKTEXT, pid, addr, out) 1627 } 1628 1629 func PtracePeekData(pid int, addr uintptr, out []byte) (count int, err error) { 1630 return ptracePeek(PTRACE_PEEKDATA, pid, addr, out) 1631 } 1632 1633 func PtracePeekUser(pid int, addr uintptr, out []byte) (count int, err error) { 1634 return ptracePeek(PTRACE_PEEKUSR, pid, addr, out) 1635 } 1636 1637 func ptracePoke(pokeReq int, peekReq int, pid int, addr uintptr, data []byte) (count int, err error) { 1638 // As for ptracePeek, we need to align our accesses to deal 1639 // with the possibility of straddling an invalid page. 1640 1641 // Leading edge. 1642 n := 0 1643 if addr%SizeofPtr != 0 { 1644 var buf [SizeofPtr]byte 1645 err = ptrace(peekReq, pid, addr-addr%SizeofPtr, uintptr(unsafe.Pointer(&buf[0]))) 1646 if err != nil { 1647 return 0, err 1648 } 1649 n += copy(buf[addr%SizeofPtr:], data) 1650 word := *((*uintptr)(unsafe.Pointer(&buf[0]))) 1651 err = ptrace(pokeReq, pid, addr-addr%SizeofPtr, word) 1652 if err != nil { 1653 return 0, err 1654 } 1655 data = data[n:] 1656 } 1657 1658 // Interior. 1659 for len(data) > SizeofPtr { 1660 word := *((*uintptr)(unsafe.Pointer(&data[0]))) 1661 err = ptrace(pokeReq, pid, addr+uintptr(n), word) 1662 if err != nil { 1663 return n, err 1664 } 1665 n += SizeofPtr 1666 data = data[SizeofPtr:] 1667 } 1668 1669 // Trailing edge. 1670 if len(data) > 0 { 1671 var buf [SizeofPtr]byte 1672 err = ptrace(peekReq, pid, addr+uintptr(n), uintptr(unsafe.Pointer(&buf[0]))) 1673 if err != nil { 1674 return n, err 1675 } 1676 copy(buf[0:], data) 1677 word := *((*uintptr)(unsafe.Pointer(&buf[0]))) 1678 err = ptrace(pokeReq, pid, addr+uintptr(n), word) 1679 if err != nil { 1680 return n, err 1681 } 1682 n += len(data) 1683 } 1684 1685 return n, nil 1686 } 1687 1688 func PtracePokeText(pid int, addr uintptr, data []byte) (count int, err error) { 1689 return ptracePoke(PTRACE_POKETEXT, PTRACE_PEEKTEXT, pid, addr, data) 1690 } 1691 1692 func PtracePokeData(pid int, addr uintptr, data []byte) (count int, err error) { 1693 return ptracePoke(PTRACE_POKEDATA, PTRACE_PEEKDATA, pid, addr, data) 1694 } 1695 1696 func PtracePokeUser(pid int, addr uintptr, data []byte) (count int, err error) { 1697 return ptracePoke(PTRACE_POKEUSR, PTRACE_PEEKUSR, pid, addr, data) 1698 } 1699 1700 func PtraceGetRegs(pid int, regsout *PtraceRegs) (err error) { 1701 return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout))) 1702 } 1703 1704 func PtraceSetRegs(pid int, regs *PtraceRegs) (err error) { 1705 return ptrace(PTRACE_SETREGS, pid, 0, uintptr(unsafe.Pointer(regs))) 1706 } 1707 1708 func PtraceSetOptions(pid int, options int) (err error) { 1709 return ptrace(PTRACE_SETOPTIONS, pid, 0, uintptr(options)) 1710 } 1711 1712 func PtraceGetEventMsg(pid int) (msg uint, err error) { 1713 var data _C_long 1714 err = ptrace(PTRACE_GETEVENTMSG, pid, 0, uintptr(unsafe.Pointer(&data))) 1715 msg = uint(data) 1716 return 1717 } 1718 1719 func PtraceCont(pid int, signal int) (err error) { 1720 return ptrace(PTRACE_CONT, pid, 0, uintptr(signal)) 1721 } 1722 1723 func PtraceSyscall(pid int, signal int) (err error) { 1724 return ptrace(PTRACE_SYSCALL, pid, 0, uintptr(signal)) 1725 } 1726 1727 func PtraceSingleStep(pid int) (err error) { return ptrace(PTRACE_SINGLESTEP, pid, 0, 0) } 1728 1729 func PtraceInterrupt(pid int) (err error) { return ptrace(PTRACE_INTERRUPT, pid, 0, 0) } 1730 1731 func PtraceAttach(pid int) (err error) { return ptrace(PTRACE_ATTACH, pid, 0, 0) } 1732 1733 func PtraceSeize(pid int) (err error) { return ptrace(PTRACE_SEIZE, pid, 0, 0) } 1734 1735 func PtraceDetach(pid int) (err error) { return ptrace(PTRACE_DETACH, pid, 0, 0) } 1736 1737 //sys reboot(magic1 uint, magic2 uint, cmd int, arg string) (err error) 1738 1739 func Reboot(cmd int) (err error) { 1740 return reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, cmd, "") 1741 } 1742 1743 func direntIno(buf []byte) (uint64, bool) { 1744 return readInt(buf, unsafe.Offsetof(Dirent{}.Ino), unsafe.Sizeof(Dirent{}.Ino)) 1745 } 1746 1747 func direntReclen(buf []byte) (uint64, bool) { 1748 return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen)) 1749 } 1750 1751 func direntNamlen(buf []byte) (uint64, bool) { 1752 reclen, ok := direntReclen(buf) 1753 if !ok { 1754 return 0, false 1755 } 1756 return reclen - uint64(unsafe.Offsetof(Dirent{}.Name)), true 1757 } 1758 1759 //sys mount(source string, target string, fstype string, flags uintptr, data *byte) (err error) 1760 1761 func Mount(source string, target string, fstype string, flags uintptr, data string) (err error) { 1762 // Certain file systems get rather angry and EINVAL if you give 1763 // them an empty string of data, rather than NULL. 1764 if data == "" { 1765 return mount(source, target, fstype, flags, nil) 1766 } 1767 datap, err := BytePtrFromString(data) 1768 if err != nil { 1769 return err 1770 } 1771 return mount(source, target, fstype, flags, datap) 1772 } 1773 1774 func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) { 1775 if raceenabled { 1776 raceReleaseMerge(unsafe.Pointer(&ioSync)) 1777 } 1778 return sendfile(outfd, infd, offset, count) 1779 } 1780 1781 // Sendto 1782 // Recvfrom 1783 // Socketpair 1784 1785 /* 1786 * Direct access 1787 */ 1788 //sys Acct(path string) (err error) 1789 //sys AddKey(keyType string, description string, payload []byte, ringid int) (id int, err error) 1790 //sys Adjtimex(buf *Timex) (state int, err error) 1791 //sysnb Capget(hdr *CapUserHeader, data *CapUserData) (err error) 1792 //sysnb Capset(hdr *CapUserHeader, data *CapUserData) (err error) 1793 //sys Chdir(path string) (err error) 1794 //sys Chroot(path string) (err error) 1795 //sys ClockGetres(clockid int32, res *Timespec) (err error) 1796 //sys ClockGettime(clockid int32, time *Timespec) (err error) 1797 //sys ClockNanosleep(clockid int32, flags int, request *Timespec, remain *Timespec) (err error) 1798 //sys Close(fd int) (err error) 1799 //sys CloseRange(first uint, last uint, flags uint) (err error) 1800 //sys CopyFileRange(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int, err error) 1801 //sys DeleteModule(name string, flags int) (err error) 1802 //sys Dup(oldfd int) (fd int, err error) 1803 1804 func Dup2(oldfd, newfd int) error { 1805 // Android O and newer blocks dup2; riscv and arm64 don't implement dup2. 1806 if runtime.GOOS == "android" || runtime.GOARCH == "riscv64" || runtime.GOARCH == "arm64" { 1807 return Dup3(oldfd, newfd, 0) 1808 } 1809 return dup2(oldfd, newfd) 1810 } 1811 1812 //sys Dup3(oldfd int, newfd int, flags int) (err error) 1813 //sysnb EpollCreate1(flag int) (fd int, err error) 1814 //sysnb EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) 1815 //sys Eventfd(initval uint, flags int) (fd int, err error) = SYS_EVENTFD2 1816 //sys Exit(code int) = SYS_EXIT_GROUP 1817 //sys Fallocate(fd int, mode uint32, off int64, len int64) (err error) 1818 //sys Fchdir(fd int) (err error) 1819 //sys Fchmod(fd int, mode uint32) (err error) 1820 //sys Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error) 1821 //sys Fdatasync(fd int) (err error) 1822 //sys Fgetxattr(fd int, attr string, dest []byte) (sz int, err error) 1823 //sys FinitModule(fd int, params string, flags int) (err error) 1824 //sys Flistxattr(fd int, dest []byte) (sz int, err error) 1825 //sys Flock(fd int, how int) (err error) 1826 //sys Fremovexattr(fd int, attr string) (err error) 1827 //sys Fsetxattr(fd int, attr string, dest []byte, flags int) (err error) 1828 //sys Fsync(fd int) (err error) 1829 //sys Getdents(fd int, buf []byte) (n int, err error) = SYS_GETDENTS64 1830 //sysnb Getpgid(pid int) (pgid int, err error) 1831 1832 func Getpgrp() (pid int) { 1833 pid, _ = Getpgid(0) 1834 return 1835 } 1836 1837 //sysnb Getpid() (pid int) 1838 //sysnb Getppid() (ppid int) 1839 //sys Getpriority(which int, who int) (prio int, err error) 1840 //sys Getrandom(buf []byte, flags int) (n int, err error) 1841 //sysnb Getrusage(who int, rusage *Rusage) (err error) 1842 //sysnb Getsid(pid int) (sid int, err error) 1843 //sysnb Gettid() (tid int) 1844 //sys Getxattr(path string, attr string, dest []byte) (sz int, err error) 1845 //sys InitModule(moduleImage []byte, params string) (err error) 1846 //sys InotifyAddWatch(fd int, pathname string, mask uint32) (watchdesc int, err error) 1847 //sysnb InotifyInit1(flags int) (fd int, err error) 1848 //sysnb InotifyRmWatch(fd int, watchdesc uint32) (success int, err error) 1849 //sysnb Kill(pid int, sig syscall.Signal) (err error) 1850 //sys Klogctl(typ int, buf []byte) (n int, err error) = SYS_SYSLOG 1851 //sys Lgetxattr(path string, attr string, dest []byte) (sz int, err error) 1852 //sys Listxattr(path string, dest []byte) (sz int, err error) 1853 //sys Llistxattr(path string, dest []byte) (sz int, err error) 1854 //sys Lremovexattr(path string, attr string) (err error) 1855 //sys Lsetxattr(path string, attr string, data []byte, flags int) (err error) 1856 //sys MemfdCreate(name string, flags int) (fd int, err error) 1857 //sys Mkdirat(dirfd int, path string, mode uint32) (err error) 1858 //sys Mknodat(dirfd int, path string, mode uint32, dev int) (err error) 1859 //sys Nanosleep(time *Timespec, leftover *Timespec) (err error) 1860 //sys PerfEventOpen(attr *PerfEventAttr, pid int, cpu int, groupFd int, flags int) (fd int, err error) 1861 //sys PivotRoot(newroot string, putold string) (err error) = SYS_PIVOT_ROOT 1862 //sysnb prlimit(pid int, resource int, newlimit *Rlimit, old *Rlimit) (err error) = SYS_PRLIMIT64 1863 //sys Prctl(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (err error) 1864 //sys Pselect(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timespec, sigmask *Sigset_t) (n int, err error) = SYS_PSELECT6 1865 //sys read(fd int, p []byte) (n int, err error) 1866 //sys Removexattr(path string, attr string) (err error) 1867 //sys Renameat2(olddirfd int, oldpath string, newdirfd int, newpath string, flags uint) (err error) 1868 //sys RequestKey(keyType string, description string, callback string, destRingid int) (id int, err error) 1869 //sys Setdomainname(p []byte) (err error) 1870 //sys Sethostname(p []byte) (err error) 1871 //sysnb Setpgid(pid int, pgid int) (err error) 1872 //sysnb Setsid() (pid int, err error) 1873 //sysnb Settimeofday(tv *Timeval) (err error) 1874 //sys Setns(fd int, nstype int) (err error) 1875 1876 // PrctlRetInt performs a prctl operation specified by option and further 1877 // optional arguments arg2 through arg5 depending on option. It returns a 1878 // non-negative integer that is returned by the prctl syscall. 1879 func PrctlRetInt(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (int, error) { 1880 ret, _, err := Syscall6(SYS_PRCTL, uintptr(option), uintptr(arg2), uintptr(arg3), uintptr(arg4), uintptr(arg5), 0) 1881 if err != 0 { 1882 return 0, err 1883 } 1884 return int(ret), nil 1885 } 1886 1887 // issue 1435. 1888 // On linux Setuid and Setgid only affects the current thread, not the process. 1889 // This does not match what most callers expect so we must return an error 1890 // here rather than letting the caller think that the call succeeded. 1891 1892 func Setuid(uid int) (err error) { 1893 return EOPNOTSUPP 1894 } 1895 1896 func Setgid(uid int) (err error) { 1897 return EOPNOTSUPP 1898 } 1899 1900 // SetfsgidRetGid sets fsgid for current thread and returns previous fsgid set. 1901 // setfsgid(2) will return a non-nil error only if its caller lacks CAP_SETUID capability. 1902 // If the call fails due to other reasons, current fsgid will be returned. 1903 func SetfsgidRetGid(gid int) (int, error) { 1904 return setfsgid(gid) 1905 } 1906 1907 // SetfsuidRetUid sets fsuid for current thread and returns previous fsuid set. 1908 // setfsgid(2) will return a non-nil error only if its caller lacks CAP_SETUID capability 1909 // If the call fails due to other reasons, current fsuid will be returned. 1910 func SetfsuidRetUid(uid int) (int, error) { 1911 return setfsuid(uid) 1912 } 1913 1914 func Setfsgid(gid int) error { 1915 _, err := setfsgid(gid) 1916 return err 1917 } 1918 1919 func Setfsuid(uid int) error { 1920 _, err := setfsuid(uid) 1921 return err 1922 } 1923 1924 func Signalfd(fd int, sigmask *Sigset_t, flags int) (newfd int, err error) { 1925 return signalfd(fd, sigmask, _C__NSIG/8, flags) 1926 } 1927 1928 //sys Setpriority(which int, who int, prio int) (err error) 1929 //sys Setxattr(path string, attr string, data []byte, flags int) (err error) 1930 //sys signalfd(fd int, sigmask *Sigset_t, maskSize uintptr, flags int) (newfd int, err error) = SYS_SIGNALFD4 1931 //sys Statx(dirfd int, path string, flags int, mask int, stat *Statx_t) (err error) 1932 //sys Sync() 1933 //sys Syncfs(fd int) (err error) 1934 //sysnb Sysinfo(info *Sysinfo_t) (err error) 1935 //sys Tee(rfd int, wfd int, len int, flags int) (n int64, err error) 1936 //sysnb TimerfdCreate(clockid int, flags int) (fd int, err error) 1937 //sysnb TimerfdGettime(fd int, currValue *ItimerSpec) (err error) 1938 //sysnb TimerfdSettime(fd int, flags int, newValue *ItimerSpec, oldValue *ItimerSpec) (err error) 1939 //sysnb Tgkill(tgid int, tid int, sig syscall.Signal) (err error) 1940 //sysnb Times(tms *Tms) (ticks uintptr, err error) 1941 //sysnb Umask(mask int) (oldmask int) 1942 //sysnb Uname(buf *Utsname) (err error) 1943 //sys Unmount(target string, flags int) (err error) = SYS_UMOUNT2 1944 //sys Unshare(flags int) (err error) 1945 //sys write(fd int, p []byte) (n int, err error) 1946 //sys exitThread(code int) (err error) = SYS_EXIT 1947 //sys readlen(fd int, p *byte, np int) (n int, err error) = SYS_READ 1948 //sys writelen(fd int, p *byte, np int) (n int, err error) = SYS_WRITE 1949 //sys readv(fd int, iovs []Iovec) (n int, err error) = SYS_READV 1950 //sys writev(fd int, iovs []Iovec) (n int, err error) = SYS_WRITEV 1951 //sys preadv(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr) (n int, err error) = SYS_PREADV 1952 //sys pwritev(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr) (n int, err error) = SYS_PWRITEV 1953 //sys preadv2(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr, flags int) (n int, err error) = SYS_PREADV2 1954 //sys pwritev2(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr, flags int) (n int, err error) = SYS_PWRITEV2 1955 1956 func bytes2iovec(bs [][]byte) []Iovec { 1957 iovecs := make([]Iovec, len(bs)) 1958 for i, b := range bs { 1959 iovecs[i].SetLen(len(b)) 1960 if len(b) > 0 { 1961 iovecs[i].Base = &b[0] 1962 } else { 1963 iovecs[i].Base = (*byte)(unsafe.Pointer(&_zero)) 1964 } 1965 } 1966 return iovecs 1967 } 1968 1969 // offs2lohi splits offs into its lower and upper unsigned long. On 64-bit 1970 // systems, hi will always be 0. On 32-bit systems, offs will be split in half. 1971 // preadv/pwritev chose this calling convention so they don't need to add a 1972 // padding-register for alignment on ARM. 1973 func offs2lohi(offs int64) (lo, hi uintptr) { 1974 return uintptr(offs), uintptr(uint64(offs) >> SizeofLong) 1975 } 1976 1977 func Readv(fd int, iovs [][]byte) (n int, err error) { 1978 iovecs := bytes2iovec(iovs) 1979 n, err = readv(fd, iovecs) 1980 readvRacedetect(iovecs, n, err) 1981 return n, err 1982 } 1983 1984 func Preadv(fd int, iovs [][]byte, offset int64) (n int, err error) { 1985 iovecs := bytes2iovec(iovs) 1986 lo, hi := offs2lohi(offset) 1987 n, err = preadv(fd, iovecs, lo, hi) 1988 readvRacedetect(iovecs, n, err) 1989 return n, err 1990 } 1991 1992 func Preadv2(fd int, iovs [][]byte, offset int64, flags int) (n int, err error) { 1993 iovecs := bytes2iovec(iovs) 1994 lo, hi := offs2lohi(offset) 1995 n, err = preadv2(fd, iovecs, lo, hi, flags) 1996 readvRacedetect(iovecs, n, err) 1997 return n, err 1998 } 1999 2000 func readvRacedetect(iovecs []Iovec, n int, err error) { 2001 if !raceenabled { 2002 return 2003 } 2004 for i := 0; n > 0 && i < len(iovecs); i++ { 2005 m := int(iovecs[i].Len) 2006 if m > n { 2007 m = n 2008 } 2009 n -= m 2010 if m > 0 { 2011 raceWriteRange(unsafe.Pointer(iovecs[i].Base), m) 2012 } 2013 } 2014 if err == nil { 2015 raceAcquire(unsafe.Pointer(&ioSync)) 2016 } 2017 } 2018 2019 func Writev(fd int, iovs [][]byte) (n int, err error) { 2020 iovecs := bytes2iovec(iovs) 2021 if raceenabled { 2022 raceReleaseMerge(unsafe.Pointer(&ioSync)) 2023 } 2024 n, err = writev(fd, iovecs) 2025 writevRacedetect(iovecs, n) 2026 return n, err 2027 } 2028 2029 func Pwritev(fd int, iovs [][]byte, offset int64) (n int, err error) { 2030 iovecs := bytes2iovec(iovs) 2031 if raceenabled { 2032 raceReleaseMerge(unsafe.Pointer(&ioSync)) 2033 } 2034 lo, hi := offs2lohi(offset) 2035 n, err = pwritev(fd, iovecs, lo, hi) 2036 writevRacedetect(iovecs, n) 2037 return n, err 2038 } 2039 2040 func Pwritev2(fd int, iovs [][]byte, offset int64, flags int) (n int, err error) { 2041 iovecs := bytes2iovec(iovs) 2042 if raceenabled { 2043 raceReleaseMerge(unsafe.Pointer(&ioSync)) 2044 } 2045 lo, hi := offs2lohi(offset) 2046 n, err = pwritev2(fd, iovecs, lo, hi, flags) 2047 writevRacedetect(iovecs, n) 2048 return n, err 2049 } 2050 2051 func writevRacedetect(iovecs []Iovec, n int) { 2052 if !raceenabled { 2053 return 2054 } 2055 for i := 0; n > 0 && i < len(iovecs); i++ { 2056 m := int(iovecs[i].Len) 2057 if m > n { 2058 m = n 2059 } 2060 n -= m 2061 if m > 0 { 2062 raceReadRange(unsafe.Pointer(iovecs[i].Base), m) 2063 } 2064 } 2065 } 2066 2067 // mmap varies by architecture; see syscall_linux_*.go. 2068 //sys munmap(addr uintptr, length uintptr) (err error) 2069 2070 var mapper = &mmapper{ 2071 active: make(map[*byte][]byte), 2072 mmap: mmap, 2073 munmap: munmap, 2074 } 2075 2076 func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) { 2077 return mapper.Mmap(fd, offset, length, prot, flags) 2078 } 2079 2080 func Munmap(b []byte) (err error) { 2081 return mapper.Munmap(b) 2082 } 2083 2084 //sys Madvise(b []byte, advice int) (err error) 2085 //sys Mprotect(b []byte, prot int) (err error) 2086 //sys Mlock(b []byte) (err error) 2087 //sys Mlockall(flags int) (err error) 2088 //sys Msync(b []byte, flags int) (err error) 2089 //sys Munlock(b []byte) (err error) 2090 //sys Munlockall() (err error) 2091 2092 // Vmsplice splices user pages from a slice of Iovecs into a pipe specified by fd, 2093 // using the specified flags. 2094 func Vmsplice(fd int, iovs []Iovec, flags int) (int, error) { 2095 var p unsafe.Pointer 2096 if len(iovs) > 0 { 2097 p = unsafe.Pointer(&iovs[0]) 2098 } 2099 2100 n, _, errno := Syscall6(SYS_VMSPLICE, uintptr(fd), uintptr(p), uintptr(len(iovs)), uintptr(flags), 0, 0) 2101 if errno != 0 { 2102 return 0, syscall.Errno(errno) 2103 } 2104 2105 return int(n), nil 2106 } 2107 2108 func isGroupMember(gid int) bool { 2109 groups, err := Getgroups() 2110 if err != nil { 2111 return false 2112 } 2113 2114 for _, g := range groups { 2115 if g == gid { 2116 return true 2117 } 2118 } 2119 return false 2120 } 2121 2122 //sys faccessat(dirfd int, path string, mode uint32) (err error) 2123 //sys Faccessat2(dirfd int, path string, mode uint32, flags int) (err error) 2124 2125 func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) { 2126 if flags == 0 { 2127 return faccessat(dirfd, path, mode) 2128 } 2129 2130 if err := Faccessat2(dirfd, path, mode, flags); err != ENOSYS && err != EPERM { 2131 return err 2132 } 2133 2134 // The Linux kernel faccessat system call does not take any flags. 2135 // The glibc faccessat implements the flags itself; see 2136 // https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/unix/sysv/linux/faccessat.c;hb=HEAD 2137 // Because people naturally expect syscall.Faccessat to act 2138 // like C faccessat, we do the same. 2139 2140 if flags & ^(AT_SYMLINK_NOFOLLOW|AT_EACCESS) != 0 { 2141 return EINVAL 2142 } 2143 2144 var st Stat_t 2145 if err := Fstatat(dirfd, path, &st, flags&AT_SYMLINK_NOFOLLOW); err != nil { 2146 return err 2147 } 2148 2149 mode &= 7 2150 if mode == 0 { 2151 return nil 2152 } 2153 2154 var uid int 2155 if flags&AT_EACCESS != 0 { 2156 uid = Geteuid() 2157 } else { 2158 uid = Getuid() 2159 } 2160 2161 if uid == 0 { 2162 if mode&1 == 0 { 2163 // Root can read and write any file. 2164 return nil 2165 } 2166 if st.Mode&0111 != 0 { 2167 // Root can execute any file that anybody can execute. 2168 return nil 2169 } 2170 return EACCES 2171 } 2172 2173 var fmode uint32 2174 if uint32(uid) == st.Uid { 2175 fmode = (st.Mode >> 6) & 7 2176 } else { 2177 var gid int 2178 if flags&AT_EACCESS != 0 { 2179 gid = Getegid() 2180 } else { 2181 gid = Getgid() 2182 } 2183 2184 if uint32(gid) == st.Gid || isGroupMember(gid) { 2185 fmode = (st.Mode >> 3) & 7 2186 } else { 2187 fmode = st.Mode & 7 2188 } 2189 } 2190 2191 if fmode&mode == mode { 2192 return nil 2193 } 2194 2195 return EACCES 2196 } 2197 2198 //sys nameToHandleAt(dirFD int, pathname string, fh *fileHandle, mountID *_C_int, flags int) (err error) = SYS_NAME_TO_HANDLE_AT 2199 //sys openByHandleAt(mountFD int, fh *fileHandle, flags int) (fd int, err error) = SYS_OPEN_BY_HANDLE_AT 2200 2201 // fileHandle is the argument to nameToHandleAt and openByHandleAt. We 2202 // originally tried to generate it via unix/linux/types.go with "type 2203 // fileHandle C.struct_file_handle" but that generated empty structs 2204 // for mips64 and mips64le. Instead, hard code it for now (it's the 2205 // same everywhere else) until the mips64 generator issue is fixed. 2206 type fileHandle struct { 2207 Bytes uint32 2208 Type int32 2209 } 2210 2211 // FileHandle represents the C struct file_handle used by 2212 // name_to_handle_at (see NameToHandleAt) and open_by_handle_at (see 2213 // OpenByHandleAt). 2214 type FileHandle struct { 2215 *fileHandle 2216 } 2217 2218 // NewFileHandle constructs a FileHandle. 2219 func NewFileHandle(handleType int32, handle []byte) FileHandle { 2220 const hdrSize = unsafe.Sizeof(fileHandle{}) 2221 buf := make([]byte, hdrSize+uintptr(len(handle))) 2222 copy(buf[hdrSize:], handle) 2223 fh := (*fileHandle)(unsafe.Pointer(&buf[0])) 2224 fh.Type = handleType 2225 fh.Bytes = uint32(len(handle)) 2226 return FileHandle{fh} 2227 } 2228 2229 func (fh *FileHandle) Size() int { return int(fh.fileHandle.Bytes) } 2230 func (fh *FileHandle) Type() int32 { return fh.fileHandle.Type } 2231 func (fh *FileHandle) Bytes() []byte { 2232 n := fh.Size() 2233 if n == 0 { 2234 return nil 2235 } 2236 return (*[1 << 30]byte)(unsafe.Pointer(uintptr(unsafe.Pointer(&fh.fileHandle.Type)) + 4))[:n:n] 2237 } 2238 2239 // NameToHandleAt wraps the name_to_handle_at system call; it obtains 2240 // a handle for a path name. 2241 func NameToHandleAt(dirfd int, path string, flags int) (handle FileHandle, mountID int, err error) { 2242 var mid _C_int 2243 // Try first with a small buffer, assuming the handle will 2244 // only be 32 bytes. 2245 size := uint32(32 + unsafe.Sizeof(fileHandle{})) 2246 didResize := false 2247 for { 2248 buf := make([]byte, size) 2249 fh := (*fileHandle)(unsafe.Pointer(&buf[0])) 2250 fh.Bytes = size - uint32(unsafe.Sizeof(fileHandle{})) 2251 err = nameToHandleAt(dirfd, path, fh, &mid, flags) 2252 if err == EOVERFLOW { 2253 if didResize { 2254 // We shouldn't need to resize more than once 2255 return 2256 } 2257 didResize = true 2258 size = fh.Bytes + uint32(unsafe.Sizeof(fileHandle{})) 2259 continue 2260 } 2261 if err != nil { 2262 return 2263 } 2264 return FileHandle{fh}, int(mid), nil 2265 } 2266 } 2267 2268 // OpenByHandleAt wraps the open_by_handle_at system call; it opens a 2269 // file via a handle as previously returned by NameToHandleAt. 2270 func OpenByHandleAt(mountFD int, handle FileHandle, flags int) (fd int, err error) { 2271 return openByHandleAt(mountFD, handle.fileHandle, flags) 2272 } 2273 2274 // Klogset wraps the sys_syslog system call; it sets console_loglevel to 2275 // the value specified by arg and passes a dummy pointer to bufp. 2276 func Klogset(typ int, arg int) (err error) { 2277 var p unsafe.Pointer 2278 _, _, errno := Syscall(SYS_SYSLOG, uintptr(typ), uintptr(p), uintptr(arg)) 2279 if errno != 0 { 2280 return errnoErr(errno) 2281 } 2282 return nil 2283 } 2284 2285 // RemoteIovec is Iovec with the pointer replaced with an integer. 2286 // It is used for ProcessVMReadv and ProcessVMWritev, where the pointer 2287 // refers to a location in a different process' address space, which 2288 // would confuse the Go garbage collector. 2289 type RemoteIovec struct { 2290 Base uintptr 2291 Len int 2292 } 2293 2294 //sys ProcessVMReadv(pid int, localIov []Iovec, remoteIov []RemoteIovec, flags uint) (n int, err error) = SYS_PROCESS_VM_READV 2295 //sys ProcessVMWritev(pid int, localIov []Iovec, remoteIov []RemoteIovec, flags uint) (n int, err error) = SYS_PROCESS_VM_WRITEV 2296 2297 /* 2298 * Unimplemented 2299 */ 2300 // AfsSyscall 2301 // Alarm 2302 // ArchPrctl 2303 // Brk 2304 // ClockNanosleep 2305 // ClockSettime 2306 // Clone 2307 // EpollCtlOld 2308 // EpollPwait 2309 // EpollWaitOld 2310 // Execve 2311 // Fork 2312 // Futex 2313 // GetKernelSyms 2314 // GetMempolicy 2315 // GetRobustList 2316 // GetThreadArea 2317 // Getitimer 2318 // Getpmsg 2319 // IoCancel 2320 // IoDestroy 2321 // IoGetevents 2322 // IoSetup 2323 // IoSubmit 2324 // IoprioGet 2325 // IoprioSet 2326 // KexecLoad 2327 // LookupDcookie 2328 // Mbind 2329 // MigratePages 2330 // Mincore 2331 // ModifyLdt 2332 // Mount 2333 // MovePages 2334 // MqGetsetattr 2335 // MqNotify 2336 // MqOpen 2337 // MqTimedreceive 2338 // MqTimedsend 2339 // MqUnlink 2340 // Mremap 2341 // Msgctl 2342 // Msgget 2343 // Msgrcv 2344 // Msgsnd 2345 // Nfsservctl 2346 // Personality 2347 // Pselect6 2348 // Ptrace 2349 // Putpmsg 2350 // Quotactl 2351 // Readahead 2352 // Readv 2353 // RemapFilePages 2354 // RestartSyscall 2355 // RtSigaction 2356 // RtSigpending 2357 // RtSigprocmask 2358 // RtSigqueueinfo 2359 // RtSigreturn 2360 // RtSigsuspend 2361 // RtSigtimedwait 2362 // SchedGetPriorityMax 2363 // SchedGetPriorityMin 2364 // SchedGetparam 2365 // SchedGetscheduler 2366 // SchedRrGetInterval 2367 // SchedSetparam 2368 // SchedYield 2369 // Security 2370 // Semctl 2371 // Semget 2372 // Semop 2373 // Semtimedop 2374 // SetMempolicy 2375 // SetRobustList 2376 // SetThreadArea 2377 // SetTidAddress 2378 // Shmat 2379 // Shmctl 2380 // Shmdt 2381 // Shmget 2382 // Sigaltstack 2383 // Swapoff 2384 // Swapon 2385 // Sysfs 2386 // TimerCreate 2387 // TimerDelete 2388 // TimerGetoverrun 2389 // TimerGettime 2390 // TimerSettime 2391 // Tkill (obsolete) 2392 // Tuxcall 2393 // Umount2 2394 // Uselib 2395 // Utimensat 2396 // Vfork 2397 // Vhangup 2398 // Vserver 2399 // Waitid 2400 // _Sysctl