Source file src/pkg/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
1
2
3
4
5
6 package unix
7
8 import (
9 "syscall"
10 "unsafe"
11 )
12
13 var _ syscall.Errno
14
15
16
17 func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
18 r0, _, e1 := syscall_rawSyscall(funcPC(libc_getgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
19 n = int(r0)
20 if e1 != 0 {
21 err = errnoErr(e1)
22 }
23 return
24 }
25
26 func libc_getgroups_trampoline()
27
28
29
30
31
32
33 func setgroups(ngid int, gid *_Gid_t) (err error) {
34 _, _, e1 := syscall_rawSyscall(funcPC(libc_setgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
35 if e1 != 0 {
36 err = errnoErr(e1)
37 }
38 return
39 }
40
41 func libc_setgroups_trampoline()
42
43
44
45
46
47
48 func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) {
49 r0, _, e1 := syscall_syscall6(funcPC(libc_wait4_trampoline), uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
50 wpid = int(r0)
51 if e1 != 0 {
52 err = errnoErr(e1)
53 }
54 return
55 }
56
57 func libc_wait4_trampoline()
58
59
60
61
62
63
64 func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
65 r0, _, e1 := syscall_syscall(funcPC(libc_accept_trampoline), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
66 fd = int(r0)
67 if e1 != 0 {
68 err = errnoErr(e1)
69 }
70 return
71 }
72
73 func libc_accept_trampoline()
74
75
76
77
78
79
80 func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
81 _, _, e1 := syscall_syscall(funcPC(libc_bind_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
82 if e1 != 0 {
83 err = errnoErr(e1)
84 }
85 return
86 }
87
88 func libc_bind_trampoline()
89
90
91
92
93
94
95 func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
96 _, _, e1 := syscall_syscall(funcPC(libc_connect_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
97 if e1 != 0 {
98 err = errnoErr(e1)
99 }
100 return
101 }
102
103 func libc_connect_trampoline()
104
105
106
107
108
109
110 func socket(domain int, typ int, proto int) (fd int, err error) {
111 r0, _, e1 := syscall_rawSyscall(funcPC(libc_socket_trampoline), uintptr(domain), uintptr(typ), uintptr(proto))
112 fd = int(r0)
113 if e1 != 0 {
114 err = errnoErr(e1)
115 }
116 return
117 }
118
119 func libc_socket_trampoline()
120
121
122
123
124
125
126 func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
127 _, _, e1 := syscall_syscall6(funcPC(libc_getsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
128 if e1 != 0 {
129 err = errnoErr(e1)
130 }
131 return
132 }
133
134 func libc_getsockopt_trampoline()
135
136
137
138
139
140
141 func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
142 _, _, e1 := syscall_syscall6(funcPC(libc_setsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
143 if e1 != 0 {
144 err = errnoErr(e1)
145 }
146 return
147 }
148
149 func libc_setsockopt_trampoline()
150
151
152
153
154
155
156 func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
157 _, _, e1 := syscall_rawSyscall(funcPC(libc_getpeername_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
158 if e1 != 0 {
159 err = errnoErr(e1)
160 }
161 return
162 }
163
164 func libc_getpeername_trampoline()
165
166
167
168
169
170
171 func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
172 _, _, e1 := syscall_rawSyscall(funcPC(libc_getsockname_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
173 if e1 != 0 {
174 err = errnoErr(e1)
175 }
176 return
177 }
178
179 func libc_getsockname_trampoline()
180
181
182
183
184
185
186 func Shutdown(s int, how int) (err error) {
187 _, _, e1 := syscall_syscall(funcPC(libc_shutdown_trampoline), uintptr(s), uintptr(how), 0)
188 if e1 != 0 {
189 err = errnoErr(e1)
190 }
191 return
192 }
193
194 func libc_shutdown_trampoline()
195
196
197
198
199
200
201 func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
202 _, _, e1 := syscall_rawSyscall6(funcPC(libc_socketpair_trampoline), uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
203 if e1 != 0 {
204 err = errnoErr(e1)
205 }
206 return
207 }
208
209 func libc_socketpair_trampoline()
210
211
212
213
214
215
216 func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) {
217 var _p0 unsafe.Pointer
218 if len(p) > 0 {
219 _p0 = unsafe.Pointer(&p[0])
220 } else {
221 _p0 = unsafe.Pointer(&_zero)
222 }
223 r0, _, e1 := syscall_syscall6(funcPC(libc_recvfrom_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
224 n = int(r0)
225 if e1 != 0 {
226 err = errnoErr(e1)
227 }
228 return
229 }
230
231 func libc_recvfrom_trampoline()
232
233
234
235
236
237
238 func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
239 var _p0 unsafe.Pointer
240 if len(buf) > 0 {
241 _p0 = unsafe.Pointer(&buf[0])
242 } else {
243 _p0 = unsafe.Pointer(&_zero)
244 }
245 _, _, e1 := syscall_syscall6(funcPC(libc_sendto_trampoline), uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
246 if e1 != 0 {
247 err = errnoErr(e1)
248 }
249 return
250 }
251
252 func libc_sendto_trampoline()
253
254
255
256
257
258
259 func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
260 r0, _, e1 := syscall_syscall(funcPC(libc_recvmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
261 n = int(r0)
262 if e1 != 0 {
263 err = errnoErr(e1)
264 }
265 return
266 }
267
268 func libc_recvmsg_trampoline()
269
270
271
272
273
274
275 func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
276 r0, _, e1 := syscall_syscall(funcPC(libc_sendmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
277 n = int(r0)
278 if e1 != 0 {
279 err = errnoErr(e1)
280 }
281 return
282 }
283
284 func libc_sendmsg_trampoline()
285
286
287
288
289
290
291 func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
292 r0, _, e1 := syscall_syscall6(funcPC(libc_kevent_trampoline), uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
293 n = int(r0)
294 if e1 != 0 {
295 err = errnoErr(e1)
296 }
297 return
298 }
299
300 func libc_kevent_trampoline()
301
302
303
304
305
306
307 func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) {
308 var _p0 unsafe.Pointer
309 if len(mib) > 0 {
310 _p0 = unsafe.Pointer(&mib[0])
311 } else {
312 _p0 = unsafe.Pointer(&_zero)
313 }
314 _, _, e1 := syscall_syscall6(funcPC(libc___sysctl_trampoline), uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
315 if e1 != 0 {
316 err = errnoErr(e1)
317 }
318 return
319 }
320
321 func libc___sysctl_trampoline()
322
323
324
325
326
327
328 func utimes(path string, timeval *[2]Timeval) (err error) {
329 var _p0 *byte
330 _p0, err = BytePtrFromString(path)
331 if err != nil {
332 return
333 }
334 _, _, e1 := syscall_syscall(funcPC(libc_utimes_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
335 if e1 != 0 {
336 err = errnoErr(e1)
337 }
338 return
339 }
340
341 func libc_utimes_trampoline()
342
343
344
345
346
347
348 func futimes(fd int, timeval *[2]Timeval) (err error) {
349 _, _, e1 := syscall_syscall(funcPC(libc_futimes_trampoline), uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
350 if e1 != 0 {
351 err = errnoErr(e1)
352 }
353 return
354 }
355
356 func libc_futimes_trampoline()
357
358
359
360
361
362
363 func fcntl(fd int, cmd int, arg int) (val int, err error) {
364 r0, _, e1 := syscall_syscall(funcPC(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
365 val = int(r0)
366 if e1 != 0 {
367 err = errnoErr(e1)
368 }
369 return
370 }
371
372 func libc_fcntl_trampoline()
373
374
375
376
377
378
379 func poll(fds *PollFd, nfds int, timeout int) (n int, err error) {
380 r0, _, e1 := syscall_syscall(funcPC(libc_poll_trampoline), uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout))
381 n = int(r0)
382 if e1 != 0 {
383 err = errnoErr(e1)
384 }
385 return
386 }
387
388 func libc_poll_trampoline()
389
390
391
392
393
394
395 func Madvise(b []byte, behav int) (err error) {
396 var _p0 unsafe.Pointer
397 if len(b) > 0 {
398 _p0 = unsafe.Pointer(&b[0])
399 } else {
400 _p0 = unsafe.Pointer(&_zero)
401 }
402 _, _, e1 := syscall_syscall(funcPC(libc_madvise_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(behav))
403 if e1 != 0 {
404 err = errnoErr(e1)
405 }
406 return
407 }
408
409 func libc_madvise_trampoline()
410
411
412
413
414
415
416 func Mlock(b []byte) (err error) {
417 var _p0 unsafe.Pointer
418 if len(b) > 0 {
419 _p0 = unsafe.Pointer(&b[0])
420 } else {
421 _p0 = unsafe.Pointer(&_zero)
422 }
423 _, _, e1 := syscall_syscall(funcPC(libc_mlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
424 if e1 != 0 {
425 err = errnoErr(e1)
426 }
427 return
428 }
429
430 func libc_mlock_trampoline()
431
432
433
434
435
436
437 func Mlockall(flags int) (err error) {
438 _, _, e1 := syscall_syscall(funcPC(libc_mlockall_trampoline), uintptr(flags), 0, 0)
439 if e1 != 0 {
440 err = errnoErr(e1)
441 }
442 return
443 }
444
445 func libc_mlockall_trampoline()
446
447
448
449
450
451
452 func Mprotect(b []byte, prot int) (err error) {
453 var _p0 unsafe.Pointer
454 if len(b) > 0 {
455 _p0 = unsafe.Pointer(&b[0])
456 } else {
457 _p0 = unsafe.Pointer(&_zero)
458 }
459 _, _, e1 := syscall_syscall(funcPC(libc_mprotect_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(prot))
460 if e1 != 0 {
461 err = errnoErr(e1)
462 }
463 return
464 }
465
466 func libc_mprotect_trampoline()
467
468
469
470
471
472
473 func Msync(b []byte, flags int) (err error) {
474 var _p0 unsafe.Pointer
475 if len(b) > 0 {
476 _p0 = unsafe.Pointer(&b[0])
477 } else {
478 _p0 = unsafe.Pointer(&_zero)
479 }
480 _, _, e1 := syscall_syscall(funcPC(libc_msync_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(flags))
481 if e1 != 0 {
482 err = errnoErr(e1)
483 }
484 return
485 }
486
487 func libc_msync_trampoline()
488
489
490
491
492
493
494 func Munlock(b []byte) (err error) {
495 var _p0 unsafe.Pointer
496 if len(b) > 0 {
497 _p0 = unsafe.Pointer(&b[0])
498 } else {
499 _p0 = unsafe.Pointer(&_zero)
500 }
501 _, _, e1 := syscall_syscall(funcPC(libc_munlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
502 if e1 != 0 {
503 err = errnoErr(e1)
504 }
505 return
506 }
507
508 func libc_munlock_trampoline()
509
510
511
512
513
514
515 func Munlockall() (err error) {
516 _, _, e1 := syscall_syscall(funcPC(libc_munlockall_trampoline), 0, 0, 0)
517 if e1 != 0 {
518 err = errnoErr(e1)
519 }
520 return
521 }
522
523 func libc_munlockall_trampoline()
524
525
526
527
528
529
530 func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
531 _, _, e1 := syscall_syscall6(funcPC(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
532 if e1 != 0 {
533 err = errnoErr(e1)
534 }
535 return
536 }
537
538 func libc_ptrace_trampoline()
539
540
541
542
543
544
545 func getattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error) {
546 _, _, e1 := syscall_syscall6(funcPC(libc_getattrlist_trampoline), uintptr(unsafe.Pointer(path)), uintptr(list), uintptr(buf), uintptr(size), uintptr(options), 0)
547 if e1 != 0 {
548 err = errnoErr(e1)
549 }
550 return
551 }
552
553 func libc_getattrlist_trampoline()
554
555
556
557
558
559
560 func pipe() (r int, w int, err error) {
561 r0, r1, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), 0, 0, 0)
562 r = int(r0)
563 w = int(r1)
564 if e1 != 0 {
565 err = errnoErr(e1)
566 }
567 return
568 }
569
570 func libc_pipe_trampoline()
571
572
573
574
575
576
577 func getxattr(path string, attr string, dest *byte, size int, position uint32, options int) (sz int, err error) {
578 var _p0 *byte
579 _p0, err = BytePtrFromString(path)
580 if err != nil {
581 return
582 }
583 var _p1 *byte
584 _p1, err = BytePtrFromString(attr)
585 if err != nil {
586 return
587 }
588 r0, _, e1 := syscall_syscall6(funcPC(libc_getxattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
589 sz = int(r0)
590 if e1 != 0 {
591 err = errnoErr(e1)
592 }
593 return
594 }
595
596 func libc_getxattr_trampoline()
597
598
599
600
601
602
603 func fgetxattr(fd int, attr string, dest *byte, size int, position uint32, options int) (sz int, err error) {
604 var _p0 *byte
605 _p0, err = BytePtrFromString(attr)
606 if err != nil {
607 return
608 }
609 r0, _, e1 := syscall_syscall6(funcPC(libc_fgetxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
610 sz = int(r0)
611 if e1 != 0 {
612 err = errnoErr(e1)
613 }
614 return
615 }
616
617 func libc_fgetxattr_trampoline()
618
619
620
621
622
623
624 func setxattr(path string, attr string, data *byte, size int, position uint32, options int) (err error) {
625 var _p0 *byte
626 _p0, err = BytePtrFromString(path)
627 if err != nil {
628 return
629 }
630 var _p1 *byte
631 _p1, err = BytePtrFromString(attr)
632 if err != nil {
633 return
634 }
635 _, _, e1 := syscall_syscall6(funcPC(libc_setxattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
636 if e1 != 0 {
637 err = errnoErr(e1)
638 }
639 return
640 }
641
642 func libc_setxattr_trampoline()
643
644
645
646
647
648
649 func fsetxattr(fd int, attr string, data *byte, size int, position uint32, options int) (err error) {
650 var _p0 *byte
651 _p0, err = BytePtrFromString(attr)
652 if err != nil {
653 return
654 }
655 _, _, e1 := syscall_syscall6(funcPC(libc_fsetxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
656 if e1 != 0 {
657 err = errnoErr(e1)
658 }
659 return
660 }
661
662 func libc_fsetxattr_trampoline()
663
664
665
666
667
668
669 func removexattr(path string, attr string, options int) (err error) {
670 var _p0 *byte
671 _p0, err = BytePtrFromString(path)
672 if err != nil {
673 return
674 }
675 var _p1 *byte
676 _p1, err = BytePtrFromString(attr)
677 if err != nil {
678 return
679 }
680 _, _, e1 := syscall_syscall(funcPC(libc_removexattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
681 if e1 != 0 {
682 err = errnoErr(e1)
683 }
684 return
685 }
686
687 func libc_removexattr_trampoline()
688
689
690
691
692
693
694 func fremovexattr(fd int, attr string, options int) (err error) {
695 var _p0 *byte
696 _p0, err = BytePtrFromString(attr)
697 if err != nil {
698 return
699 }
700 _, _, e1 := syscall_syscall(funcPC(libc_fremovexattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(options))
701 if e1 != 0 {
702 err = errnoErr(e1)
703 }
704 return
705 }
706
707 func libc_fremovexattr_trampoline()
708
709
710
711
712
713
714 func listxattr(path string, dest *byte, size int, options int) (sz int, err error) {
715 var _p0 *byte
716 _p0, err = BytePtrFromString(path)
717 if err != nil {
718 return
719 }
720 r0, _, e1 := syscall_syscall6(funcPC(libc_listxattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
721 sz = int(r0)
722 if e1 != 0 {
723 err = errnoErr(e1)
724 }
725 return
726 }
727
728 func libc_listxattr_trampoline()
729
730
731
732
733
734
735 func flistxattr(fd int, dest *byte, size int, options int) (sz int, err error) {
736 r0, _, e1 := syscall_syscall6(funcPC(libc_flistxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
737 sz = int(r0)
738 if e1 != 0 {
739 err = errnoErr(e1)
740 }
741 return
742 }
743
744 func libc_flistxattr_trampoline()
745
746
747
748
749
750
751 func setattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error) {
752 _, _, e1 := syscall_syscall6(funcPC(libc_setattrlist_trampoline), uintptr(unsafe.Pointer(path)), uintptr(list), uintptr(buf), uintptr(size), uintptr(options), 0)
753 if e1 != 0 {
754 err = errnoErr(e1)
755 }
756 return
757 }
758
759 func libc_setattrlist_trampoline()
760
761
762
763
764
765
766 func kill(pid int, signum int, posix int) (err error) {
767 _, _, e1 := syscall_syscall(funcPC(libc_kill_trampoline), uintptr(pid), uintptr(signum), uintptr(posix))
768 if e1 != 0 {
769 err = errnoErr(e1)
770 }
771 return
772 }
773
774 func libc_kill_trampoline()
775
776
777
778
779
780
781 func ioctl(fd int, req uint, arg uintptr) (err error) {
782 _, _, e1 := syscall_syscall(funcPC(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
783 if e1 != 0 {
784 err = errnoErr(e1)
785 }
786 return
787 }
788
789 func libc_ioctl_trampoline()
790
791
792
793
794
795
796 func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) {
797 _, _, e1 := syscall_syscall6(funcPC(libc_sendfile_trampoline), uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags))
798 if e1 != 0 {
799 err = errnoErr(e1)
800 }
801 return
802 }
803
804 func libc_sendfile_trampoline()
805
806
807
808
809
810
811 func Access(path string, mode uint32) (err error) {
812 var _p0 *byte
813 _p0, err = BytePtrFromString(path)
814 if err != nil {
815 return
816 }
817 _, _, e1 := syscall_syscall(funcPC(libc_access_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
818 if e1 != 0 {
819 err = errnoErr(e1)
820 }
821 return
822 }
823
824 func libc_access_trampoline()
825
826
827
828
829
830
831 func Adjtime(delta *Timeval, olddelta *Timeval) (err error) {
832 _, _, e1 := syscall_syscall(funcPC(libc_adjtime_trampoline), uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
833 if e1 != 0 {
834 err = errnoErr(e1)
835 }
836 return
837 }
838
839 func libc_adjtime_trampoline()
840
841
842
843
844
845
846 func Chdir(path string) (err error) {
847 var _p0 *byte
848 _p0, err = BytePtrFromString(path)
849 if err != nil {
850 return
851 }
852 _, _, e1 := syscall_syscall(funcPC(libc_chdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
853 if e1 != 0 {
854 err = errnoErr(e1)
855 }
856 return
857 }
858
859 func libc_chdir_trampoline()
860
861
862
863
864
865
866 func Chflags(path string, flags int) (err error) {
867 var _p0 *byte
868 _p0, err = BytePtrFromString(path)
869 if err != nil {
870 return
871 }
872 _, _, e1 := syscall_syscall(funcPC(libc_chflags_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
873 if e1 != 0 {
874 err = errnoErr(e1)
875 }
876 return
877 }
878
879 func libc_chflags_trampoline()
880
881
882
883
884
885
886 func Chmod(path string, mode uint32) (err error) {
887 var _p0 *byte
888 _p0, err = BytePtrFromString(path)
889 if err != nil {
890 return
891 }
892 _, _, e1 := syscall_syscall(funcPC(libc_chmod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
893 if e1 != 0 {
894 err = errnoErr(e1)
895 }
896 return
897 }
898
899 func libc_chmod_trampoline()
900
901
902
903
904
905
906 func Chown(path string, uid int, gid int) (err error) {
907 var _p0 *byte
908 _p0, err = BytePtrFromString(path)
909 if err != nil {
910 return
911 }
912 _, _, e1 := syscall_syscall(funcPC(libc_chown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
913 if e1 != 0 {
914 err = errnoErr(e1)
915 }
916 return
917 }
918
919 func libc_chown_trampoline()
920
921
922
923
924
925
926 func Chroot(path string) (err error) {
927 var _p0 *byte
928 _p0, err = BytePtrFromString(path)
929 if err != nil {
930 return
931 }
932 _, _, e1 := syscall_syscall(funcPC(libc_chroot_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
933 if e1 != 0 {
934 err = errnoErr(e1)
935 }
936 return
937 }
938
939 func libc_chroot_trampoline()
940
941
942
943
944
945
946 func ClockGettime(clockid int32, time *Timespec) (err error) {
947 _, _, e1 := syscall_syscall(funcPC(libc_clock_gettime_trampoline), uintptr(clockid), uintptr(unsafe.Pointer(time)), 0)
948 if e1 != 0 {
949 err = errnoErr(e1)
950 }
951 return
952 }
953
954 func libc_clock_gettime_trampoline()
955
956
957
958
959
960
961 func Close(fd int) (err error) {
962 _, _, e1 := syscall_syscall(funcPC(libc_close_trampoline), uintptr(fd), 0, 0)
963 if e1 != 0 {
964 err = errnoErr(e1)
965 }
966 return
967 }
968
969 func libc_close_trampoline()
970
971
972
973
974
975
976 func Dup(fd int) (nfd int, err error) {
977 r0, _, e1 := syscall_syscall(funcPC(libc_dup_trampoline), uintptr(fd), 0, 0)
978 nfd = int(r0)
979 if e1 != 0 {
980 err = errnoErr(e1)
981 }
982 return
983 }
984
985 func libc_dup_trampoline()
986
987
988
989
990
991
992 func Dup2(from int, to int) (err error) {
993 _, _, e1 := syscall_syscall(funcPC(libc_dup2_trampoline), uintptr(from), uintptr(to), 0)
994 if e1 != 0 {
995 err = errnoErr(e1)
996 }
997 return
998 }
999
1000 func libc_dup2_trampoline()
1001
1002
1003
1004
1005
1006
1007 func Exchangedata(path1 string, path2 string, options int) (err error) {
1008 var _p0 *byte
1009 _p0, err = BytePtrFromString(path1)
1010 if err != nil {
1011 return
1012 }
1013 var _p1 *byte
1014 _p1, err = BytePtrFromString(path2)
1015 if err != nil {
1016 return
1017 }
1018 _, _, e1 := syscall_syscall(funcPC(libc_exchangedata_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
1019 if e1 != 0 {
1020 err = errnoErr(e1)
1021 }
1022 return
1023 }
1024
1025 func libc_exchangedata_trampoline()
1026
1027
1028
1029
1030
1031
1032 func Exit(code int) {
1033 syscall_syscall(funcPC(libc_exit_trampoline), uintptr(code), 0, 0)
1034 return
1035 }
1036
1037 func libc_exit_trampoline()
1038
1039
1040
1041
1042
1043
1044 func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
1045 var _p0 *byte
1046 _p0, err = BytePtrFromString(path)
1047 if err != nil {
1048 return
1049 }
1050 _, _, e1 := syscall_syscall6(funcPC(libc_faccessat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
1051 if e1 != 0 {
1052 err = errnoErr(e1)
1053 }
1054 return
1055 }
1056
1057 func libc_faccessat_trampoline()
1058
1059
1060
1061
1062
1063
1064 func Fchdir(fd int) (err error) {
1065 _, _, e1 := syscall_syscall(funcPC(libc_fchdir_trampoline), uintptr(fd), 0, 0)
1066 if e1 != 0 {
1067 err = errnoErr(e1)
1068 }
1069 return
1070 }
1071
1072 func libc_fchdir_trampoline()
1073
1074
1075
1076
1077
1078
1079 func Fchflags(fd int, flags int) (err error) {
1080 _, _, e1 := syscall_syscall(funcPC(libc_fchflags_trampoline), uintptr(fd), uintptr(flags), 0)
1081 if e1 != 0 {
1082 err = errnoErr(e1)
1083 }
1084 return
1085 }
1086
1087 func libc_fchflags_trampoline()
1088
1089
1090
1091
1092
1093
1094 func Fchmod(fd int, mode uint32) (err error) {
1095 _, _, e1 := syscall_syscall(funcPC(libc_fchmod_trampoline), uintptr(fd), uintptr(mode), 0)
1096 if e1 != 0 {
1097 err = errnoErr(e1)
1098 }
1099 return
1100 }
1101
1102 func libc_fchmod_trampoline()
1103
1104
1105
1106
1107
1108
1109 func Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) {
1110 var _p0 *byte
1111 _p0, err = BytePtrFromString(path)
1112 if err != nil {
1113 return
1114 }
1115 _, _, e1 := syscall_syscall6(funcPC(libc_fchmodat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
1116 if e1 != 0 {
1117 err = errnoErr(e1)
1118 }
1119 return
1120 }
1121
1122 func libc_fchmodat_trampoline()
1123
1124
1125
1126
1127
1128
1129 func Fchown(fd int, uid int, gid int) (err error) {
1130 _, _, e1 := syscall_syscall(funcPC(libc_fchown_trampoline), uintptr(fd), uintptr(uid), uintptr(gid))
1131 if e1 != 0 {
1132 err = errnoErr(e1)
1133 }
1134 return
1135 }
1136
1137 func libc_fchown_trampoline()
1138
1139
1140
1141
1142
1143
1144 func Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error) {
1145 var _p0 *byte
1146 _p0, err = BytePtrFromString(path)
1147 if err != nil {
1148 return
1149 }
1150 _, _, e1 := syscall_syscall6(funcPC(libc_fchownat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
1151 if e1 != 0 {
1152 err = errnoErr(e1)
1153 }
1154 return
1155 }
1156
1157 func libc_fchownat_trampoline()
1158
1159
1160
1161
1162
1163
1164 func Flock(fd int, how int) (err error) {
1165 _, _, e1 := syscall_syscall(funcPC(libc_flock_trampoline), uintptr(fd), uintptr(how), 0)
1166 if e1 != 0 {
1167 err = errnoErr(e1)
1168 }
1169 return
1170 }
1171
1172 func libc_flock_trampoline()
1173
1174
1175
1176
1177
1178
1179 func Fpathconf(fd int, name int) (val int, err error) {
1180 r0, _, e1 := syscall_syscall(funcPC(libc_fpathconf_trampoline), uintptr(fd), uintptr(name), 0)
1181 val = int(r0)
1182 if e1 != 0 {
1183 err = errnoErr(e1)
1184 }
1185 return
1186 }
1187
1188 func libc_fpathconf_trampoline()
1189
1190
1191
1192
1193
1194
1195 func Fsync(fd int) (err error) {
1196 _, _, e1 := syscall_syscall(funcPC(libc_fsync_trampoline), uintptr(fd), 0, 0)
1197 if e1 != 0 {
1198 err = errnoErr(e1)
1199 }
1200 return
1201 }
1202
1203 func libc_fsync_trampoline()
1204
1205
1206
1207
1208
1209
1210 func Ftruncate(fd int, length int64) (err error) {
1211 _, _, e1 := syscall_syscall(funcPC(libc_ftruncate_trampoline), uintptr(fd), uintptr(length), 0)
1212 if e1 != 0 {
1213 err = errnoErr(e1)
1214 }
1215 return
1216 }
1217
1218 func libc_ftruncate_trampoline()
1219
1220
1221
1222
1223
1224
1225 func Getdtablesize() (size int) {
1226 r0, _, _ := syscall_syscall(funcPC(libc_getdtablesize_trampoline), 0, 0, 0)
1227 size = int(r0)
1228 return
1229 }
1230
1231 func libc_getdtablesize_trampoline()
1232
1233
1234
1235
1236
1237
1238 func Getegid() (egid int) {
1239 r0, _, _ := syscall_rawSyscall(funcPC(libc_getegid_trampoline), 0, 0, 0)
1240 egid = int(r0)
1241 return
1242 }
1243
1244 func libc_getegid_trampoline()
1245
1246
1247
1248
1249
1250
1251 func Geteuid() (uid int) {
1252 r0, _, _ := syscall_rawSyscall(funcPC(libc_geteuid_trampoline), 0, 0, 0)
1253 uid = int(r0)
1254 return
1255 }
1256
1257 func libc_geteuid_trampoline()
1258
1259
1260
1261
1262
1263
1264 func Getgid() (gid int) {
1265 r0, _, _ := syscall_rawSyscall(funcPC(libc_getgid_trampoline), 0, 0, 0)
1266 gid = int(r0)
1267 return
1268 }
1269
1270 func libc_getgid_trampoline()
1271
1272
1273
1274
1275
1276
1277 func Getpgid(pid int) (pgid int, err error) {
1278 r0, _, e1 := syscall_rawSyscall(funcPC(libc_getpgid_trampoline), uintptr(pid), 0, 0)
1279 pgid = int(r0)
1280 if e1 != 0 {
1281 err = errnoErr(e1)
1282 }
1283 return
1284 }
1285
1286 func libc_getpgid_trampoline()
1287
1288
1289
1290
1291
1292
1293 func Getpgrp() (pgrp int) {
1294 r0, _, _ := syscall_rawSyscall(funcPC(libc_getpgrp_trampoline), 0, 0, 0)
1295 pgrp = int(r0)
1296 return
1297 }
1298
1299 func libc_getpgrp_trampoline()
1300
1301
1302
1303
1304
1305
1306 func Getpid() (pid int) {
1307 r0, _, _ := syscall_rawSyscall(funcPC(libc_getpid_trampoline), 0, 0, 0)
1308 pid = int(r0)
1309 return
1310 }
1311
1312 func libc_getpid_trampoline()
1313
1314
1315
1316
1317
1318
1319 func Getppid() (ppid int) {
1320 r0, _, _ := syscall_rawSyscall(funcPC(libc_getppid_trampoline), 0, 0, 0)
1321 ppid = int(r0)
1322 return
1323 }
1324
1325 func libc_getppid_trampoline()
1326
1327
1328
1329
1330
1331
1332 func Getpriority(which int, who int) (prio int, err error) {
1333 r0, _, e1 := syscall_syscall(funcPC(libc_getpriority_trampoline), uintptr(which), uintptr(who), 0)
1334 prio = int(r0)
1335 if e1 != 0 {
1336 err = errnoErr(e1)
1337 }
1338 return
1339 }
1340
1341 func libc_getpriority_trampoline()
1342
1343
1344
1345
1346
1347
1348 func Getrlimit(which int, lim *Rlimit) (err error) {
1349 _, _, e1 := syscall_rawSyscall(funcPC(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
1350 if e1 != 0 {
1351 err = errnoErr(e1)
1352 }
1353 return
1354 }
1355
1356 func libc_getrlimit_trampoline()
1357
1358
1359
1360
1361
1362
1363 func Getrusage(who int, rusage *Rusage) (err error) {
1364 _, _, e1 := syscall_rawSyscall(funcPC(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
1365 if e1 != 0 {
1366 err = errnoErr(e1)
1367 }
1368 return
1369 }
1370
1371 func libc_getrusage_trampoline()
1372
1373
1374
1375
1376
1377
1378 func Getsid(pid int) (sid int, err error) {
1379 r0, _, e1 := syscall_rawSyscall(funcPC(libc_getsid_trampoline), uintptr(pid), 0, 0)
1380 sid = int(r0)
1381 if e1 != 0 {
1382 err = errnoErr(e1)
1383 }
1384 return
1385 }
1386
1387 func libc_getsid_trampoline()
1388
1389
1390
1391
1392
1393
1394 func Getuid() (uid int) {
1395 r0, _, _ := syscall_rawSyscall(funcPC(libc_getuid_trampoline), 0, 0, 0)
1396 uid = int(r0)
1397 return
1398 }
1399
1400 func libc_getuid_trampoline()
1401
1402
1403
1404
1405
1406
1407 func Issetugid() (tainted bool) {
1408 r0, _, _ := syscall_rawSyscall(funcPC(libc_issetugid_trampoline), 0, 0, 0)
1409 tainted = bool(r0 != 0)
1410 return
1411 }
1412
1413 func libc_issetugid_trampoline()
1414
1415
1416
1417
1418
1419
1420 func Kqueue() (fd int, err error) {
1421 r0, _, e1 := syscall_syscall(funcPC(libc_kqueue_trampoline), 0, 0, 0)
1422 fd = int(r0)
1423 if e1 != 0 {
1424 err = errnoErr(e1)
1425 }
1426 return
1427 }
1428
1429 func libc_kqueue_trampoline()
1430
1431
1432
1433
1434
1435
1436 func Lchown(path string, uid int, gid int) (err error) {
1437 var _p0 *byte
1438 _p0, err = BytePtrFromString(path)
1439 if err != nil {
1440 return
1441 }
1442 _, _, e1 := syscall_syscall(funcPC(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
1443 if e1 != 0 {
1444 err = errnoErr(e1)
1445 }
1446 return
1447 }
1448
1449 func libc_lchown_trampoline()
1450
1451
1452
1453
1454
1455
1456 func Link(path string, link string) (err error) {
1457 var _p0 *byte
1458 _p0, err = BytePtrFromString(path)
1459 if err != nil {
1460 return
1461 }
1462 var _p1 *byte
1463 _p1, err = BytePtrFromString(link)
1464 if err != nil {
1465 return
1466 }
1467 _, _, e1 := syscall_syscall(funcPC(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
1468 if e1 != 0 {
1469 err = errnoErr(e1)
1470 }
1471 return
1472 }
1473
1474 func libc_link_trampoline()
1475
1476
1477
1478
1479
1480
1481 func Linkat(pathfd int, path string, linkfd int, link string, flags int) (err error) {
1482 var _p0 *byte
1483 _p0, err = BytePtrFromString(path)
1484 if err != nil {
1485 return
1486 }
1487 var _p1 *byte
1488 _p1, err = BytePtrFromString(link)
1489 if err != nil {
1490 return
1491 }
1492 _, _, e1 := syscall_syscall6(funcPC(libc_linkat_trampoline), uintptr(pathfd), uintptr(unsafe.Pointer(_p0)), uintptr(linkfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
1493 if e1 != 0 {
1494 err = errnoErr(e1)
1495 }
1496 return
1497 }
1498
1499 func libc_linkat_trampoline()
1500
1501
1502
1503
1504
1505
1506 func Listen(s int, backlog int) (err error) {
1507 _, _, e1 := syscall_syscall(funcPC(libc_listen_trampoline), uintptr(s), uintptr(backlog), 0)
1508 if e1 != 0 {
1509 err = errnoErr(e1)
1510 }
1511 return
1512 }
1513
1514 func libc_listen_trampoline()
1515
1516
1517
1518
1519
1520
1521 func Mkdir(path string, mode uint32) (err error) {
1522 var _p0 *byte
1523 _p0, err = BytePtrFromString(path)
1524 if err != nil {
1525 return
1526 }
1527 _, _, e1 := syscall_syscall(funcPC(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
1528 if e1 != 0 {
1529 err = errnoErr(e1)
1530 }
1531 return
1532 }
1533
1534 func libc_mkdir_trampoline()
1535
1536
1537
1538
1539
1540
1541 func Mkdirat(dirfd int, path string, mode uint32) (err error) {
1542 var _p0 *byte
1543 _p0, err = BytePtrFromString(path)
1544 if err != nil {
1545 return
1546 }
1547 _, _, e1 := syscall_syscall(funcPC(libc_mkdirat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
1548 if e1 != 0 {
1549 err = errnoErr(e1)
1550 }
1551 return
1552 }
1553
1554 func libc_mkdirat_trampoline()
1555
1556
1557
1558
1559
1560
1561 func Mkfifo(path string, mode uint32) (err error) {
1562 var _p0 *byte
1563 _p0, err = BytePtrFromString(path)
1564 if err != nil {
1565 return
1566 }
1567 _, _, e1 := syscall_syscall(funcPC(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
1568 if e1 != 0 {
1569 err = errnoErr(e1)
1570 }
1571 return
1572 }
1573
1574 func libc_mkfifo_trampoline()
1575
1576
1577
1578
1579
1580
1581 func Mknod(path string, mode uint32, dev int) (err error) {
1582 var _p0 *byte
1583 _p0, err = BytePtrFromString(path)
1584 if err != nil {
1585 return
1586 }
1587 _, _, e1 := syscall_syscall(funcPC(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
1588 if e1 != 0 {
1589 err = errnoErr(e1)
1590 }
1591 return
1592 }
1593
1594 func libc_mknod_trampoline()
1595
1596
1597
1598
1599
1600
1601 func Open(path string, mode int, perm uint32) (fd int, err error) {
1602 var _p0 *byte
1603 _p0, err = BytePtrFromString(path)
1604 if err != nil {
1605 return
1606 }
1607 r0, _, e1 := syscall_syscall(funcPC(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
1608 fd = int(r0)
1609 if e1 != 0 {
1610 err = errnoErr(e1)
1611 }
1612 return
1613 }
1614
1615 func libc_open_trampoline()
1616
1617
1618
1619
1620
1621
1622 func Openat(dirfd int, path string, mode int, perm uint32) (fd int, err error) {
1623 var _p0 *byte
1624 _p0, err = BytePtrFromString(path)
1625 if err != nil {
1626 return
1627 }
1628 r0, _, e1 := syscall_syscall6(funcPC(libc_openat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0)
1629 fd = int(r0)
1630 if e1 != 0 {
1631 err = errnoErr(e1)
1632 }
1633 return
1634 }
1635
1636 func libc_openat_trampoline()
1637
1638
1639
1640
1641
1642
1643 func Pathconf(path string, name int) (val int, err error) {
1644 var _p0 *byte
1645 _p0, err = BytePtrFromString(path)
1646 if err != nil {
1647 return
1648 }
1649 r0, _, e1 := syscall_syscall(funcPC(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
1650 val = int(r0)
1651 if e1 != 0 {
1652 err = errnoErr(e1)
1653 }
1654 return
1655 }
1656
1657 func libc_pathconf_trampoline()
1658
1659
1660
1661
1662
1663
1664 func Pread(fd int, p []byte, offset int64) (n int, err error) {
1665 var _p0 unsafe.Pointer
1666 if len(p) > 0 {
1667 _p0 = unsafe.Pointer(&p[0])
1668 } else {
1669 _p0 = unsafe.Pointer(&_zero)
1670 }
1671 r0, _, e1 := syscall_syscall6(funcPC(libc_pread_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
1672 n = int(r0)
1673 if e1 != 0 {
1674 err = errnoErr(e1)
1675 }
1676 return
1677 }
1678
1679 func libc_pread_trampoline()
1680
1681
1682
1683
1684
1685
1686 func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
1687 var _p0 unsafe.Pointer
1688 if len(p) > 0 {
1689 _p0 = unsafe.Pointer(&p[0])
1690 } else {
1691 _p0 = unsafe.Pointer(&_zero)
1692 }
1693 r0, _, e1 := syscall_syscall6(funcPC(libc_pwrite_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
1694 n = int(r0)
1695 if e1 != 0 {
1696 err = errnoErr(e1)
1697 }
1698 return
1699 }
1700
1701 func libc_pwrite_trampoline()
1702
1703
1704
1705
1706
1707
1708 func read(fd int, p []byte) (n int, err error) {
1709 var _p0 unsafe.Pointer
1710 if len(p) > 0 {
1711 _p0 = unsafe.Pointer(&p[0])
1712 } else {
1713 _p0 = unsafe.Pointer(&_zero)
1714 }
1715 r0, _, e1 := syscall_syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
1716 n = int(r0)
1717 if e1 != 0 {
1718 err = errnoErr(e1)
1719 }
1720 return
1721 }
1722
1723 func libc_read_trampoline()
1724
1725
1726
1727
1728
1729
1730 func Readlink(path string, buf []byte) (n int, err error) {
1731 var _p0 *byte
1732 _p0, err = BytePtrFromString(path)
1733 if err != nil {
1734 return
1735 }
1736 var _p1 unsafe.Pointer
1737 if len(buf) > 0 {
1738 _p1 = unsafe.Pointer(&buf[0])
1739 } else {
1740 _p1 = unsafe.Pointer(&_zero)
1741 }
1742 r0, _, e1 := syscall_syscall(funcPC(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
1743 n = int(r0)
1744 if e1 != 0 {
1745 err = errnoErr(e1)
1746 }
1747 return
1748 }
1749
1750 func libc_readlink_trampoline()
1751
1752
1753
1754
1755
1756
1757 func Readlinkat(dirfd int, path string, buf []byte) (n int, err error) {
1758 var _p0 *byte
1759 _p0, err = BytePtrFromString(path)
1760 if err != nil {
1761 return
1762 }
1763 var _p1 unsafe.Pointer
1764 if len(buf) > 0 {
1765 _p1 = unsafe.Pointer(&buf[0])
1766 } else {
1767 _p1 = unsafe.Pointer(&_zero)
1768 }
1769 r0, _, e1 := syscall_syscall6(funcPC(libc_readlinkat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
1770 n = int(r0)
1771 if e1 != 0 {
1772 err = errnoErr(e1)
1773 }
1774 return
1775 }
1776
1777 func libc_readlinkat_trampoline()
1778
1779
1780
1781
1782
1783
1784 func Rename(from string, to string) (err error) {
1785 var _p0 *byte
1786 _p0, err = BytePtrFromString(from)
1787 if err != nil {
1788 return
1789 }
1790 var _p1 *byte
1791 _p1, err = BytePtrFromString(to)
1792 if err != nil {
1793 return
1794 }
1795 _, _, e1 := syscall_syscall(funcPC(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
1796 if e1 != 0 {
1797 err = errnoErr(e1)
1798 }
1799 return
1800 }
1801
1802 func libc_rename_trampoline()
1803
1804
1805
1806
1807
1808
1809 func Renameat(fromfd int, from string, tofd int, to string) (err error) {
1810 var _p0 *byte
1811 _p0, err = BytePtrFromString(from)
1812 if err != nil {
1813 return
1814 }
1815 var _p1 *byte
1816 _p1, err = BytePtrFromString(to)
1817 if err != nil {
1818 return
1819 }
1820 _, _, e1 := syscall_syscall6(funcPC(libc_renameat_trampoline), uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), 0, 0)
1821 if e1 != 0 {
1822 err = errnoErr(e1)
1823 }
1824 return
1825 }
1826
1827 func libc_renameat_trampoline()
1828
1829
1830
1831
1832
1833
1834 func Revoke(path string) (err error) {
1835 var _p0 *byte
1836 _p0, err = BytePtrFromString(path)
1837 if err != nil {
1838 return
1839 }
1840 _, _, e1 := syscall_syscall(funcPC(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
1841 if e1 != 0 {
1842 err = errnoErr(e1)
1843 }
1844 return
1845 }
1846
1847 func libc_revoke_trampoline()
1848
1849
1850
1851
1852
1853
1854 func Rmdir(path string) (err error) {
1855 var _p0 *byte
1856 _p0, err = BytePtrFromString(path)
1857 if err != nil {
1858 return
1859 }
1860 _, _, e1 := syscall_syscall(funcPC(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
1861 if e1 != 0 {
1862 err = errnoErr(e1)
1863 }
1864 return
1865 }
1866
1867 func libc_rmdir_trampoline()
1868
1869
1870
1871
1872
1873
1874 func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
1875 r0, _, e1 := syscall_syscall(funcPC(libc_lseek_trampoline), uintptr(fd), uintptr(offset), uintptr(whence))
1876 newoffset = int64(r0)
1877 if e1 != 0 {
1878 err = errnoErr(e1)
1879 }
1880 return
1881 }
1882
1883 func libc_lseek_trampoline()
1884
1885
1886
1887
1888
1889
1890 func Select(n int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (err error) {
1891 _, _, e1 := syscall_syscall6(funcPC(libc_select_trampoline), uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
1892 if e1 != 0 {
1893 err = errnoErr(e1)
1894 }
1895 return
1896 }
1897
1898 func libc_select_trampoline()
1899
1900
1901
1902
1903
1904
1905 func Setegid(egid int) (err error) {
1906 _, _, e1 := syscall_syscall(funcPC(libc_setegid_trampoline), uintptr(egid), 0, 0)
1907 if e1 != 0 {
1908 err = errnoErr(e1)
1909 }
1910 return
1911 }
1912
1913 func libc_setegid_trampoline()
1914
1915
1916
1917
1918
1919
1920 func Seteuid(euid int) (err error) {
1921 _, _, e1 := syscall_rawSyscall(funcPC(libc_seteuid_trampoline), uintptr(euid), 0, 0)
1922 if e1 != 0 {
1923 err = errnoErr(e1)
1924 }
1925 return
1926 }
1927
1928 func libc_seteuid_trampoline()
1929
1930
1931
1932
1933
1934
1935 func Setgid(gid int) (err error) {
1936 _, _, e1 := syscall_rawSyscall(funcPC(libc_setgid_trampoline), uintptr(gid), 0, 0)
1937 if e1 != 0 {
1938 err = errnoErr(e1)
1939 }
1940 return
1941 }
1942
1943 func libc_setgid_trampoline()
1944
1945
1946
1947
1948
1949
1950 func Setlogin(name string) (err error) {
1951 var _p0 *byte
1952 _p0, err = BytePtrFromString(name)
1953 if err != nil {
1954 return
1955 }
1956 _, _, e1 := syscall_syscall(funcPC(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
1957 if e1 != 0 {
1958 err = errnoErr(e1)
1959 }
1960 return
1961 }
1962
1963 func libc_setlogin_trampoline()
1964
1965
1966
1967
1968
1969
1970 func Setpgid(pid int, pgid int) (err error) {
1971 _, _, e1 := syscall_rawSyscall(funcPC(libc_setpgid_trampoline), uintptr(pid), uintptr(pgid), 0)
1972 if e1 != 0 {
1973 err = errnoErr(e1)
1974 }
1975 return
1976 }
1977
1978 func libc_setpgid_trampoline()
1979
1980
1981
1982
1983
1984
1985 func Setpriority(which int, who int, prio int) (err error) {
1986 _, _, e1 := syscall_syscall(funcPC(libc_setpriority_trampoline), uintptr(which), uintptr(who), uintptr(prio))
1987 if e1 != 0 {
1988 err = errnoErr(e1)
1989 }
1990 return
1991 }
1992
1993 func libc_setpriority_trampoline()
1994
1995
1996
1997
1998
1999
2000 func Setprivexec(flag int) (err error) {
2001 _, _, e1 := syscall_syscall(funcPC(libc_setprivexec_trampoline), uintptr(flag), 0, 0)
2002 if e1 != 0 {
2003 err = errnoErr(e1)
2004 }
2005 return
2006 }
2007
2008 func libc_setprivexec_trampoline()
2009
2010
2011
2012
2013
2014
2015 func Setregid(rgid int, egid int) (err error) {
2016 _, _, e1 := syscall_rawSyscall(funcPC(libc_setregid_trampoline), uintptr(rgid), uintptr(egid), 0)
2017 if e1 != 0 {
2018 err = errnoErr(e1)
2019 }
2020 return
2021 }
2022
2023 func libc_setregid_trampoline()
2024
2025
2026
2027
2028
2029
2030 func Setreuid(ruid int, euid int) (err error) {
2031 _, _, e1 := syscall_rawSyscall(funcPC(libc_setreuid_trampoline), uintptr(ruid), uintptr(euid), 0)
2032 if e1 != 0 {
2033 err = errnoErr(e1)
2034 }
2035 return
2036 }
2037
2038 func libc_setreuid_trampoline()
2039
2040
2041
2042
2043
2044
2045 func Setrlimit(which int, lim *Rlimit) (err error) {
2046 _, _, e1 := syscall_rawSyscall(funcPC(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
2047 if e1 != 0 {
2048 err = errnoErr(e1)
2049 }
2050 return
2051 }
2052
2053 func libc_setrlimit_trampoline()
2054
2055
2056
2057
2058
2059
2060 func Setsid() (pid int, err error) {
2061 r0, _, e1 := syscall_rawSyscall(funcPC(libc_setsid_trampoline), 0, 0, 0)
2062 pid = int(r0)
2063 if e1 != 0 {
2064 err = errnoErr(e1)
2065 }
2066 return
2067 }
2068
2069 func libc_setsid_trampoline()
2070
2071
2072
2073
2074
2075
2076 func Settimeofday(tp *Timeval) (err error) {
2077 _, _, e1 := syscall_rawSyscall(funcPC(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
2078 if e1 != 0 {
2079 err = errnoErr(e1)
2080 }
2081 return
2082 }
2083
2084 func libc_settimeofday_trampoline()
2085
2086
2087
2088
2089
2090
2091 func Setuid(uid int) (err error) {
2092 _, _, e1 := syscall_rawSyscall(funcPC(libc_setuid_trampoline), uintptr(uid), 0, 0)
2093 if e1 != 0 {
2094 err = errnoErr(e1)
2095 }
2096 return
2097 }
2098
2099 func libc_setuid_trampoline()
2100
2101
2102
2103
2104
2105
2106 func Symlink(path string, link string) (err error) {
2107 var _p0 *byte
2108 _p0, err = BytePtrFromString(path)
2109 if err != nil {
2110 return
2111 }
2112 var _p1 *byte
2113 _p1, err = BytePtrFromString(link)
2114 if err != nil {
2115 return
2116 }
2117 _, _, e1 := syscall_syscall(funcPC(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
2118 if e1 != 0 {
2119 err = errnoErr(e1)
2120 }
2121 return
2122 }
2123
2124 func libc_symlink_trampoline()
2125
2126
2127
2128
2129
2130
2131 func Symlinkat(oldpath string, newdirfd int, newpath string) (err error) {
2132 var _p0 *byte
2133 _p0, err = BytePtrFromString(oldpath)
2134 if err != nil {
2135 return
2136 }
2137 var _p1 *byte
2138 _p1, err = BytePtrFromString(newpath)
2139 if err != nil {
2140 return
2141 }
2142 _, _, e1 := syscall_syscall(funcPC(libc_symlinkat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
2143 if e1 != 0 {
2144 err = errnoErr(e1)
2145 }
2146 return
2147 }
2148
2149 func libc_symlinkat_trampoline()
2150
2151
2152
2153
2154
2155
2156 func Sync() (err error) {
2157 _, _, e1 := syscall_syscall(funcPC(libc_sync_trampoline), 0, 0, 0)
2158 if e1 != 0 {
2159 err = errnoErr(e1)
2160 }
2161 return
2162 }
2163
2164 func libc_sync_trampoline()
2165
2166
2167
2168
2169
2170
2171 func Truncate(path string, length int64) (err error) {
2172 var _p0 *byte
2173 _p0, err = BytePtrFromString(path)
2174 if err != nil {
2175 return
2176 }
2177 _, _, e1 := syscall_syscall(funcPC(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
2178 if e1 != 0 {
2179 err = errnoErr(e1)
2180 }
2181 return
2182 }
2183
2184 func libc_truncate_trampoline()
2185
2186
2187
2188
2189
2190
2191 func Umask(newmask int) (oldmask int) {
2192 r0, _, _ := syscall_syscall(funcPC(libc_umask_trampoline), uintptr(newmask), 0, 0)
2193 oldmask = int(r0)
2194 return
2195 }
2196
2197 func libc_umask_trampoline()
2198
2199
2200
2201
2202
2203
2204 func Undelete(path string) (err error) {
2205 var _p0 *byte
2206 _p0, err = BytePtrFromString(path)
2207 if err != nil {
2208 return
2209 }
2210 _, _, e1 := syscall_syscall(funcPC(libc_undelete_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
2211 if e1 != 0 {
2212 err = errnoErr(e1)
2213 }
2214 return
2215 }
2216
2217 func libc_undelete_trampoline()
2218
2219
2220
2221
2222
2223
2224 func Unlink(path string) (err error) {
2225 var _p0 *byte
2226 _p0, err = BytePtrFromString(path)
2227 if err != nil {
2228 return
2229 }
2230 _, _, e1 := syscall_syscall(funcPC(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
2231 if e1 != 0 {
2232 err = errnoErr(e1)
2233 }
2234 return
2235 }
2236
2237 func libc_unlink_trampoline()
2238
2239
2240
2241
2242
2243
2244 func Unlinkat(dirfd int, path string, flags int) (err error) {
2245 var _p0 *byte
2246 _p0, err = BytePtrFromString(path)
2247 if err != nil {
2248 return
2249 }
2250 _, _, e1 := syscall_syscall(funcPC(libc_unlinkat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
2251 if e1 != 0 {
2252 err = errnoErr(e1)
2253 }
2254 return
2255 }
2256
2257 func libc_unlinkat_trampoline()
2258
2259
2260
2261
2262
2263
2264 func Unmount(path string, flags int) (err error) {
2265 var _p0 *byte
2266 _p0, err = BytePtrFromString(path)
2267 if err != nil {
2268 return
2269 }
2270 _, _, e1 := syscall_syscall(funcPC(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
2271 if e1 != 0 {
2272 err = errnoErr(e1)
2273 }
2274 return
2275 }
2276
2277 func libc_unmount_trampoline()
2278
2279
2280
2281
2282
2283
2284 func write(fd int, p []byte) (n int, err error) {
2285 var _p0 unsafe.Pointer
2286 if len(p) > 0 {
2287 _p0 = unsafe.Pointer(&p[0])
2288 } else {
2289 _p0 = unsafe.Pointer(&_zero)
2290 }
2291 r0, _, e1 := syscall_syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
2292 n = int(r0)
2293 if e1 != 0 {
2294 err = errnoErr(e1)
2295 }
2296 return
2297 }
2298
2299 func libc_write_trampoline()
2300
2301
2302
2303
2304
2305
2306 func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
2307 r0, _, e1 := syscall_syscall6(funcPC(libc_mmap_trampoline), uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
2308 ret = uintptr(r0)
2309 if e1 != 0 {
2310 err = errnoErr(e1)
2311 }
2312 return
2313 }
2314
2315 func libc_mmap_trampoline()
2316
2317
2318
2319
2320
2321
2322 func munmap(addr uintptr, length uintptr) (err error) {
2323 _, _, e1 := syscall_syscall(funcPC(libc_munmap_trampoline), uintptr(addr), uintptr(length), 0)
2324 if e1 != 0 {
2325 err = errnoErr(e1)
2326 }
2327 return
2328 }
2329
2330 func libc_munmap_trampoline()
2331
2332
2333
2334
2335
2336
2337 func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
2338 r0, _, e1 := syscall_syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
2339 n = int(r0)
2340 if e1 != 0 {
2341 err = errnoErr(e1)
2342 }
2343 return
2344 }
2345
2346
2347
2348 func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
2349 r0, _, e1 := syscall_syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
2350 n = int(r0)
2351 if e1 != 0 {
2352 err = errnoErr(e1)
2353 }
2354 return
2355 }
2356
2357
2358
2359 func gettimeofday(tp *Timeval) (sec int64, usec int32, err error) {
2360 r0, r1, e1 := syscall_rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
2361 sec = int64(r0)
2362 usec = int32(r1)
2363 if e1 != 0 {
2364 err = errnoErr(e1)
2365 }
2366 return
2367 }
2368
2369 func libc_gettimeofday_trampoline()
2370
2371
2372
2373
2374
2375
2376 func Fstat(fd int, stat *Stat_t) (err error) {
2377 _, _, e1 := syscall_syscall(funcPC(libc_fstat64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
2378 if e1 != 0 {
2379 err = errnoErr(e1)
2380 }
2381 return
2382 }
2383
2384 func libc_fstat64_trampoline()
2385
2386
2387
2388
2389
2390
2391 func Fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
2392 var _p0 *byte
2393 _p0, err = BytePtrFromString(path)
2394 if err != nil {
2395 return
2396 }
2397 _, _, e1 := syscall_syscall6(funcPC(libc_fstatat64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
2398 if e1 != 0 {
2399 err = errnoErr(e1)
2400 }
2401 return
2402 }
2403
2404 func libc_fstatat64_trampoline()
2405
2406
2407
2408
2409
2410
2411 func Fstatfs(fd int, stat *Statfs_t) (err error) {
2412 _, _, e1 := syscall_syscall(funcPC(libc_fstatfs64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
2413 if e1 != 0 {
2414 err = errnoErr(e1)
2415 }
2416 return
2417 }
2418
2419 func libc_fstatfs64_trampoline()
2420
2421
2422
2423
2424
2425
2426 func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) {
2427 var _p0 unsafe.Pointer
2428 if len(buf) > 0 {
2429 _p0 = unsafe.Pointer(&buf[0])
2430 } else {
2431 _p0 = unsafe.Pointer(&_zero)
2432 }
2433 r0, _, e1 := syscall_syscall6(funcPC(libc___getdirentries64_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(buf)), uintptr(unsafe.Pointer(basep)), 0, 0)
2434 n = int(r0)
2435 if e1 != 0 {
2436 err = errnoErr(e1)
2437 }
2438 return
2439 }
2440
2441 func libc___getdirentries64_trampoline()
2442
2443
2444
2445
2446
2447
2448 func getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) {
2449 r0, _, e1 := syscall_syscall(funcPC(libc_getfsstat64_trampoline), uintptr(buf), uintptr(size), uintptr(flags))
2450 n = int(r0)
2451 if e1 != 0 {
2452 err = errnoErr(e1)
2453 }
2454 return
2455 }
2456
2457 func libc_getfsstat64_trampoline()
2458
2459
2460
2461
2462
2463
2464 func Lstat(path string, stat *Stat_t) (err error) {
2465 var _p0 *byte
2466 _p0, err = BytePtrFromString(path)
2467 if err != nil {
2468 return
2469 }
2470 _, _, e1 := syscall_syscall(funcPC(libc_lstat64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
2471 if e1 != 0 {
2472 err = errnoErr(e1)
2473 }
2474 return
2475 }
2476
2477 func libc_lstat64_trampoline()
2478
2479
2480
2481
2482
2483
2484 func Stat(path string, stat *Stat_t) (err error) {
2485 var _p0 *byte
2486 _p0, err = BytePtrFromString(path)
2487 if err != nil {
2488 return
2489 }
2490 _, _, e1 := syscall_syscall(funcPC(libc_stat64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
2491 if e1 != 0 {
2492 err = errnoErr(e1)
2493 }
2494 return
2495 }
2496
2497 func libc_stat64_trampoline()
2498
2499
2500
2501
2502
2503
2504 func Statfs(path string, stat *Statfs_t) (err error) {
2505 var _p0 *byte
2506 _p0, err = BytePtrFromString(path)
2507 if err != nil {
2508 return
2509 }
2510 _, _, e1 := syscall_syscall(funcPC(libc_statfs64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
2511 if e1 != 0 {
2512 err = errnoErr(e1)
2513 }
2514 return
2515 }
2516
2517 func libc_statfs64_trampoline()
2518
2519
2520
2521
View as plain text