Source file
src/syscall/syscall_linux.go
Documentation: syscall
1
2
3
4
5
6
7
8
9
10
11
12 package syscall
13
14 import "unsafe"
15
16
19
20 func Access(path string, mode uint32) (err error) {
21 return Faccessat(_AT_FDCWD, path, mode, 0)
22 }
23
24 func Chmod(path string, mode uint32) (err error) {
25 return Fchmodat(_AT_FDCWD, path, mode, 0)
26 }
27
28 func Chown(path string, uid int, gid int) (err error) {
29 return Fchownat(_AT_FDCWD, path, uid, gid, 0)
30 }
31
32 func Creat(path string, mode uint32) (fd int, err error) {
33 return Open(path, O_CREAT|O_WRONLY|O_TRUNC, mode)
34 }
35
36
37
38 func Link(oldpath string, newpath string) (err error) {
39 return linkat(_AT_FDCWD, oldpath, _AT_FDCWD, newpath, 0)
40 }
41
42 func Mkdir(path string, mode uint32) (err error) {
43 return Mkdirat(_AT_FDCWD, path, mode)
44 }
45
46 func Mknod(path string, mode uint32, dev int) (err error) {
47 return Mknodat(_AT_FDCWD, path, mode, dev)
48 }
49
50 func Open(path string, mode int, perm uint32) (fd int, err error) {
51 return openat(_AT_FDCWD, path, mode|O_LARGEFILE, perm)
52 }
53
54
55
56 func Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) {
57 return openat(dirfd, path, flags|O_LARGEFILE, mode)
58 }
59
60
61
62 func Readlink(path string, buf []byte) (n int, err error) {
63 return readlinkat(_AT_FDCWD, path, buf)
64 }
65
66 func Rename(oldpath string, newpath string) (err error) {
67 return Renameat(_AT_FDCWD, oldpath, _AT_FDCWD, newpath)
68 }
69
70 func Rmdir(path string) error {
71 return unlinkat(_AT_FDCWD, path, _AT_REMOVEDIR)
72 }
73
74
75
76 func Symlink(oldpath string, newpath string) (err error) {
77 return symlinkat(oldpath, _AT_FDCWD, newpath)
78 }
79
80 func Unlink(path string) error {
81 return unlinkat(_AT_FDCWD, path, 0)
82 }
83
84
85
86 func Unlinkat(dirfd int, path string) error {
87 return unlinkat(dirfd, path, 0)
88 }
89
90
91
92 func Utimes(path string, tv []Timeval) (err error) {
93 if len(tv) != 2 {
94 return EINVAL
95 }
96 return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
97 }
98
99
100
101 func UtimesNano(path string, ts []Timespec) (err error) {
102 if len(ts) != 2 {
103 return EINVAL
104 }
105 err = utimensat(_AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0)
106 if err != ENOSYS {
107 return err
108 }
109
110
111 var tv [2]Timeval
112 for i := 0; i < 2; i++ {
113 tv[i].Sec = ts[i].Sec
114 tv[i].Usec = ts[i].Nsec / 1000
115 }
116 return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
117 }
118
119
120
121 func Futimesat(dirfd int, path string, tv []Timeval) (err error) {
122 if len(tv) != 2 {
123 return EINVAL
124 }
125 pathp, err := BytePtrFromString(path)
126 if err != nil {
127 return err
128 }
129 return futimesat(dirfd, pathp, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
130 }
131
132 func Futimes(fd int, tv []Timeval) (err error) {
133
134
135 return Utimes("/proc/self/fd/"+itoa(fd), tv)
136 }
137
138 const ImplementsGetwd = true
139
140
141
142 func Getwd() (wd string, err error) {
143 var buf [PathMax]byte
144 n, err := Getcwd(buf[0:])
145 if err != nil {
146 return "", err
147 }
148
149 if n < 1 || n > len(buf) || buf[n-1] != 0 {
150 return "", EINVAL
151 }
152 return string(buf[0 : n-1]), nil
153 }
154
155 func Getgroups() (gids []int, err error) {
156 n, err := getgroups(0, nil)
157 if err != nil {
158 return nil, err
159 }
160 if n == 0 {
161 return nil, nil
162 }
163
164
165 if n < 0 || n > 1<<20 {
166 return nil, EINVAL
167 }
168
169 a := make([]_Gid_t, n)
170 n, err = getgroups(n, &a[0])
171 if err != nil {
172 return nil, err
173 }
174 gids = make([]int, n)
175 for i, v := range a[0:n] {
176 gids[i] = int(v)
177 }
178 return
179 }
180
181 func Setgroups(gids []int) (err error) {
182 if len(gids) == 0 {
183 return setgroups(0, nil)
184 }
185
186 a := make([]_Gid_t, len(gids))
187 for i, v := range gids {
188 a[i] = _Gid_t(v)
189 }
190 return setgroups(len(a), &a[0])
191 }
192
193 type WaitStatus uint32
194
195
196
197
198
199
200
201
202
203
204 const (
205 mask = 0x7F
206 core = 0x80
207 exited = 0x00
208 stopped = 0x7F
209 shift = 8
210 )
211
212 func (w WaitStatus) Exited() bool { return w&mask == exited }
213
214 func (w WaitStatus) Signaled() bool { return w&mask != stopped && w&mask != exited }
215
216 func (w WaitStatus) Stopped() bool { return w&0xFF == stopped }
217
218 func (w WaitStatus) Continued() bool { return w == 0xFFFF }
219
220 func (w WaitStatus) CoreDump() bool { return w.Signaled() && w&core != 0 }
221
222 func (w WaitStatus) ExitStatus() int {
223 if !w.Exited() {
224 return -1
225 }
226 return int(w>>shift) & 0xFF
227 }
228
229 func (w WaitStatus) Signal() Signal {
230 if !w.Signaled() {
231 return -1
232 }
233 return Signal(w & mask)
234 }
235
236 func (w WaitStatus) StopSignal() Signal {
237 if !w.Stopped() {
238 return -1
239 }
240 return Signal(w>>shift) & 0xFF
241 }
242
243 func (w WaitStatus) TrapCause() int {
244 if w.StopSignal() != SIGTRAP {
245 return -1
246 }
247 return int(w>>shift) >> 8
248 }
249
250
251
252 func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) {
253 var status _C_int
254 wpid, err = wait4(pid, &status, options, rusage)
255 if wstatus != nil {
256 *wstatus = WaitStatus(status)
257 }
258 return
259 }
260
261 func Mkfifo(path string, mode uint32) (err error) {
262 return Mknod(path, mode|S_IFIFO, 0)
263 }
264
265 func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) {
266 if sa.Port < 0 || sa.Port > 0xFFFF {
267 return nil, 0, EINVAL
268 }
269 sa.raw.Family = AF_INET
270 p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
271 p[0] = byte(sa.Port >> 8)
272 p[1] = byte(sa.Port)
273 for i := 0; i < len(sa.Addr); i++ {
274 sa.raw.Addr[i] = sa.Addr[i]
275 }
276 return unsafe.Pointer(&sa.raw), SizeofSockaddrInet4, nil
277 }
278
279 func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) {
280 if sa.Port < 0 || sa.Port > 0xFFFF {
281 return nil, 0, EINVAL
282 }
283 sa.raw.Family = AF_INET6
284 p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
285 p[0] = byte(sa.Port >> 8)
286 p[1] = byte(sa.Port)
287 sa.raw.Scope_id = sa.ZoneId
288 for i := 0; i < len(sa.Addr); i++ {
289 sa.raw.Addr[i] = sa.Addr[i]
290 }
291 return unsafe.Pointer(&sa.raw), SizeofSockaddrInet6, nil
292 }
293
294 func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) {
295 name := sa.Name
296 n := len(name)
297 if n > len(sa.raw.Path) {
298 return nil, 0, EINVAL
299 }
300 if n == len(sa.raw.Path) && name[0] != '@' {
301 return nil, 0, EINVAL
302 }
303 sa.raw.Family = AF_UNIX
304 for i := 0; i < n; i++ {
305 sa.raw.Path[i] = int8(name[i])
306 }
307
308 sl := _Socklen(2)
309 if n > 0 {
310 sl += _Socklen(n) + 1
311 }
312 if sa.raw.Path[0] == '@' {
313 sa.raw.Path[0] = 0
314
315 sl--
316 }
317
318 return unsafe.Pointer(&sa.raw), sl, nil
319 }
320
321 type SockaddrLinklayer struct {
322 Protocol uint16
323 Ifindex int
324 Hatype uint16
325 Pkttype uint8
326 Halen uint8
327 Addr [8]byte
328 raw RawSockaddrLinklayer
329 }
330
331 func (sa *SockaddrLinklayer) sockaddr() (unsafe.Pointer, _Socklen, error) {
332 if sa.Ifindex < 0 || sa.Ifindex > 0x7fffffff {
333 return nil, 0, EINVAL
334 }
335 sa.raw.Family = AF_PACKET
336 sa.raw.Protocol = sa.Protocol
337 sa.raw.Ifindex = int32(sa.Ifindex)
338 sa.raw.Hatype = sa.Hatype
339 sa.raw.Pkttype = sa.Pkttype
340 sa.raw.Halen = sa.Halen
341 for i := 0; i < len(sa.Addr); i++ {
342 sa.raw.Addr[i] = sa.Addr[i]
343 }
344 return unsafe.Pointer(&sa.raw), SizeofSockaddrLinklayer, nil
345 }
346
347 type SockaddrNetlink struct {
348 Family uint16
349 Pad uint16
350 Pid uint32
351 Groups uint32
352 raw RawSockaddrNetlink
353 }
354
355 func (sa *SockaddrNetlink) sockaddr() (unsafe.Pointer, _Socklen, error) {
356 sa.raw.Family = AF_NETLINK
357 sa.raw.Pad = sa.Pad
358 sa.raw.Pid = sa.Pid
359 sa.raw.Groups = sa.Groups
360 return unsafe.Pointer(&sa.raw), SizeofSockaddrNetlink, nil
361 }
362
363 func anyToSockaddr(rsa *RawSockaddrAny) (Sockaddr, error) {
364 switch rsa.Addr.Family {
365 case AF_NETLINK:
366 pp := (*RawSockaddrNetlink)(unsafe.Pointer(rsa))
367 sa := new(SockaddrNetlink)
368 sa.Family = pp.Family
369 sa.Pad = pp.Pad
370 sa.Pid = pp.Pid
371 sa.Groups = pp.Groups
372 return sa, nil
373
374 case AF_PACKET:
375 pp := (*RawSockaddrLinklayer)(unsafe.Pointer(rsa))
376 sa := new(SockaddrLinklayer)
377 sa.Protocol = pp.Protocol
378 sa.Ifindex = int(pp.Ifindex)
379 sa.Hatype = pp.Hatype
380 sa.Pkttype = pp.Pkttype
381 sa.Halen = pp.Halen
382 for i := 0; i < len(sa.Addr); i++ {
383 sa.Addr[i] = pp.Addr[i]
384 }
385 return sa, nil
386
387 case AF_UNIX:
388 pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa))
389 sa := new(SockaddrUnix)
390 if pp.Path[0] == 0 {
391
392
393
394
395
396 pp.Path[0] = '@'
397 }
398
399
400
401
402
403
404 n := 0
405 for n < len(pp.Path) && pp.Path[n] != 0 {
406 n++
407 }
408 bytes := (*[10000]byte)(unsafe.Pointer(&pp.Path[0]))[0:n]
409 sa.Name = string(bytes)
410 return sa, nil
411
412 case AF_INET:
413 pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa))
414 sa := new(SockaddrInet4)
415 p := (*[2]byte)(unsafe.Pointer(&pp.Port))
416 sa.Port = int(p[0])<<8 + int(p[1])
417 for i := 0; i < len(sa.Addr); i++ {
418 sa.Addr[i] = pp.Addr[i]
419 }
420 return sa, nil
421
422 case AF_INET6:
423 pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa))
424 sa := new(SockaddrInet6)
425 p := (*[2]byte)(unsafe.Pointer(&pp.Port))
426 sa.Port = int(p[0])<<8 + int(p[1])
427 sa.ZoneId = pp.Scope_id
428 for i := 0; i < len(sa.Addr); i++ {
429 sa.Addr[i] = pp.Addr[i]
430 }
431 return sa, nil
432 }
433 return nil, EAFNOSUPPORT
434 }
435
436 func Accept(fd int) (nfd int, sa Sockaddr, err error) {
437 var rsa RawSockaddrAny
438 var len _Socklen = SizeofSockaddrAny
439 nfd, err = accept(fd, &rsa, &len)
440 if err != nil {
441 return
442 }
443 sa, err = anyToSockaddr(&rsa)
444 if err != nil {
445 Close(nfd)
446 nfd = 0
447 }
448 return
449 }
450
451 func Accept4(fd int, flags int) (nfd int, sa Sockaddr, err error) {
452 var rsa RawSockaddrAny
453 var len _Socklen = SizeofSockaddrAny
454 nfd, err = accept4(fd, &rsa, &len, flags)
455 if err != nil {
456 return
457 }
458 if len > SizeofSockaddrAny {
459 panic("RawSockaddrAny too small")
460 }
461 sa, err = anyToSockaddr(&rsa)
462 if err != nil {
463 Close(nfd)
464 nfd = 0
465 }
466 return
467 }
468
469 func Getsockname(fd int) (sa Sockaddr, err error) {
470 var rsa RawSockaddrAny
471 var len _Socklen = SizeofSockaddrAny
472 if err = getsockname(fd, &rsa, &len); err != nil {
473 return
474 }
475 return anyToSockaddr(&rsa)
476 }
477
478 func GetsockoptInet4Addr(fd, level, opt int) (value [4]byte, err error) {
479 vallen := _Socklen(4)
480 err = getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
481 return value, err
482 }
483
484 func GetsockoptIPMreq(fd, level, opt int) (*IPMreq, error) {
485 var value IPMreq
486 vallen := _Socklen(SizeofIPMreq)
487 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
488 return &value, err
489 }
490
491 func GetsockoptIPMreqn(fd, level, opt int) (*IPMreqn, error) {
492 var value IPMreqn
493 vallen := _Socklen(SizeofIPMreqn)
494 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
495 return &value, err
496 }
497
498 func GetsockoptIPv6Mreq(fd, level, opt int) (*IPv6Mreq, error) {
499 var value IPv6Mreq
500 vallen := _Socklen(SizeofIPv6Mreq)
501 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
502 return &value, err
503 }
504
505 func GetsockoptIPv6MTUInfo(fd, level, opt int) (*IPv6MTUInfo, error) {
506 var value IPv6MTUInfo
507 vallen := _Socklen(SizeofIPv6MTUInfo)
508 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
509 return &value, err
510 }
511
512 func GetsockoptICMPv6Filter(fd, level, opt int) (*ICMPv6Filter, error) {
513 var value ICMPv6Filter
514 vallen := _Socklen(SizeofICMPv6Filter)
515 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
516 return &value, err
517 }
518
519 func GetsockoptUcred(fd, level, opt int) (*Ucred, error) {
520 var value Ucred
521 vallen := _Socklen(SizeofUcred)
522 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
523 return &value, err
524 }
525
526 func SetsockoptIPMreqn(fd, level, opt int, mreq *IPMreqn) (err error) {
527 return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq))
528 }
529
530 func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) {
531 var msg Msghdr
532 var rsa RawSockaddrAny
533 msg.Name = (*byte)(unsafe.Pointer(&rsa))
534 msg.Namelen = uint32(SizeofSockaddrAny)
535 var iov Iovec
536 if len(p) > 0 {
537 iov.Base = &p[0]
538 iov.SetLen(len(p))
539 }
540 var dummy byte
541 if len(oob) > 0 {
542 var sockType int
543 sockType, err = GetsockoptInt(fd, SOL_SOCKET, SO_TYPE)
544 if err != nil {
545 return
546 }
547
548 if sockType != SOCK_DGRAM && len(p) == 0 {
549 iov.Base = &dummy
550 iov.SetLen(1)
551 }
552 msg.Control = &oob[0]
553 msg.SetControllen(len(oob))
554 }
555 msg.Iov = &iov
556 msg.Iovlen = 1
557 if n, err = recvmsg(fd, &msg, flags); err != nil {
558 return
559 }
560 oobn = int(msg.Controllen)
561 recvflags = int(msg.Flags)
562
563 if rsa.Addr.Family != AF_UNSPEC {
564 from, err = anyToSockaddr(&rsa)
565 }
566 return
567 }
568
569 func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) {
570 _, err = SendmsgN(fd, p, oob, to, flags)
571 return
572 }
573
574 func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) {
575 var ptr unsafe.Pointer
576 var salen _Socklen
577 if to != nil {
578 var err error
579 ptr, salen, err = to.sockaddr()
580 if err != nil {
581 return 0, err
582 }
583 }
584 var msg Msghdr
585 msg.Name = (*byte)(ptr)
586 msg.Namelen = uint32(salen)
587 var iov Iovec
588 if len(p) > 0 {
589 iov.Base = &p[0]
590 iov.SetLen(len(p))
591 }
592 var dummy byte
593 if len(oob) > 0 {
594 var sockType int
595 sockType, err = GetsockoptInt(fd, SOL_SOCKET, SO_TYPE)
596 if err != nil {
597 return 0, err
598 }
599
600 if sockType != SOCK_DGRAM && len(p) == 0 {
601 iov.Base = &dummy
602 iov.SetLen(1)
603 }
604 msg.Control = &oob[0]
605 msg.SetControllen(len(oob))
606 }
607 msg.Iov = &iov
608 msg.Iovlen = 1
609 if n, err = sendmsg(fd, &msg, flags); err != nil {
610 return 0, err
611 }
612 if len(oob) > 0 && len(p) == 0 {
613 n = 0
614 }
615 return n, nil
616 }
617
618
619 func BindToDevice(fd int, device string) (err error) {
620 return SetsockoptString(fd, SOL_SOCKET, SO_BINDTODEVICE, device)
621 }
622
623
624
625 func ptracePeek(req int, pid int, addr uintptr, out []byte) (count int, err error) {
626
627
628
629
630
631
632 var buf [sizeofPtr]byte
633
634
635
636
637
638
639 n := 0
640 if addr%sizeofPtr != 0 {
641 err = ptrace(req, pid, addr-addr%sizeofPtr, uintptr(unsafe.Pointer(&buf[0])))
642 if err != nil {
643 return 0, err
644 }
645 n += copy(out, buf[addr%sizeofPtr:])
646 out = out[n:]
647 }
648
649
650 for len(out) > 0 {
651
652
653 err = ptrace(req, pid, addr+uintptr(n), uintptr(unsafe.Pointer(&buf[0])))
654 if err != nil {
655 return n, err
656 }
657 copied := copy(out, buf[0:])
658 n += copied
659 out = out[copied:]
660 }
661
662 return n, nil
663 }
664
665 func PtracePeekText(pid int, addr uintptr, out []byte) (count int, err error) {
666 return ptracePeek(PTRACE_PEEKTEXT, pid, addr, out)
667 }
668
669 func PtracePeekData(pid int, addr uintptr, out []byte) (count int, err error) {
670 return ptracePeek(PTRACE_PEEKDATA, pid, addr, out)
671 }
672
673 func ptracePoke(pokeReq int, peekReq int, pid int, addr uintptr, data []byte) (count int, err error) {
674
675
676
677
678 n := 0
679 if addr%sizeofPtr != 0 {
680 var buf [sizeofPtr]byte
681 err = ptrace(peekReq, pid, addr-addr%sizeofPtr, uintptr(unsafe.Pointer(&buf[0])))
682 if err != nil {
683 return 0, err
684 }
685 n += copy(buf[addr%sizeofPtr:], data)
686 word := *((*uintptr)(unsafe.Pointer(&buf[0])))
687 err = ptrace(pokeReq, pid, addr-addr%sizeofPtr, word)
688 if err != nil {
689 return 0, err
690 }
691 data = data[n:]
692 }
693
694
695 for len(data) > sizeofPtr {
696 word := *((*uintptr)(unsafe.Pointer(&data[0])))
697 err = ptrace(pokeReq, pid, addr+uintptr(n), word)
698 if err != nil {
699 return n, err
700 }
701 n += sizeofPtr
702 data = data[sizeofPtr:]
703 }
704
705
706 if len(data) > 0 {
707 var buf [sizeofPtr]byte
708 err = ptrace(peekReq, pid, addr+uintptr(n), uintptr(unsafe.Pointer(&buf[0])))
709 if err != nil {
710 return n, err
711 }
712 copy(buf[0:], data)
713 word := *((*uintptr)(unsafe.Pointer(&buf[0])))
714 err = ptrace(pokeReq, pid, addr+uintptr(n), word)
715 if err != nil {
716 return n, err
717 }
718 n += len(data)
719 }
720
721 return n, nil
722 }
723
724 func PtracePokeText(pid int, addr uintptr, data []byte) (count int, err error) {
725 return ptracePoke(PTRACE_POKETEXT, PTRACE_PEEKTEXT, pid, addr, data)
726 }
727
728 func PtracePokeData(pid int, addr uintptr, data []byte) (count int, err error) {
729 return ptracePoke(PTRACE_POKEDATA, PTRACE_PEEKDATA, pid, addr, data)
730 }
731
732 func PtraceGetRegs(pid int, regsout *PtraceRegs) (err error) {
733 return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout)))
734 }
735
736 func PtraceSetRegs(pid int, regs *PtraceRegs) (err error) {
737 return ptrace(PTRACE_SETREGS, pid, 0, uintptr(unsafe.Pointer(regs)))
738 }
739
740 func PtraceSetOptions(pid int, options int) (err error) {
741 return ptrace(PTRACE_SETOPTIONS, pid, 0, uintptr(options))
742 }
743
744 func PtraceGetEventMsg(pid int) (msg uint, err error) {
745 var data _C_long
746 err = ptrace(PTRACE_GETEVENTMSG, pid, 0, uintptr(unsafe.Pointer(&data)))
747 msg = uint(data)
748 return
749 }
750
751 func PtraceCont(pid int, signal int) (err error) {
752 return ptrace(PTRACE_CONT, pid, 0, uintptr(signal))
753 }
754
755 func PtraceSyscall(pid int, signal int) (err error) {
756 return ptrace(PTRACE_SYSCALL, pid, 0, uintptr(signal))
757 }
758
759 func PtraceSingleStep(pid int) (err error) { return ptrace(PTRACE_SINGLESTEP, pid, 0, 0) }
760
761 func PtraceAttach(pid int) (err error) { return ptrace(PTRACE_ATTACH, pid, 0, 0) }
762
763 func PtraceDetach(pid int) (err error) { return ptrace(PTRACE_DETACH, pid, 0, 0) }
764
765
766
767 func Reboot(cmd int) (err error) {
768 return reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, cmd, "")
769 }
770
771 func ReadDirent(fd int, buf []byte) (n int, err error) {
772 return Getdents(fd, buf)
773 }
774
775 func direntIno(buf []byte) (uint64, bool) {
776 return readInt(buf, unsafe.Offsetof(Dirent{}.Ino), unsafe.Sizeof(Dirent{}.Ino))
777 }
778
779 func direntReclen(buf []byte) (uint64, bool) {
780 return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen))
781 }
782
783 func direntNamlen(buf []byte) (uint64, bool) {
784 reclen, ok := direntReclen(buf)
785 if !ok {
786 return 0, false
787 }
788 return reclen - uint64(unsafe.Offsetof(Dirent{}.Name)), true
789 }
790
791
792
793 func Mount(source string, target string, fstype string, flags uintptr, data string) (err error) {
794
795
796 if data == "" {
797 return mount(source, target, fstype, flags, nil)
798 }
799 datap, err := BytePtrFromString(data)
800 if err != nil {
801 return err
802 }
803 return mount(source, target, fstype, flags, datap)
804 }
805
806
807
808
809
810
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837 func Getpgrp() (pid int) {
838 pid, _ = Getpgid(0)
839 return
840 }
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874 func Setuid(uid int) (err error) {
875 return EOPNOTSUPP
876 }
877
878 func Setgid(gid int) (err error) {
879 return EOPNOTSUPP
880 }
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903 var mapper = &mmapper{
904 active: make(map[*byte][]byte),
905 mmap: mmap,
906 munmap: munmap,
907 }
908
909 func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) {
910 return mapper.Mmap(fd, offset, length, prot, flags)
911 }
912
913 func Munmap(b []byte) (err error) {
914 return mapper.Munmap(b)
915 }
916
917
918
919
920
921
922
923
924
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
View as plain text