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