Source file src/pkg/cmd/vendor/golang.org/x/sys/unix/zsyscall_darwin_386.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_syscall9(funcPC(libc_sendfile_trampoline), uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(offset>>32), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags), 0, 0)
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 Close(fd int) (err error) {
947 _, _, e1 := syscall_syscall(funcPC(libc_close_trampoline), uintptr(fd), 0, 0)
948 if e1 != 0 {
949 err = errnoErr(e1)
950 }
951 return
952 }
953
954 func libc_close_trampoline()
955
956
957
958
959
960
961 func Dup(fd int) (nfd int, err error) {
962 r0, _, e1 := syscall_syscall(funcPC(libc_dup_trampoline), uintptr(fd), 0, 0)
963 nfd = int(r0)
964 if e1 != 0 {
965 err = errnoErr(e1)
966 }
967 return
968 }
969
970 func libc_dup_trampoline()
971
972
973
974
975
976
977 func Dup2(from int, to int) (err error) {
978 _, _, e1 := syscall_syscall(funcPC(libc_dup2_trampoline), uintptr(from), uintptr(to), 0)
979 if e1 != 0 {
980 err = errnoErr(e1)
981 }
982 return
983 }
984
985 func libc_dup2_trampoline()
986
987
988
989
990
991
992 func Exchangedata(path1 string, path2 string, options int) (err error) {
993 var _p0 *byte
994 _p0, err = BytePtrFromString(path1)
995 if err != nil {
996 return
997 }
998 var _p1 *byte
999 _p1, err = BytePtrFromString(path2)
1000 if err != nil {
1001 return
1002 }
1003 _, _, e1 := syscall_syscall(funcPC(libc_exchangedata_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
1004 if e1 != 0 {
1005 err = errnoErr(e1)
1006 }
1007 return
1008 }
1009
1010 func libc_exchangedata_trampoline()
1011
1012
1013
1014
1015
1016
1017 func Exit(code int) {
1018 syscall_syscall(funcPC(libc_exit_trampoline), uintptr(code), 0, 0)
1019 return
1020 }
1021
1022 func libc_exit_trampoline()
1023
1024
1025
1026
1027
1028
1029 func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
1030 var _p0 *byte
1031 _p0, err = BytePtrFromString(path)
1032 if err != nil {
1033 return
1034 }
1035 _, _, e1 := syscall_syscall6(funcPC(libc_faccessat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
1036 if e1 != 0 {
1037 err = errnoErr(e1)
1038 }
1039 return
1040 }
1041
1042 func libc_faccessat_trampoline()
1043
1044
1045
1046
1047
1048
1049 func Fchdir(fd int) (err error) {
1050 _, _, e1 := syscall_syscall(funcPC(libc_fchdir_trampoline), uintptr(fd), 0, 0)
1051 if e1 != 0 {
1052 err = errnoErr(e1)
1053 }
1054 return
1055 }
1056
1057 func libc_fchdir_trampoline()
1058
1059
1060
1061
1062
1063
1064 func Fchflags(fd int, flags int) (err error) {
1065 _, _, e1 := syscall_syscall(funcPC(libc_fchflags_trampoline), uintptr(fd), uintptr(flags), 0)
1066 if e1 != 0 {
1067 err = errnoErr(e1)
1068 }
1069 return
1070 }
1071
1072 func libc_fchflags_trampoline()
1073
1074
1075
1076
1077
1078
1079 func Fchmod(fd int, mode uint32) (err error) {
1080 _, _, e1 := syscall_syscall(funcPC(libc_fchmod_trampoline), uintptr(fd), uintptr(mode), 0)
1081 if e1 != 0 {
1082 err = errnoErr(e1)
1083 }
1084 return
1085 }
1086
1087 func libc_fchmod_trampoline()
1088
1089
1090
1091
1092
1093
1094 func Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) {
1095 var _p0 *byte
1096 _p0, err = BytePtrFromString(path)
1097 if err != nil {
1098 return
1099 }
1100 _, _, e1 := syscall_syscall6(funcPC(libc_fchmodat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
1101 if e1 != 0 {
1102 err = errnoErr(e1)
1103 }
1104 return
1105 }
1106
1107 func libc_fchmodat_trampoline()
1108
1109
1110
1111
1112
1113
1114 func Fchown(fd int, uid int, gid int) (err error) {
1115 _, _, e1 := syscall_syscall(funcPC(libc_fchown_trampoline), uintptr(fd), uintptr(uid), uintptr(gid))
1116 if e1 != 0 {
1117 err = errnoErr(e1)
1118 }
1119 return
1120 }
1121
1122 func libc_fchown_trampoline()
1123
1124
1125
1126
1127
1128
1129 func Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error) {
1130 var _p0 *byte
1131 _p0, err = BytePtrFromString(path)
1132 if err != nil {
1133 return
1134 }
1135 _, _, e1 := syscall_syscall6(funcPC(libc_fchownat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
1136 if e1 != 0 {
1137 err = errnoErr(e1)
1138 }
1139 return
1140 }
1141
1142 func libc_fchownat_trampoline()
1143
1144
1145
1146
1147
1148
1149 func Flock(fd int, how int) (err error) {
1150 _, _, e1 := syscall_syscall(funcPC(libc_flock_trampoline), uintptr(fd), uintptr(how), 0)
1151 if e1 != 0 {
1152 err = errnoErr(e1)
1153 }
1154 return
1155 }
1156
1157 func libc_flock_trampoline()
1158
1159
1160
1161
1162
1163
1164 func Fpathconf(fd int, name int) (val int, err error) {
1165 r0, _, e1 := syscall_syscall(funcPC(libc_fpathconf_trampoline), uintptr(fd), uintptr(name), 0)
1166 val = int(r0)
1167 if e1 != 0 {
1168 err = errnoErr(e1)
1169 }
1170 return
1171 }
1172
1173 func libc_fpathconf_trampoline()
1174
1175
1176
1177
1178
1179
1180 func Fsync(fd int) (err error) {
1181 _, _, e1 := syscall_syscall(funcPC(libc_fsync_trampoline), uintptr(fd), 0, 0)
1182 if e1 != 0 {
1183 err = errnoErr(e1)
1184 }
1185 return
1186 }
1187
1188 func libc_fsync_trampoline()
1189
1190
1191
1192
1193
1194
1195 func Ftruncate(fd int, length int64) (err error) {
1196 _, _, e1 := syscall_syscall(funcPC(libc_ftruncate_trampoline), uintptr(fd), uintptr(length), uintptr(length>>32))
1197 if e1 != 0 {
1198 err = errnoErr(e1)
1199 }
1200 return
1201 }
1202
1203 func libc_ftruncate_trampoline()
1204
1205
1206
1207
1208
1209
1210 func Getdtablesize() (size int) {
1211 r0, _, _ := syscall_syscall(funcPC(libc_getdtablesize_trampoline), 0, 0, 0)
1212 size = int(r0)
1213 return
1214 }
1215
1216 func libc_getdtablesize_trampoline()
1217
1218
1219
1220
1221
1222
1223 func Getegid() (egid int) {
1224 r0, _, _ := syscall_rawSyscall(funcPC(libc_getegid_trampoline), 0, 0, 0)
1225 egid = int(r0)
1226 return
1227 }
1228
1229 func libc_getegid_trampoline()
1230
1231
1232
1233
1234
1235
1236 func Geteuid() (uid int) {
1237 r0, _, _ := syscall_rawSyscall(funcPC(libc_geteuid_trampoline), 0, 0, 0)
1238 uid = int(r0)
1239 return
1240 }
1241
1242 func libc_geteuid_trampoline()
1243
1244
1245
1246
1247
1248
1249 func Getgid() (gid int) {
1250 r0, _, _ := syscall_rawSyscall(funcPC(libc_getgid_trampoline), 0, 0, 0)
1251 gid = int(r0)
1252 return
1253 }
1254
1255 func libc_getgid_trampoline()
1256
1257
1258
1259
1260
1261
1262 func Getpgid(pid int) (pgid int, err error) {
1263 r0, _, e1 := syscall_rawSyscall(funcPC(libc_getpgid_trampoline), uintptr(pid), 0, 0)
1264 pgid = int(r0)
1265 if e1 != 0 {
1266 err = errnoErr(e1)
1267 }
1268 return
1269 }
1270
1271 func libc_getpgid_trampoline()
1272
1273
1274
1275
1276
1277
1278 func Getpgrp() (pgrp int) {
1279 r0, _, _ := syscall_rawSyscall(funcPC(libc_getpgrp_trampoline), 0, 0, 0)
1280 pgrp = int(r0)
1281 return
1282 }
1283
1284 func libc_getpgrp_trampoline()
1285
1286
1287
1288
1289
1290
1291 func Getpid() (pid int) {
1292 r0, _, _ := syscall_rawSyscall(funcPC(libc_getpid_trampoline), 0, 0, 0)
1293 pid = int(r0)
1294 return
1295 }
1296
1297 func libc_getpid_trampoline()
1298
1299
1300
1301
1302
1303
1304 func Getppid() (ppid int) {
1305 r0, _, _ := syscall_rawSyscall(funcPC(libc_getppid_trampoline), 0, 0, 0)
1306 ppid = int(r0)
1307 return
1308 }
1309
1310 func libc_getppid_trampoline()
1311
1312
1313
1314
1315
1316
1317 func Getpriority(which int, who int) (prio int, err error) {
1318 r0, _, e1 := syscall_syscall(funcPC(libc_getpriority_trampoline), uintptr(which), uintptr(who), 0)
1319 prio = int(r0)
1320 if e1 != 0 {
1321 err = errnoErr(e1)
1322 }
1323 return
1324 }
1325
1326 func libc_getpriority_trampoline()
1327
1328
1329
1330
1331
1332
1333 func Getrlimit(which int, lim *Rlimit) (err error) {
1334 _, _, e1 := syscall_rawSyscall(funcPC(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
1335 if e1 != 0 {
1336 err = errnoErr(e1)
1337 }
1338 return
1339 }
1340
1341 func libc_getrlimit_trampoline()
1342
1343
1344
1345
1346
1347
1348 func Getrusage(who int, rusage *Rusage) (err error) {
1349 _, _, e1 := syscall_rawSyscall(funcPC(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
1350 if e1 != 0 {
1351 err = errnoErr(e1)
1352 }
1353 return
1354 }
1355
1356 func libc_getrusage_trampoline()
1357
1358
1359
1360
1361
1362
1363 func Getsid(pid int) (sid int, err error) {
1364 r0, _, e1 := syscall_rawSyscall(funcPC(libc_getsid_trampoline), uintptr(pid), 0, 0)
1365 sid = int(r0)
1366 if e1 != 0 {
1367 err = errnoErr(e1)
1368 }
1369 return
1370 }
1371
1372 func libc_getsid_trampoline()
1373
1374
1375
1376
1377
1378
1379 func Getuid() (uid int) {
1380 r0, _, _ := syscall_rawSyscall(funcPC(libc_getuid_trampoline), 0, 0, 0)
1381 uid = int(r0)
1382 return
1383 }
1384
1385 func libc_getuid_trampoline()
1386
1387
1388
1389
1390
1391
1392 func Issetugid() (tainted bool) {
1393 r0, _, _ := syscall_rawSyscall(funcPC(libc_issetugid_trampoline), 0, 0, 0)
1394 tainted = bool(r0 != 0)
1395 return
1396 }
1397
1398 func libc_issetugid_trampoline()
1399
1400
1401
1402
1403
1404
1405 func Kqueue() (fd int, err error) {
1406 r0, _, e1 := syscall_syscall(funcPC(libc_kqueue_trampoline), 0, 0, 0)
1407 fd = int(r0)
1408 if e1 != 0 {
1409 err = errnoErr(e1)
1410 }
1411 return
1412 }
1413
1414 func libc_kqueue_trampoline()
1415
1416
1417
1418
1419
1420
1421 func Lchown(path string, uid int, gid int) (err error) {
1422 var _p0 *byte
1423 _p0, err = BytePtrFromString(path)
1424 if err != nil {
1425 return
1426 }
1427 _, _, e1 := syscall_syscall(funcPC(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
1428 if e1 != 0 {
1429 err = errnoErr(e1)
1430 }
1431 return
1432 }
1433
1434 func libc_lchown_trampoline()
1435
1436
1437
1438
1439
1440
1441 func Link(path string, link string) (err error) {
1442 var _p0 *byte
1443 _p0, err = BytePtrFromString(path)
1444 if err != nil {
1445 return
1446 }
1447 var _p1 *byte
1448 _p1, err = BytePtrFromString(link)
1449 if err != nil {
1450 return
1451 }
1452 _, _, e1 := syscall_syscall(funcPC(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
1453 if e1 != 0 {
1454 err = errnoErr(e1)
1455 }
1456 return
1457 }
1458
1459 func libc_link_trampoline()
1460
1461
1462
1463
1464
1465
1466 func Linkat(pathfd int, path string, linkfd int, link string, flags int) (err error) {
1467 var _p0 *byte
1468 _p0, err = BytePtrFromString(path)
1469 if err != nil {
1470 return
1471 }
1472 var _p1 *byte
1473 _p1, err = BytePtrFromString(link)
1474 if err != nil {
1475 return
1476 }
1477 _, _, e1 := syscall_syscall6(funcPC(libc_linkat_trampoline), uintptr(pathfd), uintptr(unsafe.Pointer(_p0)), uintptr(linkfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
1478 if e1 != 0 {
1479 err = errnoErr(e1)
1480 }
1481 return
1482 }
1483
1484 func libc_linkat_trampoline()
1485
1486
1487
1488
1489
1490
1491 func Listen(s int, backlog int) (err error) {
1492 _, _, e1 := syscall_syscall(funcPC(libc_listen_trampoline), uintptr(s), uintptr(backlog), 0)
1493 if e1 != 0 {
1494 err = errnoErr(e1)
1495 }
1496 return
1497 }
1498
1499 func libc_listen_trampoline()
1500
1501
1502
1503
1504
1505
1506 func Mkdir(path string, mode uint32) (err error) {
1507 var _p0 *byte
1508 _p0, err = BytePtrFromString(path)
1509 if err != nil {
1510 return
1511 }
1512 _, _, e1 := syscall_syscall(funcPC(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
1513 if e1 != 0 {
1514 err = errnoErr(e1)
1515 }
1516 return
1517 }
1518
1519 func libc_mkdir_trampoline()
1520
1521
1522
1523
1524
1525
1526 func Mkdirat(dirfd int, path string, mode uint32) (err error) {
1527 var _p0 *byte
1528 _p0, err = BytePtrFromString(path)
1529 if err != nil {
1530 return
1531 }
1532 _, _, e1 := syscall_syscall(funcPC(libc_mkdirat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
1533 if e1 != 0 {
1534 err = errnoErr(e1)
1535 }
1536 return
1537 }
1538
1539 func libc_mkdirat_trampoline()
1540
1541
1542
1543
1544
1545
1546 func Mkfifo(path string, mode uint32) (err error) {
1547 var _p0 *byte
1548 _p0, err = BytePtrFromString(path)
1549 if err != nil {
1550 return
1551 }
1552 _, _, e1 := syscall_syscall(funcPC(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
1553 if e1 != 0 {
1554 err = errnoErr(e1)
1555 }
1556 return
1557 }
1558
1559 func libc_mkfifo_trampoline()
1560
1561
1562
1563
1564
1565
1566 func Mknod(path string, mode uint32, dev int) (err error) {
1567 var _p0 *byte
1568 _p0, err = BytePtrFromString(path)
1569 if err != nil {
1570 return
1571 }
1572 _, _, e1 := syscall_syscall(funcPC(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
1573 if e1 != 0 {
1574 err = errnoErr(e1)
1575 }
1576 return
1577 }
1578
1579 func libc_mknod_trampoline()
1580
1581
1582
1583
1584
1585
1586 func Open(path string, mode int, perm uint32) (fd int, err error) {
1587 var _p0 *byte
1588 _p0, err = BytePtrFromString(path)
1589 if err != nil {
1590 return
1591 }
1592 r0, _, e1 := syscall_syscall(funcPC(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
1593 fd = int(r0)
1594 if e1 != 0 {
1595 err = errnoErr(e1)
1596 }
1597 return
1598 }
1599
1600 func libc_open_trampoline()
1601
1602
1603
1604
1605
1606
1607 func Openat(dirfd int, path string, mode int, perm uint32) (fd int, err error) {
1608 var _p0 *byte
1609 _p0, err = BytePtrFromString(path)
1610 if err != nil {
1611 return
1612 }
1613 r0, _, e1 := syscall_syscall6(funcPC(libc_openat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0)
1614 fd = int(r0)
1615 if e1 != 0 {
1616 err = errnoErr(e1)
1617 }
1618 return
1619 }
1620
1621 func libc_openat_trampoline()
1622
1623
1624
1625
1626
1627
1628 func Pathconf(path string, name int) (val int, err error) {
1629 var _p0 *byte
1630 _p0, err = BytePtrFromString(path)
1631 if err != nil {
1632 return
1633 }
1634 r0, _, e1 := syscall_syscall(funcPC(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
1635 val = int(r0)
1636 if e1 != 0 {
1637 err = errnoErr(e1)
1638 }
1639 return
1640 }
1641
1642 func libc_pathconf_trampoline()
1643
1644
1645
1646
1647
1648
1649 func Pread(fd int, p []byte, offset int64) (n int, err error) {
1650 var _p0 unsafe.Pointer
1651 if len(p) > 0 {
1652 _p0 = unsafe.Pointer(&p[0])
1653 } else {
1654 _p0 = unsafe.Pointer(&_zero)
1655 }
1656 r0, _, e1 := syscall_syscall6(funcPC(libc_pread_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
1657 n = int(r0)
1658 if e1 != 0 {
1659 err = errnoErr(e1)
1660 }
1661 return
1662 }
1663
1664 func libc_pread_trampoline()
1665
1666
1667
1668
1669
1670
1671 func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
1672 var _p0 unsafe.Pointer
1673 if len(p) > 0 {
1674 _p0 = unsafe.Pointer(&p[0])
1675 } else {
1676 _p0 = unsafe.Pointer(&_zero)
1677 }
1678 r0, _, e1 := syscall_syscall6(funcPC(libc_pwrite_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
1679 n = int(r0)
1680 if e1 != 0 {
1681 err = errnoErr(e1)
1682 }
1683 return
1684 }
1685
1686 func libc_pwrite_trampoline()
1687
1688
1689
1690
1691
1692
1693 func read(fd int, p []byte) (n int, err error) {
1694 var _p0 unsafe.Pointer
1695 if len(p) > 0 {
1696 _p0 = unsafe.Pointer(&p[0])
1697 } else {
1698 _p0 = unsafe.Pointer(&_zero)
1699 }
1700 r0, _, e1 := syscall_syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
1701 n = int(r0)
1702 if e1 != 0 {
1703 err = errnoErr(e1)
1704 }
1705 return
1706 }
1707
1708 func libc_read_trampoline()
1709
1710
1711
1712
1713
1714
1715 func Readlink(path string, buf []byte) (n int, err error) {
1716 var _p0 *byte
1717 _p0, err = BytePtrFromString(path)
1718 if err != nil {
1719 return
1720 }
1721 var _p1 unsafe.Pointer
1722 if len(buf) > 0 {
1723 _p1 = unsafe.Pointer(&buf[0])
1724 } else {
1725 _p1 = unsafe.Pointer(&_zero)
1726 }
1727 r0, _, e1 := syscall_syscall(funcPC(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
1728 n = int(r0)
1729 if e1 != 0 {
1730 err = errnoErr(e1)
1731 }
1732 return
1733 }
1734
1735 func libc_readlink_trampoline()
1736
1737
1738
1739
1740
1741
1742 func Readlinkat(dirfd int, path string, buf []byte) (n int, err error) {
1743 var _p0 *byte
1744 _p0, err = BytePtrFromString(path)
1745 if err != nil {
1746 return
1747 }
1748 var _p1 unsafe.Pointer
1749 if len(buf) > 0 {
1750 _p1 = unsafe.Pointer(&buf[0])
1751 } else {
1752 _p1 = unsafe.Pointer(&_zero)
1753 }
1754 r0, _, e1 := syscall_syscall6(funcPC(libc_readlinkat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
1755 n = int(r0)
1756 if e1 != 0 {
1757 err = errnoErr(e1)
1758 }
1759 return
1760 }
1761
1762 func libc_readlinkat_trampoline()
1763
1764
1765
1766
1767
1768
1769 func Rename(from string, to string) (err error) {
1770 var _p0 *byte
1771 _p0, err = BytePtrFromString(from)
1772 if err != nil {
1773 return
1774 }
1775 var _p1 *byte
1776 _p1, err = BytePtrFromString(to)
1777 if err != nil {
1778 return
1779 }
1780 _, _, e1 := syscall_syscall(funcPC(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
1781 if e1 != 0 {
1782 err = errnoErr(e1)
1783 }
1784 return
1785 }
1786
1787 func libc_rename_trampoline()
1788
1789
1790
1791
1792
1793
1794 func Renameat(fromfd int, from string, tofd int, to string) (err error) {
1795 var _p0 *byte
1796 _p0, err = BytePtrFromString(from)
1797 if err != nil {
1798 return
1799 }
1800 var _p1 *byte
1801 _p1, err = BytePtrFromString(to)
1802 if err != nil {
1803 return
1804 }
1805 _, _, e1 := syscall_syscall6(funcPC(libc_renameat_trampoline), uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), 0, 0)
1806 if e1 != 0 {
1807 err = errnoErr(e1)
1808 }
1809 return
1810 }
1811
1812 func libc_renameat_trampoline()
1813
1814
1815
1816
1817
1818
1819 func Revoke(path string) (err error) {
1820 var _p0 *byte
1821 _p0, err = BytePtrFromString(path)
1822 if err != nil {
1823 return
1824 }
1825 _, _, e1 := syscall_syscall(funcPC(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
1826 if e1 != 0 {
1827 err = errnoErr(e1)
1828 }
1829 return
1830 }
1831
1832 func libc_revoke_trampoline()
1833
1834
1835
1836
1837
1838
1839 func Rmdir(path string) (err error) {
1840 var _p0 *byte
1841 _p0, err = BytePtrFromString(path)
1842 if err != nil {
1843 return
1844 }
1845 _, _, e1 := syscall_syscall(funcPC(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
1846 if e1 != 0 {
1847 err = errnoErr(e1)
1848 }
1849 return
1850 }
1851
1852 func libc_rmdir_trampoline()
1853
1854
1855
1856
1857
1858
1859 func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
1860 r0, r1, e1 := syscall_syscall6(funcPC(libc_lseek_trampoline), uintptr(fd), uintptr(offset), uintptr(offset>>32), uintptr(whence), 0, 0)
1861 newoffset = int64(int64(r1)<<32 | int64(r0))
1862 if e1 != 0 {
1863 err = errnoErr(e1)
1864 }
1865 return
1866 }
1867
1868 func libc_lseek_trampoline()
1869
1870
1871
1872
1873
1874
1875 func Select(n int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (err error) {
1876 _, _, 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)
1877 if e1 != 0 {
1878 err = errnoErr(e1)
1879 }
1880 return
1881 }
1882
1883 func libc_select_trampoline()
1884
1885
1886
1887
1888
1889
1890 func Setegid(egid int) (err error) {
1891 _, _, e1 := syscall_syscall(funcPC(libc_setegid_trampoline), uintptr(egid), 0, 0)
1892 if e1 != 0 {
1893 err = errnoErr(e1)
1894 }
1895 return
1896 }
1897
1898 func libc_setegid_trampoline()
1899
1900
1901
1902
1903
1904
1905 func Seteuid(euid int) (err error) {
1906 _, _, e1 := syscall_rawSyscall(funcPC(libc_seteuid_trampoline), uintptr(euid), 0, 0)
1907 if e1 != 0 {
1908 err = errnoErr(e1)
1909 }
1910 return
1911 }
1912
1913 func libc_seteuid_trampoline()
1914
1915
1916
1917
1918
1919
1920 func Setgid(gid int) (err error) {
1921 _, _, e1 := syscall_rawSyscall(funcPC(libc_setgid_trampoline), uintptr(gid), 0, 0)
1922 if e1 != 0 {
1923 err = errnoErr(e1)
1924 }
1925 return
1926 }
1927
1928 func libc_setgid_trampoline()
1929
1930
1931
1932
1933
1934
1935 func Setlogin(name string) (err error) {
1936 var _p0 *byte
1937 _p0, err = BytePtrFromString(name)
1938 if err != nil {
1939 return
1940 }
1941 _, _, e1 := syscall_syscall(funcPC(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
1942 if e1 != 0 {
1943 err = errnoErr(e1)
1944 }
1945 return
1946 }
1947
1948 func libc_setlogin_trampoline()
1949
1950
1951
1952
1953
1954
1955 func Setpgid(pid int, pgid int) (err error) {
1956 _, _, e1 := syscall_rawSyscall(funcPC(libc_setpgid_trampoline), uintptr(pid), uintptr(pgid), 0)
1957 if e1 != 0 {
1958 err = errnoErr(e1)
1959 }
1960 return
1961 }
1962
1963 func libc_setpgid_trampoline()
1964
1965
1966
1967
1968
1969
1970 func Setpriority(which int, who int, prio int) (err error) {
1971 _, _, e1 := syscall_syscall(funcPC(libc_setpriority_trampoline), uintptr(which), uintptr(who), uintptr(prio))
1972 if e1 != 0 {
1973 err = errnoErr(e1)
1974 }
1975 return
1976 }
1977
1978 func libc_setpriority_trampoline()
1979
1980
1981
1982
1983
1984
1985 func Setprivexec(flag int) (err error) {
1986 _, _, e1 := syscall_syscall(funcPC(libc_setprivexec_trampoline), uintptr(flag), 0, 0)
1987 if e1 != 0 {
1988 err = errnoErr(e1)
1989 }
1990 return
1991 }
1992
1993 func libc_setprivexec_trampoline()
1994
1995
1996
1997
1998
1999
2000 func Setregid(rgid int, egid int) (err error) {
2001 _, _, e1 := syscall_rawSyscall(funcPC(libc_setregid_trampoline), uintptr(rgid), uintptr(egid), 0)
2002 if e1 != 0 {
2003 err = errnoErr(e1)
2004 }
2005 return
2006 }
2007
2008 func libc_setregid_trampoline()
2009
2010
2011
2012
2013
2014
2015 func Setreuid(ruid int, euid int) (err error) {
2016 _, _, e1 := syscall_rawSyscall(funcPC(libc_setreuid_trampoline), uintptr(ruid), uintptr(euid), 0)
2017 if e1 != 0 {
2018 err = errnoErr(e1)
2019 }
2020 return
2021 }
2022
2023 func libc_setreuid_trampoline()
2024
2025
2026
2027
2028
2029
2030 func Setrlimit(which int, lim *Rlimit) (err error) {
2031 _, _, e1 := syscall_rawSyscall(funcPC(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
2032 if e1 != 0 {
2033 err = errnoErr(e1)
2034 }
2035 return
2036 }
2037
2038 func libc_setrlimit_trampoline()
2039
2040
2041
2042
2043
2044
2045 func Setsid() (pid int, err error) {
2046 r0, _, e1 := syscall_rawSyscall(funcPC(libc_setsid_trampoline), 0, 0, 0)
2047 pid = int(r0)
2048 if e1 != 0 {
2049 err = errnoErr(e1)
2050 }
2051 return
2052 }
2053
2054 func libc_setsid_trampoline()
2055
2056
2057
2058
2059
2060
2061 func Settimeofday(tp *Timeval) (err error) {
2062 _, _, e1 := syscall_rawSyscall(funcPC(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
2063 if e1 != 0 {
2064 err = errnoErr(e1)
2065 }
2066 return
2067 }
2068
2069 func libc_settimeofday_trampoline()
2070
2071
2072
2073
2074
2075
2076 func Setuid(uid int) (err error) {
2077 _, _, e1 := syscall_rawSyscall(funcPC(libc_setuid_trampoline), uintptr(uid), 0, 0)
2078 if e1 != 0 {
2079 err = errnoErr(e1)
2080 }
2081 return
2082 }
2083
2084 func libc_setuid_trampoline()
2085
2086
2087
2088
2089
2090
2091 func Symlink(path string, link string) (err error) {
2092 var _p0 *byte
2093 _p0, err = BytePtrFromString(path)
2094 if err != nil {
2095 return
2096 }
2097 var _p1 *byte
2098 _p1, err = BytePtrFromString(link)
2099 if err != nil {
2100 return
2101 }
2102 _, _, e1 := syscall_syscall(funcPC(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
2103 if e1 != 0 {
2104 err = errnoErr(e1)
2105 }
2106 return
2107 }
2108
2109 func libc_symlink_trampoline()
2110
2111
2112
2113
2114
2115
2116 func Symlinkat(oldpath string, newdirfd int, newpath string) (err error) {
2117 var _p0 *byte
2118 _p0, err = BytePtrFromString(oldpath)
2119 if err != nil {
2120 return
2121 }
2122 var _p1 *byte
2123 _p1, err = BytePtrFromString(newpath)
2124 if err != nil {
2125 return
2126 }
2127 _, _, e1 := syscall_syscall(funcPC(libc_symlinkat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
2128 if e1 != 0 {
2129 err = errnoErr(e1)
2130 }
2131 return
2132 }
2133
2134 func libc_symlinkat_trampoline()
2135
2136
2137
2138
2139
2140
2141 func Sync() (err error) {
2142 _, _, e1 := syscall_syscall(funcPC(libc_sync_trampoline), 0, 0, 0)
2143 if e1 != 0 {
2144 err = errnoErr(e1)
2145 }
2146 return
2147 }
2148
2149 func libc_sync_trampoline()
2150
2151
2152
2153
2154
2155
2156 func Truncate(path string, length int64) (err error) {
2157 var _p0 *byte
2158 _p0, err = BytePtrFromString(path)
2159 if err != nil {
2160 return
2161 }
2162 _, _, e1 := syscall_syscall(funcPC(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(length), uintptr(length>>32))
2163 if e1 != 0 {
2164 err = errnoErr(e1)
2165 }
2166 return
2167 }
2168
2169 func libc_truncate_trampoline()
2170
2171
2172
2173
2174
2175
2176 func Umask(newmask int) (oldmask int) {
2177 r0, _, _ := syscall_syscall(funcPC(libc_umask_trampoline), uintptr(newmask), 0, 0)
2178 oldmask = int(r0)
2179 return
2180 }
2181
2182 func libc_umask_trampoline()
2183
2184
2185
2186
2187
2188
2189 func Undelete(path string) (err error) {
2190 var _p0 *byte
2191 _p0, err = BytePtrFromString(path)
2192 if err != nil {
2193 return
2194 }
2195 _, _, e1 := syscall_syscall(funcPC(libc_undelete_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
2196 if e1 != 0 {
2197 err = errnoErr(e1)
2198 }
2199 return
2200 }
2201
2202 func libc_undelete_trampoline()
2203
2204
2205
2206
2207
2208
2209 func Unlink(path string) (err error) {
2210 var _p0 *byte
2211 _p0, err = BytePtrFromString(path)
2212 if err != nil {
2213 return
2214 }
2215 _, _, e1 := syscall_syscall(funcPC(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
2216 if e1 != 0 {
2217 err = errnoErr(e1)
2218 }
2219 return
2220 }
2221
2222 func libc_unlink_trampoline()
2223
2224
2225
2226
2227
2228
2229 func Unlinkat(dirfd int, path string, flags int) (err error) {
2230 var _p0 *byte
2231 _p0, err = BytePtrFromString(path)
2232 if err != nil {
2233 return
2234 }
2235 _, _, e1 := syscall_syscall(funcPC(libc_unlinkat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
2236 if e1 != 0 {
2237 err = errnoErr(e1)
2238 }
2239 return
2240 }
2241
2242 func libc_unlinkat_trampoline()
2243
2244
2245
2246
2247
2248
2249 func Unmount(path string, flags int) (err error) {
2250 var _p0 *byte
2251 _p0, err = BytePtrFromString(path)
2252 if err != nil {
2253 return
2254 }
2255 _, _, e1 := syscall_syscall(funcPC(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
2256 if e1 != 0 {
2257 err = errnoErr(e1)
2258 }
2259 return
2260 }
2261
2262 func libc_unmount_trampoline()
2263
2264
2265
2266
2267
2268
2269 func write(fd int, p []byte) (n int, err error) {
2270 var _p0 unsafe.Pointer
2271 if len(p) > 0 {
2272 _p0 = unsafe.Pointer(&p[0])
2273 } else {
2274 _p0 = unsafe.Pointer(&_zero)
2275 }
2276 r0, _, e1 := syscall_syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
2277 n = int(r0)
2278 if e1 != 0 {
2279 err = errnoErr(e1)
2280 }
2281 return
2282 }
2283
2284 func libc_write_trampoline()
2285
2286
2287
2288
2289
2290
2291 func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
2292 r0, _, e1 := syscall_syscall9(funcPC(libc_mmap_trampoline), uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos), uintptr(pos>>32), 0, 0)
2293 ret = uintptr(r0)
2294 if e1 != 0 {
2295 err = errnoErr(e1)
2296 }
2297 return
2298 }
2299
2300 func libc_mmap_trampoline()
2301
2302
2303
2304
2305
2306
2307 func munmap(addr uintptr, length uintptr) (err error) {
2308 _, _, e1 := syscall_syscall(funcPC(libc_munmap_trampoline), uintptr(addr), uintptr(length), 0)
2309 if e1 != 0 {
2310 err = errnoErr(e1)
2311 }
2312 return
2313 }
2314
2315 func libc_munmap_trampoline()
2316
2317
2318
2319
2320
2321
2322 func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
2323 r0, _, e1 := syscall_syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
2324 n = int(r0)
2325 if e1 != 0 {
2326 err = errnoErr(e1)
2327 }
2328 return
2329 }
2330
2331
2332
2333 func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
2334 r0, _, e1 := syscall_syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
2335 n = int(r0)
2336 if e1 != 0 {
2337 err = errnoErr(e1)
2338 }
2339 return
2340 }
2341
2342
2343
2344 func gettimeofday(tp *Timeval) (sec int32, usec int32, err error) {
2345 r0, r1, e1 := syscall_rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
2346 sec = int32(r0)
2347 usec = int32(r1)
2348 if e1 != 0 {
2349 err = errnoErr(e1)
2350 }
2351 return
2352 }
2353
2354 func libc_gettimeofday_trampoline()
2355
2356
2357
2358
2359
2360
2361 func Fstat(fd int, stat *Stat_t) (err error) {
2362 _, _, e1 := syscall_syscall(funcPC(libc_fstat64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
2363 if e1 != 0 {
2364 err = errnoErr(e1)
2365 }
2366 return
2367 }
2368
2369 func libc_fstat64_trampoline()
2370
2371
2372
2373
2374
2375
2376 func Fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
2377 var _p0 *byte
2378 _p0, err = BytePtrFromString(path)
2379 if err != nil {
2380 return
2381 }
2382 _, _, e1 := syscall_syscall6(funcPC(libc_fstatat64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
2383 if e1 != 0 {
2384 err = errnoErr(e1)
2385 }
2386 return
2387 }
2388
2389 func libc_fstatat64_trampoline()
2390
2391
2392
2393
2394
2395
2396 func Fstatfs(fd int, stat *Statfs_t) (err error) {
2397 _, _, e1 := syscall_syscall(funcPC(libc_fstatfs64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
2398 if e1 != 0 {
2399 err = errnoErr(e1)
2400 }
2401 return
2402 }
2403
2404 func libc_fstatfs64_trampoline()
2405
2406
2407
2408
2409
2410
2411 func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) {
2412 var _p0 unsafe.Pointer
2413 if len(buf) > 0 {
2414 _p0 = unsafe.Pointer(&buf[0])
2415 } else {
2416 _p0 = unsafe.Pointer(&_zero)
2417 }
2418 r0, _, e1 := syscall_syscall6(funcPC(libc___getdirentries64_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(buf)), uintptr(unsafe.Pointer(basep)), 0, 0)
2419 n = int(r0)
2420 if e1 != 0 {
2421 err = errnoErr(e1)
2422 }
2423 return
2424 }
2425
2426 func libc___getdirentries64_trampoline()
2427
2428
2429
2430
2431
2432
2433 func getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) {
2434 r0, _, e1 := syscall_syscall(funcPC(libc_getfsstat64_trampoline), uintptr(buf), uintptr(size), uintptr(flags))
2435 n = int(r0)
2436 if e1 != 0 {
2437 err = errnoErr(e1)
2438 }
2439 return
2440 }
2441
2442 func libc_getfsstat64_trampoline()
2443
2444
2445
2446
2447
2448
2449 func Lstat(path string, stat *Stat_t) (err error) {
2450 var _p0 *byte
2451 _p0, err = BytePtrFromString(path)
2452 if err != nil {
2453 return
2454 }
2455 _, _, e1 := syscall_syscall(funcPC(libc_lstat64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
2456 if e1 != 0 {
2457 err = errnoErr(e1)
2458 }
2459 return
2460 }
2461
2462 func libc_lstat64_trampoline()
2463
2464
2465
2466
2467
2468
2469 func Stat(path string, stat *Stat_t) (err error) {
2470 var _p0 *byte
2471 _p0, err = BytePtrFromString(path)
2472 if err != nil {
2473 return
2474 }
2475 _, _, e1 := syscall_syscall(funcPC(libc_stat64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
2476 if e1 != 0 {
2477 err = errnoErr(e1)
2478 }
2479 return
2480 }
2481
2482 func libc_stat64_trampoline()
2483
2484
2485
2486
2487
2488
2489 func Statfs(path string, stat *Statfs_t) (err error) {
2490 var _p0 *byte
2491 _p0, err = BytePtrFromString(path)
2492 if err != nil {
2493 return
2494 }
2495 _, _, e1 := syscall_syscall(funcPC(libc_statfs64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
2496 if e1 != 0 {
2497 err = errnoErr(e1)
2498 }
2499 return
2500 }
2501
2502 func libc_statfs64_trampoline()
2503
2504
2505
2506
View as plain text