Source file
src/syscall/zsyscall_linux_arm64.go
1
2
3
4
5
6 package syscall
7
8 import "unsafe"
9
10
11
12 func faccessat(dirfd int, path string, mode uint32) (err error) {
13 var _p0 *byte
14 _p0, err = BytePtrFromString(path)
15 if err != nil {
16 return
17 }
18 _, _, e1 := Syscall(SYS_FACCESSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
19 if e1 != 0 {
20 err = errnoErr(e1)
21 }
22 return
23 }
24
25
26
27 func faccessat2(dirfd int, path string, mode uint32, flags int) (err error) {
28 var _p0 *byte
29 _p0, err = BytePtrFromString(path)
30 if err != nil {
31 return
32 }
33 _, _, e1 := Syscall6(_SYS_faccessat2, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
34 if e1 != 0 {
35 err = errnoErr(e1)
36 }
37 return
38 }
39
40
41
42 func fchmodat(dirfd int, path string, mode uint32) (err error) {
43 var _p0 *byte
44 _p0, err = BytePtrFromString(path)
45 if err != nil {
46 return
47 }
48 _, _, e1 := Syscall(SYS_FCHMODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
49 if e1 != 0 {
50 err = errnoErr(e1)
51 }
52 return
53 }
54
55
56
57 func linkat(olddirfd int, oldpath string, newdirfd int, newpath string, flags int) (err error) {
58 var _p0 *byte
59 _p0, err = BytePtrFromString(oldpath)
60 if err != nil {
61 return
62 }
63 var _p1 *byte
64 _p1, err = BytePtrFromString(newpath)
65 if err != nil {
66 return
67 }
68 _, _, e1 := Syscall6(SYS_LINKAT, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
69 if e1 != 0 {
70 err = errnoErr(e1)
71 }
72 return
73 }
74
75
76
77 func openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) {
78 var _p0 *byte
79 _p0, err = BytePtrFromString(path)
80 if err != nil {
81 return
82 }
83 r0, _, e1 := Syscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(mode), 0, 0)
84 fd = int(r0)
85 if e1 != 0 {
86 err = errnoErr(e1)
87 }
88 return
89 }
90
91
92
93 func pipe2(p *[2]_C_int, flags int) (err error) {
94 _, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
95 if e1 != 0 {
96 err = errnoErr(e1)
97 }
98 return
99 }
100
101
102
103 func readlinkat(dirfd int, path string, buf []byte) (n int, err error) {
104 var _p0 *byte
105 _p0, err = BytePtrFromString(path)
106 if err != nil {
107 return
108 }
109 var _p1 unsafe.Pointer
110 if len(buf) > 0 {
111 _p1 = unsafe.Pointer(&buf[0])
112 } else {
113 _p1 = unsafe.Pointer(&_zero)
114 }
115 r0, _, e1 := Syscall6(SYS_READLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
116 n = int(r0)
117 if e1 != 0 {
118 err = errnoErr(e1)
119 }
120 return
121 }
122
123
124
125 func symlinkat(oldpath string, newdirfd int, newpath string) (err error) {
126 var _p0 *byte
127 _p0, err = BytePtrFromString(oldpath)
128 if err != nil {
129 return
130 }
131 var _p1 *byte
132 _p1, err = BytePtrFromString(newpath)
133 if err != nil {
134 return
135 }
136 _, _, e1 := Syscall(SYS_SYMLINKAT, uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
137 if e1 != 0 {
138 err = errnoErr(e1)
139 }
140 return
141 }
142
143
144
145 func unlinkat(dirfd int, path string, flags int) (err error) {
146 var _p0 *byte
147 _p0, err = BytePtrFromString(path)
148 if err != nil {
149 return
150 }
151 _, _, e1 := Syscall(SYS_UNLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
152 if e1 != 0 {
153 err = errnoErr(e1)
154 }
155 return
156 }
157
158
159
160 func utimensat(dirfd int, path string, times *[2]Timespec, flag int) (err error) {
161 var _p0 *byte
162 _p0, err = BytePtrFromString(path)
163 if err != nil {
164 return
165 }
166 _, _, e1 := Syscall6(SYS_UTIMENSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), uintptr(flag), 0, 0)
167 if e1 != 0 {
168 err = errnoErr(e1)
169 }
170 return
171 }
172
173
174
175 func Getcwd(buf []byte) (n int, err error) {
176 var _p0 unsafe.Pointer
177 if len(buf) > 0 {
178 _p0 = unsafe.Pointer(&buf[0])
179 } else {
180 _p0 = unsafe.Pointer(&_zero)
181 }
182 r0, _, e1 := Syscall(SYS_GETCWD, uintptr(_p0), uintptr(len(buf)), 0)
183 n = int(r0)
184 if e1 != 0 {
185 err = errnoErr(e1)
186 }
187 return
188 }
189
190
191
192 func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) {
193 r0, _, e1 := Syscall6(SYS_WAIT4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
194 wpid = int(r0)
195 if e1 != 0 {
196 err = errnoErr(e1)
197 }
198 return
199 }
200
201
202
203 func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
204 _, _, e1 := Syscall6(SYS_PTRACE, uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
205 if e1 != 0 {
206 err = errnoErr(e1)
207 }
208 return
209 }
210
211
212
213 func ptracePtr(request int, pid int, addr uintptr, data unsafe.Pointer) (err error) {
214 _, _, e1 := Syscall6(SYS_PTRACE, uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
215 if e1 != 0 {
216 err = errnoErr(e1)
217 }
218 return
219 }
220
221
222
223 func reboot(magic1 uint, magic2 uint, cmd int, arg string) (err error) {
224 var _p0 *byte
225 _p0, err = BytePtrFromString(arg)
226 if err != nil {
227 return
228 }
229 _, _, e1 := Syscall6(SYS_REBOOT, uintptr(magic1), uintptr(magic2), uintptr(cmd), uintptr(unsafe.Pointer(_p0)), 0, 0)
230 if e1 != 0 {
231 err = errnoErr(e1)
232 }
233 return
234 }
235
236
237
238 func mount(source string, target string, fstype string, flags uintptr, data *byte) (err error) {
239 var _p0 *byte
240 _p0, err = BytePtrFromString(source)
241 if err != nil {
242 return
243 }
244 var _p1 *byte
245 _p1, err = BytePtrFromString(target)
246 if err != nil {
247 return
248 }
249 var _p2 *byte
250 _p2, err = BytePtrFromString(fstype)
251 if err != nil {
252 return
253 }
254 _, _, e1 := Syscall6(SYS_MOUNT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(_p2)), uintptr(flags), uintptr(unsafe.Pointer(data)), 0)
255 if e1 != 0 {
256 err = errnoErr(e1)
257 }
258 return
259 }
260
261
262
263 func Acct(path string) (err error) {
264 var _p0 *byte
265 _p0, err = BytePtrFromString(path)
266 if err != nil {
267 return
268 }
269 _, _, e1 := Syscall(SYS_ACCT, uintptr(unsafe.Pointer(_p0)), 0, 0)
270 if e1 != 0 {
271 err = errnoErr(e1)
272 }
273 return
274 }
275
276
277
278 func Adjtimex(buf *Timex) (state int, err error) {
279 r0, _, e1 := Syscall(SYS_ADJTIMEX, uintptr(unsafe.Pointer(buf)), 0, 0)
280 state = int(r0)
281 if e1 != 0 {
282 err = errnoErr(e1)
283 }
284 return
285 }
286
287
288
289 func Chdir(path string) (err error) {
290 var _p0 *byte
291 _p0, err = BytePtrFromString(path)
292 if err != nil {
293 return
294 }
295 _, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
296 if e1 != 0 {
297 err = errnoErr(e1)
298 }
299 return
300 }
301
302
303
304 func Chroot(path string) (err error) {
305 var _p0 *byte
306 _p0, err = BytePtrFromString(path)
307 if err != nil {
308 return
309 }
310 _, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0)
311 if e1 != 0 {
312 err = errnoErr(e1)
313 }
314 return
315 }
316
317
318
319 func Close(fd int) (err error) {
320 _, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
321 if e1 != 0 {
322 err = errnoErr(e1)
323 }
324 return
325 }
326
327
328
329 func Dup(oldfd int) (fd int, err error) {
330 r0, _, e1 := Syscall(SYS_DUP, uintptr(oldfd), 0, 0)
331 fd = int(r0)
332 if e1 != 0 {
333 err = errnoErr(e1)
334 }
335 return
336 }
337
338
339
340 func Dup3(oldfd int, newfd int, flags int) (err error) {
341 _, _, e1 := Syscall(SYS_DUP3, uintptr(oldfd), uintptr(newfd), uintptr(flags))
342 if e1 != 0 {
343 err = errnoErr(e1)
344 }
345 return
346 }
347
348
349
350 func EpollCreate1(flag int) (fd int, err error) {
351 r0, _, e1 := RawSyscall(SYS_EPOLL_CREATE1, uintptr(flag), 0, 0)
352 fd = int(r0)
353 if e1 != 0 {
354 err = errnoErr(e1)
355 }
356 return
357 }
358
359
360
361 func EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) {
362 _, _, e1 := RawSyscall6(SYS_EPOLL_CTL, uintptr(epfd), uintptr(op), uintptr(fd), uintptr(unsafe.Pointer(event)), 0, 0)
363 if e1 != 0 {
364 err = errnoErr(e1)
365 }
366 return
367 }
368
369
370
371 func Fallocate(fd int, mode uint32, off int64, len int64) (err error) {
372 _, _, e1 := Syscall6(SYS_FALLOCATE, uintptr(fd), uintptr(mode), uintptr(off), uintptr(len), 0, 0)
373 if e1 != 0 {
374 err = errnoErr(e1)
375 }
376 return
377 }
378
379
380
381 func Fchdir(fd int) (err error) {
382 _, _, e1 := Syscall(SYS_FCHDIR, uintptr(fd), 0, 0)
383 if e1 != 0 {
384 err = errnoErr(e1)
385 }
386 return
387 }
388
389
390
391 func Fchmod(fd int, mode uint32) (err error) {
392 _, _, e1 := Syscall(SYS_FCHMOD, uintptr(fd), uintptr(mode), 0)
393 if e1 != 0 {
394 err = errnoErr(e1)
395 }
396 return
397 }
398
399
400
401 func Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error) {
402 var _p0 *byte
403 _p0, err = BytePtrFromString(path)
404 if err != nil {
405 return
406 }
407 _, _, e1 := Syscall6(SYS_FCHOWNAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
408 if e1 != 0 {
409 err = errnoErr(e1)
410 }
411 return
412 }
413
414
415
416 func fcntl(fd int, cmd int, arg int) (val int, err error) {
417 r0, _, e1 := Syscall(SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg))
418 val = int(r0)
419 if e1 != 0 {
420 err = errnoErr(e1)
421 }
422 return
423 }
424
425
426
427 func Fdatasync(fd int) (err error) {
428 _, _, e1 := Syscall(SYS_FDATASYNC, uintptr(fd), 0, 0)
429 if e1 != 0 {
430 err = errnoErr(e1)
431 }
432 return
433 }
434
435
436
437 func Flock(fd int, how int) (err error) {
438 _, _, e1 := Syscall(SYS_FLOCK, uintptr(fd), uintptr(how), 0)
439 if e1 != 0 {
440 err = errnoErr(e1)
441 }
442 return
443 }
444
445
446
447 func Fsync(fd int) (err error) {
448 _, _, e1 := Syscall(SYS_FSYNC, uintptr(fd), 0, 0)
449 if e1 != 0 {
450 err = errnoErr(e1)
451 }
452 return
453 }
454
455
456
457 func Getdents(fd int, buf []byte) (n int, err error) {
458 var _p0 unsafe.Pointer
459 if len(buf) > 0 {
460 _p0 = unsafe.Pointer(&buf[0])
461 } else {
462 _p0 = unsafe.Pointer(&_zero)
463 }
464 r0, _, e1 := Syscall(SYS_GETDENTS64, uintptr(fd), uintptr(_p0), uintptr(len(buf)))
465 n = int(r0)
466 if e1 != 0 {
467 err = errnoErr(e1)
468 }
469 return
470 }
471
472
473
474 func Getpgid(pid int) (pgid int, err error) {
475 r0, _, e1 := RawSyscall(SYS_GETPGID, uintptr(pid), 0, 0)
476 pgid = int(r0)
477 if e1 != 0 {
478 err = errnoErr(e1)
479 }
480 return
481 }
482
483
484
485 func Getpid() (pid int) {
486 r0, _ := rawSyscallNoError(SYS_GETPID, 0, 0, 0)
487 pid = int(r0)
488 return
489 }
490
491
492
493 func Getppid() (ppid int) {
494 r0, _ := rawSyscallNoError(SYS_GETPPID, 0, 0, 0)
495 ppid = int(r0)
496 return
497 }
498
499
500
501 func Getpriority(which int, who int) (prio int, err error) {
502 r0, _, e1 := Syscall(SYS_GETPRIORITY, uintptr(which), uintptr(who), 0)
503 prio = int(r0)
504 if e1 != 0 {
505 err = errnoErr(e1)
506 }
507 return
508 }
509
510
511
512 func Getrusage(who int, rusage *Rusage) (err error) {
513 _, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
514 if e1 != 0 {
515 err = errnoErr(e1)
516 }
517 return
518 }
519
520
521
522 func Gettid() (tid int) {
523 r0, _ := rawSyscallNoError(SYS_GETTID, 0, 0, 0)
524 tid = int(r0)
525 return
526 }
527
528
529
530 func Getxattr(path string, attr string, dest []byte) (sz int, err error) {
531 var _p0 *byte
532 _p0, err = BytePtrFromString(path)
533 if err != nil {
534 return
535 }
536 var _p1 *byte
537 _p1, err = BytePtrFromString(attr)
538 if err != nil {
539 return
540 }
541 var _p2 unsafe.Pointer
542 if len(dest) > 0 {
543 _p2 = unsafe.Pointer(&dest[0])
544 } else {
545 _p2 = unsafe.Pointer(&_zero)
546 }
547 r0, _, e1 := Syscall6(SYS_GETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(dest)), 0, 0)
548 sz = int(r0)
549 if e1 != 0 {
550 err = errnoErr(e1)
551 }
552 return
553 }
554
555
556
557 func InotifyAddWatch(fd int, pathname string, mask uint32) (watchdesc int, err error) {
558 var _p0 *byte
559 _p0, err = BytePtrFromString(pathname)
560 if err != nil {
561 return
562 }
563 r0, _, e1 := Syscall(SYS_INOTIFY_ADD_WATCH, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(mask))
564 watchdesc = int(r0)
565 if e1 != 0 {
566 err = errnoErr(e1)
567 }
568 return
569 }
570
571
572
573 func InotifyInit1(flags int) (fd int, err error) {
574 r0, _, e1 := RawSyscall(SYS_INOTIFY_INIT1, uintptr(flags), 0, 0)
575 fd = int(r0)
576 if e1 != 0 {
577 err = errnoErr(e1)
578 }
579 return
580 }
581
582
583
584 func InotifyRmWatch(fd int, watchdesc uint32) (success int, err error) {
585 r0, _, e1 := RawSyscall(SYS_INOTIFY_RM_WATCH, uintptr(fd), uintptr(watchdesc), 0)
586 success = int(r0)
587 if e1 != 0 {
588 err = errnoErr(e1)
589 }
590 return
591 }
592
593
594
595 func Kill(pid int, sig Signal) (err error) {
596 _, _, e1 := RawSyscall(SYS_KILL, uintptr(pid), uintptr(sig), 0)
597 if e1 != 0 {
598 err = errnoErr(e1)
599 }
600 return
601 }
602
603
604
605 func Klogctl(typ int, buf []byte) (n int, err error) {
606 var _p0 unsafe.Pointer
607 if len(buf) > 0 {
608 _p0 = unsafe.Pointer(&buf[0])
609 } else {
610 _p0 = unsafe.Pointer(&_zero)
611 }
612 r0, _, e1 := Syscall(SYS_SYSLOG, uintptr(typ), uintptr(_p0), uintptr(len(buf)))
613 n = int(r0)
614 if e1 != 0 {
615 err = errnoErr(e1)
616 }
617 return
618 }
619
620
621
622 func Listxattr(path string, dest []byte) (sz int, err error) {
623 var _p0 *byte
624 _p0, err = BytePtrFromString(path)
625 if err != nil {
626 return
627 }
628 var _p1 unsafe.Pointer
629 if len(dest) > 0 {
630 _p1 = unsafe.Pointer(&dest[0])
631 } else {
632 _p1 = unsafe.Pointer(&_zero)
633 }
634 r0, _, e1 := Syscall(SYS_LISTXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest)))
635 sz = int(r0)
636 if e1 != 0 {
637 err = errnoErr(e1)
638 }
639 return
640 }
641
642
643
644 func Mkdirat(dirfd int, path string, mode uint32) (err error) {
645 var _p0 *byte
646 _p0, err = BytePtrFromString(path)
647 if err != nil {
648 return
649 }
650 _, _, e1 := Syscall(SYS_MKDIRAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
651 if e1 != 0 {
652 err = errnoErr(e1)
653 }
654 return
655 }
656
657
658
659 func Mknodat(dirfd int, path string, mode uint32, dev int) (err error) {
660 var _p0 *byte
661 _p0, err = BytePtrFromString(path)
662 if err != nil {
663 return
664 }
665 _, _, e1 := Syscall6(SYS_MKNODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev), 0, 0)
666 if e1 != 0 {
667 err = errnoErr(e1)
668 }
669 return
670 }
671
672
673
674 func Nanosleep(time *Timespec, leftover *Timespec) (err error) {
675 _, _, e1 := Syscall(SYS_NANOSLEEP, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
676 if e1 != 0 {
677 err = errnoErr(e1)
678 }
679 return
680 }
681
682
683
684 func PivotRoot(newroot string, putold string) (err error) {
685 var _p0 *byte
686 _p0, err = BytePtrFromString(newroot)
687 if err != nil {
688 return
689 }
690 var _p1 *byte
691 _p1, err = BytePtrFromString(putold)
692 if err != nil {
693 return
694 }
695 _, _, e1 := Syscall(SYS_PIVOT_ROOT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
696 if e1 != 0 {
697 err = errnoErr(e1)
698 }
699 return
700 }
701
702
703
704 func prlimit1(pid int, resource int, newlimit *Rlimit, old *Rlimit) (err error) {
705 _, _, e1 := RawSyscall6(SYS_PRLIMIT64, uintptr(pid), uintptr(resource), uintptr(unsafe.Pointer(newlimit)), uintptr(unsafe.Pointer(old)), 0, 0)
706 if e1 != 0 {
707 err = errnoErr(e1)
708 }
709 return
710 }
711
712
713
714 func read(fd int, p []byte) (n int, err error) {
715 var _p0 unsafe.Pointer
716 if len(p) > 0 {
717 _p0 = unsafe.Pointer(&p[0])
718 } else {
719 _p0 = unsafe.Pointer(&_zero)
720 }
721 r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p)))
722 n = int(r0)
723 if e1 != 0 {
724 err = errnoErr(e1)
725 }
726 return
727 }
728
729
730
731 func Removexattr(path string, attr string) (err error) {
732 var _p0 *byte
733 _p0, err = BytePtrFromString(path)
734 if err != nil {
735 return
736 }
737 var _p1 *byte
738 _p1, err = BytePtrFromString(attr)
739 if err != nil {
740 return
741 }
742 _, _, e1 := Syscall(SYS_REMOVEXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
743 if e1 != 0 {
744 err = errnoErr(e1)
745 }
746 return
747 }
748
749
750
751 func Setdomainname(p []byte) (err error) {
752 var _p0 unsafe.Pointer
753 if len(p) > 0 {
754 _p0 = unsafe.Pointer(&p[0])
755 } else {
756 _p0 = unsafe.Pointer(&_zero)
757 }
758 _, _, e1 := Syscall(SYS_SETDOMAINNAME, uintptr(_p0), uintptr(len(p)), 0)
759 if e1 != 0 {
760 err = errnoErr(e1)
761 }
762 return
763 }
764
765
766
767 func Sethostname(p []byte) (err error) {
768 var _p0 unsafe.Pointer
769 if len(p) > 0 {
770 _p0 = unsafe.Pointer(&p[0])
771 } else {
772 _p0 = unsafe.Pointer(&_zero)
773 }
774 _, _, e1 := Syscall(SYS_SETHOSTNAME, uintptr(_p0), uintptr(len(p)), 0)
775 if e1 != 0 {
776 err = errnoErr(e1)
777 }
778 return
779 }
780
781
782
783 func Setpgid(pid int, pgid int) (err error) {
784 _, _, e1 := RawSyscall(SYS_SETPGID, uintptr(pid), uintptr(pgid), 0)
785 if e1 != 0 {
786 err = errnoErr(e1)
787 }
788 return
789 }
790
791
792
793 func Setsid() (pid int, err error) {
794 r0, _, e1 := RawSyscall(SYS_SETSID, 0, 0, 0)
795 pid = int(r0)
796 if e1 != 0 {
797 err = errnoErr(e1)
798 }
799 return
800 }
801
802
803
804 func Settimeofday(tv *Timeval) (err error) {
805 _, _, e1 := RawSyscall(SYS_SETTIMEOFDAY, uintptr(unsafe.Pointer(tv)), 0, 0)
806 if e1 != 0 {
807 err = errnoErr(e1)
808 }
809 return
810 }
811
812
813
814 func Setpriority(which int, who int, prio int) (err error) {
815 _, _, e1 := Syscall(SYS_SETPRIORITY, uintptr(which), uintptr(who), uintptr(prio))
816 if e1 != 0 {
817 err = errnoErr(e1)
818 }
819 return
820 }
821
822
823
824 func Setxattr(path string, attr string, data []byte, flags int) (err error) {
825 var _p0 *byte
826 _p0, err = BytePtrFromString(path)
827 if err != nil {
828 return
829 }
830 var _p1 *byte
831 _p1, err = BytePtrFromString(attr)
832 if err != nil {
833 return
834 }
835 var _p2 unsafe.Pointer
836 if len(data) > 0 {
837 _p2 = unsafe.Pointer(&data[0])
838 } else {
839 _p2 = unsafe.Pointer(&_zero)
840 }
841 _, _, e1 := Syscall6(SYS_SETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(data)), uintptr(flags), 0)
842 if e1 != 0 {
843 err = errnoErr(e1)
844 }
845 return
846 }
847
848
849
850 func Sync() {
851 Syscall(SYS_SYNC, 0, 0, 0)
852 return
853 }
854
855
856
857 func Sysinfo(info *Sysinfo_t) (err error) {
858 _, _, e1 := RawSyscall(SYS_SYSINFO, uintptr(unsafe.Pointer(info)), 0, 0)
859 if e1 != 0 {
860 err = errnoErr(e1)
861 }
862 return
863 }
864
865
866
867 func Tee(rfd int, wfd int, len int, flags int) (n int64, err error) {
868 r0, _, e1 := Syscall6(SYS_TEE, uintptr(rfd), uintptr(wfd), uintptr(len), uintptr(flags), 0, 0)
869 n = int64(r0)
870 if e1 != 0 {
871 err = errnoErr(e1)
872 }
873 return
874 }
875
876
877
878 func Tgkill(tgid int, tid int, sig Signal) (err error) {
879 _, _, e1 := RawSyscall(SYS_TGKILL, uintptr(tgid), uintptr(tid), uintptr(sig))
880 if e1 != 0 {
881 err = errnoErr(e1)
882 }
883 return
884 }
885
886
887
888 func Times(tms *Tms) (ticks uintptr, err error) {
889 r0, _, e1 := RawSyscall(SYS_TIMES, uintptr(unsafe.Pointer(tms)), 0, 0)
890 ticks = uintptr(r0)
891 if e1 != 0 {
892 err = errnoErr(e1)
893 }
894 return
895 }
896
897
898
899 func Umask(mask int) (oldmask int) {
900 r0, _ := rawSyscallNoError(SYS_UMASK, uintptr(mask), 0, 0)
901 oldmask = int(r0)
902 return
903 }
904
905
906
907 func Uname(buf *Utsname) (err error) {
908 _, _, e1 := RawSyscall(SYS_UNAME, uintptr(unsafe.Pointer(buf)), 0, 0)
909 if e1 != 0 {
910 err = errnoErr(e1)
911 }
912 return
913 }
914
915
916
917 func Unmount(target string, flags int) (err error) {
918 var _p0 *byte
919 _p0, err = BytePtrFromString(target)
920 if err != nil {
921 return
922 }
923 _, _, e1 := Syscall(SYS_UMOUNT2, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
924 if e1 != 0 {
925 err = errnoErr(e1)
926 }
927 return
928 }
929
930
931
932 func Unshare(flags int) (err error) {
933 _, _, e1 := Syscall(SYS_UNSHARE, uintptr(flags), 0, 0)
934 if e1 != 0 {
935 err = errnoErr(e1)
936 }
937 return
938 }
939
940
941
942 func write(fd int, p []byte) (n int, err error) {
943 var _p0 unsafe.Pointer
944 if len(p) > 0 {
945 _p0 = unsafe.Pointer(&p[0])
946 } else {
947 _p0 = unsafe.Pointer(&_zero)
948 }
949 r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)))
950 n = int(r0)
951 if e1 != 0 {
952 err = errnoErr(e1)
953 }
954 return
955 }
956
957
958
959 func exitThread(code int) (err error) {
960 _, _, e1 := Syscall(SYS_EXIT, uintptr(code), 0, 0)
961 if e1 != 0 {
962 err = errnoErr(e1)
963 }
964 return
965 }
966
967
968
969 func readlen(fd int, p *byte, np int) (n int, err error) {
970 r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(p)), uintptr(np))
971 n = int(r0)
972 if e1 != 0 {
973 err = errnoErr(e1)
974 }
975 return
976 }
977
978
979
980 func writelen(fd int, p *byte, np int) (n int, err error) {
981 r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(unsafe.Pointer(p)), uintptr(np))
982 n = int(r0)
983 if e1 != 0 {
984 err = errnoErr(e1)
985 }
986 return
987 }
988
989
990
991 func munmap(addr uintptr, length uintptr) (err error) {
992 _, _, e1 := Syscall(SYS_MUNMAP, uintptr(addr), uintptr(length), 0)
993 if e1 != 0 {
994 err = errnoErr(e1)
995 }
996 return
997 }
998
999
1000
1001 func Madvise(b []byte, advice int) (err error) {
1002 var _p0 unsafe.Pointer
1003 if len(b) > 0 {
1004 _p0 = unsafe.Pointer(&b[0])
1005 } else {
1006 _p0 = unsafe.Pointer(&_zero)
1007 }
1008 _, _, e1 := Syscall(SYS_MADVISE, uintptr(_p0), uintptr(len(b)), uintptr(advice))
1009 if e1 != 0 {
1010 err = errnoErr(e1)
1011 }
1012 return
1013 }
1014
1015
1016
1017 func Mprotect(b []byte, prot int) (err error) {
1018 var _p0 unsafe.Pointer
1019 if len(b) > 0 {
1020 _p0 = unsafe.Pointer(&b[0])
1021 } else {
1022 _p0 = unsafe.Pointer(&_zero)
1023 }
1024 _, _, e1 := Syscall(SYS_MPROTECT, uintptr(_p0), uintptr(len(b)), uintptr(prot))
1025 if e1 != 0 {
1026 err = errnoErr(e1)
1027 }
1028 return
1029 }
1030
1031
1032
1033 func Mlock(b []byte) (err error) {
1034 var _p0 unsafe.Pointer
1035 if len(b) > 0 {
1036 _p0 = unsafe.Pointer(&b[0])
1037 } else {
1038 _p0 = unsafe.Pointer(&_zero)
1039 }
1040 _, _, e1 := Syscall(SYS_MLOCK, uintptr(_p0), uintptr(len(b)), 0)
1041 if e1 != 0 {
1042 err = errnoErr(e1)
1043 }
1044 return
1045 }
1046
1047
1048
1049 func Munlock(b []byte) (err error) {
1050 var _p0 unsafe.Pointer
1051 if len(b) > 0 {
1052 _p0 = unsafe.Pointer(&b[0])
1053 } else {
1054 _p0 = unsafe.Pointer(&_zero)
1055 }
1056 _, _, e1 := Syscall(SYS_MUNLOCK, uintptr(_p0), uintptr(len(b)), 0)
1057 if e1 != 0 {
1058 err = errnoErr(e1)
1059 }
1060 return
1061 }
1062
1063
1064
1065 func Mlockall(flags int) (err error) {
1066 _, _, e1 := Syscall(SYS_MLOCKALL, uintptr(flags), 0, 0)
1067 if e1 != 0 {
1068 err = errnoErr(e1)
1069 }
1070 return
1071 }
1072
1073
1074
1075 func Munlockall() (err error) {
1076 _, _, e1 := Syscall(SYS_MUNLOCKALL, 0, 0, 0)
1077 if e1 != 0 {
1078 err = errnoErr(e1)
1079 }
1080 return
1081 }
1082
1083
1084
1085 func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) {
1086 var _p0 unsafe.Pointer
1087 if len(events) > 0 {
1088 _p0 = unsafe.Pointer(&events[0])
1089 } else {
1090 _p0 = unsafe.Pointer(&_zero)
1091 }
1092 r0, _, e1 := Syscall6(SYS_EPOLL_PWAIT, uintptr(epfd), uintptr(_p0), uintptr(len(events)), uintptr(msec), 0, 0)
1093 n = int(r0)
1094 if e1 != 0 {
1095 err = errnoErr(e1)
1096 }
1097 return
1098 }
1099
1100
1101
1102 func Fchown(fd int, uid int, gid int) (err error) {
1103 _, _, e1 := Syscall(SYS_FCHOWN, uintptr(fd), uintptr(uid), uintptr(gid))
1104 if e1 != 0 {
1105 err = errnoErr(e1)
1106 }
1107 return
1108 }
1109
1110
1111
1112 func Fstat(fd int, stat *Stat_t) (err error) {
1113 _, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
1114 if e1 != 0 {
1115 err = errnoErr(e1)
1116 }
1117 return
1118 }
1119
1120
1121
1122 func fstatat(dirfd int, path string, stat *Stat_t, flags int) (err error) {
1123 var _p0 *byte
1124 _p0, err = BytePtrFromString(path)
1125 if err != nil {
1126 return
1127 }
1128 _, _, e1 := Syscall6(SYS_FSTATAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
1129 if e1 != 0 {
1130 err = errnoErr(e1)
1131 }
1132 return
1133 }
1134
1135
1136
1137 func Fstatfs(fd int, buf *Statfs_t) (err error) {
1138 _, _, e1 := Syscall(SYS_FSTATFS, uintptr(fd), uintptr(unsafe.Pointer(buf)), 0)
1139 if e1 != 0 {
1140 err = errnoErr(e1)
1141 }
1142 return
1143 }
1144
1145
1146
1147 func Ftruncate(fd int, length int64) (err error) {
1148 _, _, e1 := Syscall(SYS_FTRUNCATE, uintptr(fd), uintptr(length), 0)
1149 if e1 != 0 {
1150 err = errnoErr(e1)
1151 }
1152 return
1153 }
1154
1155
1156
1157 func Getegid() (egid int) {
1158 r0, _ := rawSyscallNoError(SYS_GETEGID, 0, 0, 0)
1159 egid = int(r0)
1160 return
1161 }
1162
1163
1164
1165 func Geteuid() (euid int) {
1166 r0, _ := rawSyscallNoError(SYS_GETEUID, 0, 0, 0)
1167 euid = int(r0)
1168 return
1169 }
1170
1171
1172
1173 func Getgid() (gid int) {
1174 r0, _ := rawSyscallNoError(SYS_GETGID, 0, 0, 0)
1175 gid = int(r0)
1176 return
1177 }
1178
1179
1180
1181 func getrlimit(resource int, rlim *Rlimit) (err error) {
1182 _, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0)
1183 if e1 != 0 {
1184 err = errnoErr(e1)
1185 }
1186 return
1187 }
1188
1189
1190
1191 func Getuid() (uid int) {
1192 r0, _ := rawSyscallNoError(SYS_GETUID, 0, 0, 0)
1193 uid = int(r0)
1194 return
1195 }
1196
1197
1198
1199 func Listen(s int, n int) (err error) {
1200 _, _, e1 := Syscall(SYS_LISTEN, uintptr(s), uintptr(n), 0)
1201 if e1 != 0 {
1202 err = errnoErr(e1)
1203 }
1204 return
1205 }
1206
1207
1208
1209 func pread(fd int, p []byte, offset int64) (n int, err error) {
1210 var _p0 unsafe.Pointer
1211 if len(p) > 0 {
1212 _p0 = unsafe.Pointer(&p[0])
1213 } else {
1214 _p0 = unsafe.Pointer(&_zero)
1215 }
1216 r0, _, e1 := Syscall6(SYS_PREAD64, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
1217 n = int(r0)
1218 if e1 != 0 {
1219 err = errnoErr(e1)
1220 }
1221 return
1222 }
1223
1224
1225
1226 func pwrite(fd int, p []byte, offset int64) (n int, err error) {
1227 var _p0 unsafe.Pointer
1228 if len(p) > 0 {
1229 _p0 = unsafe.Pointer(&p[0])
1230 } else {
1231 _p0 = unsafe.Pointer(&_zero)
1232 }
1233 r0, _, e1 := Syscall6(SYS_PWRITE64, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
1234 n = int(r0)
1235 if e1 != 0 {
1236 err = errnoErr(e1)
1237 }
1238 return
1239 }
1240
1241
1242
1243 func Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error) {
1244 var _p0 *byte
1245 _p0, err = BytePtrFromString(oldpath)
1246 if err != nil {
1247 return
1248 }
1249 var _p1 *byte
1250 _p1, err = BytePtrFromString(newpath)
1251 if err != nil {
1252 return
1253 }
1254 _, _, e1 := Syscall6(SYS_RENAMEAT, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)), 0, 0)
1255 if e1 != 0 {
1256 err = errnoErr(e1)
1257 }
1258 return
1259 }
1260
1261
1262
1263 func Seek(fd int, offset int64, whence int) (off int64, err error) {
1264 r0, _, e1 := Syscall(SYS_LSEEK, uintptr(fd), uintptr(offset), uintptr(whence))
1265 off = int64(r0)
1266 if e1 != 0 {
1267 err = errnoErr(e1)
1268 }
1269 return
1270 }
1271
1272
1273
1274 func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
1275 r0, _, e1 := Syscall6(SYS_SENDFILE, uintptr(outfd), uintptr(infd), uintptr(unsafe.Pointer(offset)), uintptr(count), 0, 0)
1276 written = int(r0)
1277 if e1 != 0 {
1278 err = errnoErr(e1)
1279 }
1280 return
1281 }
1282
1283
1284
1285 func Setfsgid(gid int) (err error) {
1286 _, _, e1 := Syscall(SYS_SETFSGID, uintptr(gid), 0, 0)
1287 if e1 != 0 {
1288 err = errnoErr(e1)
1289 }
1290 return
1291 }
1292
1293
1294
1295 func Setfsuid(uid int) (err error) {
1296 _, _, e1 := Syscall(SYS_SETFSUID, uintptr(uid), 0, 0)
1297 if e1 != 0 {
1298 err = errnoErr(e1)
1299 }
1300 return
1301 }
1302
1303
1304
1305 func setrlimit1(resource int, rlim *Rlimit) (err error) {
1306 _, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0)
1307 if e1 != 0 {
1308 err = errnoErr(e1)
1309 }
1310 return
1311 }
1312
1313
1314
1315 func Shutdown(fd int, how int) (err error) {
1316 _, _, e1 := Syscall(SYS_SHUTDOWN, uintptr(fd), uintptr(how), 0)
1317 if e1 != 0 {
1318 err = errnoErr(e1)
1319 }
1320 return
1321 }
1322
1323
1324
1325 func Splice(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int64, err error) {
1326 r0, _, e1 := Syscall6(SYS_SPLICE, uintptr(rfd), uintptr(unsafe.Pointer(roff)), uintptr(wfd), uintptr(unsafe.Pointer(woff)), uintptr(len), uintptr(flags))
1327 n = int64(r0)
1328 if e1 != 0 {
1329 err = errnoErr(e1)
1330 }
1331 return
1332 }
1333
1334
1335
1336 func Statfs(path string, buf *Statfs_t) (err error) {
1337 var _p0 *byte
1338 _p0, err = BytePtrFromString(path)
1339 if err != nil {
1340 return
1341 }
1342 _, _, e1 := Syscall(SYS_STATFS, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(buf)), 0)
1343 if e1 != 0 {
1344 err = errnoErr(e1)
1345 }
1346 return
1347 }
1348
1349
1350
1351 func SyncFileRange(fd int, off int64, n int64, flags int) (err error) {
1352 _, _, e1 := Syscall6(SYS_SYNC_FILE_RANGE2, uintptr(fd), uintptr(off), uintptr(n), uintptr(flags), 0, 0)
1353 if e1 != 0 {
1354 err = errnoErr(e1)
1355 }
1356 return
1357 }
1358
1359
1360
1361 func Truncate(path string, length int64) (err error) {
1362 var _p0 *byte
1363 _p0, err = BytePtrFromString(path)
1364 if err != nil {
1365 return
1366 }
1367 _, _, e1 := Syscall(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
1368 if e1 != 0 {
1369 err = errnoErr(e1)
1370 }
1371 return
1372 }
1373
1374
1375
1376 func accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) {
1377 r0, _, e1 := Syscall6(SYS_ACCEPT4, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
1378 fd = int(r0)
1379 if e1 != 0 {
1380 err = errnoErr(e1)
1381 }
1382 return
1383 }
1384
1385
1386
1387 func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
1388 _, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen))
1389 if e1 != 0 {
1390 err = errnoErr(e1)
1391 }
1392 return
1393 }
1394
1395
1396
1397 func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
1398 _, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen))
1399 if e1 != 0 {
1400 err = errnoErr(e1)
1401 }
1402 return
1403 }
1404
1405
1406
1407 func getgroups(n int, list *_Gid_t) (nn int, err error) {
1408 r0, _, e1 := RawSyscall(SYS_GETGROUPS, uintptr(n), uintptr(unsafe.Pointer(list)), 0)
1409 nn = int(r0)
1410 if e1 != 0 {
1411 err = errnoErr(e1)
1412 }
1413 return
1414 }
1415
1416
1417
1418 func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
1419 _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
1420 if e1 != 0 {
1421 err = errnoErr(e1)
1422 }
1423 return
1424 }
1425
1426
1427
1428 func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
1429 _, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
1430 if e1 != 0 {
1431 err = errnoErr(e1)
1432 }
1433 return
1434 }
1435
1436
1437
1438 func socket(domain int, typ int, proto int) (fd int, err error) {
1439 r0, _, e1 := RawSyscall(SYS_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto))
1440 fd = int(r0)
1441 if e1 != 0 {
1442 err = errnoErr(e1)
1443 }
1444 return
1445 }
1446
1447
1448
1449 func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
1450 _, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
1451 if e1 != 0 {
1452 err = errnoErr(e1)
1453 }
1454 return
1455 }
1456
1457
1458
1459 func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
1460 _, _, e1 := RawSyscall(SYS_GETPEERNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
1461 if e1 != 0 {
1462 err = errnoErr(e1)
1463 }
1464 return
1465 }
1466
1467
1468
1469 func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
1470 _, _, e1 := RawSyscall(SYS_GETSOCKNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
1471 if e1 != 0 {
1472 err = errnoErr(e1)
1473 }
1474 return
1475 }
1476
1477
1478
1479 func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) {
1480 var _p0 unsafe.Pointer
1481 if len(p) > 0 {
1482 _p0 = unsafe.Pointer(&p[0])
1483 } else {
1484 _p0 = unsafe.Pointer(&_zero)
1485 }
1486 r0, _, e1 := Syscall6(SYS_RECVFROM, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
1487 n = int(r0)
1488 if e1 != 0 {
1489 err = errnoErr(e1)
1490 }
1491 return
1492 }
1493
1494
1495
1496 func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
1497 var _p0 unsafe.Pointer
1498 if len(buf) > 0 {
1499 _p0 = unsafe.Pointer(&buf[0])
1500 } else {
1501 _p0 = unsafe.Pointer(&_zero)
1502 }
1503 _, _, e1 := Syscall6(SYS_SENDTO, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
1504 if e1 != 0 {
1505 err = errnoErr(e1)
1506 }
1507 return
1508 }
1509
1510
1511
1512 func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
1513 r0, _, e1 := Syscall(SYS_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
1514 n = int(r0)
1515 if e1 != 0 {
1516 err = errnoErr(e1)
1517 }
1518 return
1519 }
1520
1521
1522
1523 func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
1524 r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
1525 n = int(r0)
1526 if e1 != 0 {
1527 err = errnoErr(e1)
1528 }
1529 return
1530 }
1531
1532
1533
1534 func mmap(addr uintptr, length uintptr, prot int, flags int, fd int, offset int64) (xaddr uintptr, err error) {
1535 r0, _, e1 := Syscall6(SYS_MMAP, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flags), uintptr(fd), uintptr(offset))
1536 xaddr = uintptr(r0)
1537 if e1 != 0 {
1538 err = errnoErr(e1)
1539 }
1540 return
1541 }
1542
1543
1544
1545 func pselect(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timespec, sigmask *sigset_t) (n int, err error) {
1546 r0, _, e1 := Syscall6(SYS_PSELECT6, uintptr(nfd), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), uintptr(unsafe.Pointer(sigmask)))
1547 n = int(r0)
1548 if e1 != 0 {
1549 err = errnoErr(e1)
1550 }
1551 return
1552 }
1553
1554
1555
1556 func Gettimeofday(tv *Timeval) (err error) {
1557 _, _, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tv)), 0, 0)
1558 if e1 != 0 {
1559 err = errnoErr(e1)
1560 }
1561 return
1562 }
1563
1564
1565
1566 func ppoll(fds *pollFd, nfds int, timeout *Timespec, sigmask *sigset_t) (n int, err error) {
1567 r0, _, e1 := Syscall6(SYS_PPOLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(unsafe.Pointer(timeout)), uintptr(unsafe.Pointer(sigmask)), 0, 0)
1568 n = int(r0)
1569 if e1 != 0 {
1570 err = errnoErr(e1)
1571 }
1572 return
1573 }
1574
View as plain text