Source file
src/syscall/zsyscall_openbsd_mips64.go
Documentation: syscall
1
2
3
4
5
6
7 package syscall
8
9 import "unsafe"
10
11
12
13 func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
14 r0, _, e1 := RawSyscall(SYS_GETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
15 n = int(r0)
16 if e1 != 0 {
17 err = errnoErr(e1)
18 }
19 return
20 }
21
22
23
24 func setgroups(ngid int, gid *_Gid_t) (err error) {
25 _, _, e1 := RawSyscall(SYS_SETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
26 if e1 != 0 {
27 err = errnoErr(e1)
28 }
29 return
30 }
31
32
33
34 func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) {
35 r0, _, e1 := Syscall6(SYS_WAIT4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
36 wpid = int(r0)
37 if e1 != 0 {
38 err = errnoErr(e1)
39 }
40 return
41 }
42
43
44
45 func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
46 r0, _, e1 := Syscall(SYS_ACCEPT, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
47 fd = int(r0)
48 if e1 != 0 {
49 err = errnoErr(e1)
50 }
51 return
52 }
53
54
55
56 func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
57 _, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen))
58 if e1 != 0 {
59 err = errnoErr(e1)
60 }
61 return
62 }
63
64
65
66 func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
67 _, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen))
68 if e1 != 0 {
69 err = errnoErr(e1)
70 }
71 return
72 }
73
74
75
76 func socket(domain int, typ int, proto int) (fd int, err error) {
77 r0, _, e1 := RawSyscall(SYS_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto))
78 fd = int(r0)
79 if e1 != 0 {
80 err = errnoErr(e1)
81 }
82 return
83 }
84
85
86
87 func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
88 _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
89 if e1 != 0 {
90 err = errnoErr(e1)
91 }
92 return
93 }
94
95
96
97 func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
98 _, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
99 if e1 != 0 {
100 err = errnoErr(e1)
101 }
102 return
103 }
104
105
106
107 func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
108 _, _, e1 := RawSyscall(SYS_GETPEERNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
109 if e1 != 0 {
110 err = errnoErr(e1)
111 }
112 return
113 }
114
115
116
117 func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
118 _, _, e1 := RawSyscall(SYS_GETSOCKNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
119 if e1 != 0 {
120 err = errnoErr(e1)
121 }
122 return
123 }
124
125
126
127 func Shutdown(s int, how int) (err error) {
128 _, _, e1 := Syscall(SYS_SHUTDOWN, uintptr(s), uintptr(how), 0)
129 if e1 != 0 {
130 err = errnoErr(e1)
131 }
132 return
133 }
134
135
136
137 func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
138 _, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
139 if e1 != 0 {
140 err = errnoErr(e1)
141 }
142 return
143 }
144
145
146
147 func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) {
148 var _p0 unsafe.Pointer
149 if len(p) > 0 {
150 _p0 = unsafe.Pointer(&p[0])
151 } else {
152 _p0 = unsafe.Pointer(&_zero)
153 }
154 r0, _, e1 := Syscall6(SYS_RECVFROM, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
155 n = int(r0)
156 if e1 != 0 {
157 err = errnoErr(e1)
158 }
159 return
160 }
161
162
163
164 func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
165 var _p0 unsafe.Pointer
166 if len(buf) > 0 {
167 _p0 = unsafe.Pointer(&buf[0])
168 } else {
169 _p0 = unsafe.Pointer(&_zero)
170 }
171 _, _, e1 := Syscall6(SYS_SENDTO, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
172 if e1 != 0 {
173 err = errnoErr(e1)
174 }
175 return
176 }
177
178
179
180 func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
181 r0, _, e1 := Syscall(SYS_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
182 n = int(r0)
183 if e1 != 0 {
184 err = errnoErr(e1)
185 }
186 return
187 }
188
189
190
191 func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
192 r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
193 n = int(r0)
194 if e1 != 0 {
195 err = errnoErr(e1)
196 }
197 return
198 }
199
200
201
202 func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
203 r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
204 n = int(r0)
205 if e1 != 0 {
206 err = errnoErr(e1)
207 }
208 return
209 }
210
211
212
213 func utimes(path string, timeval *[2]Timeval) (err error) {
214 var _p0 *byte
215 _p0, err = BytePtrFromString(path)
216 if err != nil {
217 return
218 }
219 _, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
220 if e1 != 0 {
221 err = errnoErr(e1)
222 }
223 return
224 }
225
226
227
228 func futimes(fd int, timeval *[2]Timeval) (err error) {
229 _, _, e1 := Syscall(SYS_FUTIMES, uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
230 if e1 != 0 {
231 err = errnoErr(e1)
232 }
233 return
234 }
235
236
237
238 func fcntl(fd int, cmd int, arg int) (val int, err error) {
239 r0, _, e1 := Syscall(SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg))
240 val = int(r0)
241 if e1 != 0 {
242 err = errnoErr(e1)
243 }
244 return
245 }
246
247
248
249 func pipe2(p *[2]_C_int, flags int) (err error) {
250 _, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
251 if e1 != 0 {
252 err = errnoErr(e1)
253 }
254 return
255 }
256
257
258
259 func accept4(fd int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (nfd int, err error) {
260 r0, _, e1 := Syscall6(SYS_ACCEPT4, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
261 nfd = int(r0)
262 if e1 != 0 {
263 err = errnoErr(e1)
264 }
265 return
266 }
267
268
269
270 func getdents(fd int, buf []byte) (n int, err error) {
271 var _p0 unsafe.Pointer
272 if len(buf) > 0 {
273 _p0 = unsafe.Pointer(&buf[0])
274 } else {
275 _p0 = unsafe.Pointer(&_zero)
276 }
277 r0, _, e1 := Syscall(SYS_GETDENTS, uintptr(fd), uintptr(_p0), uintptr(len(buf)))
278 n = int(r0)
279 if e1 != 0 {
280 err = errnoErr(e1)
281 }
282 return
283 }
284
285
286
287 func Access(path string, mode uint32) (err error) {
288 var _p0 *byte
289 _p0, err = BytePtrFromString(path)
290 if err != nil {
291 return
292 }
293 _, _, e1 := Syscall(SYS_ACCESS, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
294 if e1 != 0 {
295 err = errnoErr(e1)
296 }
297 return
298 }
299
300
301
302 func Adjtime(delta *Timeval, olddelta *Timeval) (err error) {
303 _, _, e1 := Syscall(SYS_ADJTIME, uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
304 if e1 != 0 {
305 err = errnoErr(e1)
306 }
307 return
308 }
309
310
311
312 func Chdir(path string) (err error) {
313 var _p0 *byte
314 _p0, err = BytePtrFromString(path)
315 if err != nil {
316 return
317 }
318 _, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
319 if e1 != 0 {
320 err = errnoErr(e1)
321 }
322 return
323 }
324
325
326
327 func Chflags(path string, flags int) (err error) {
328 var _p0 *byte
329 _p0, err = BytePtrFromString(path)
330 if err != nil {
331 return
332 }
333 _, _, e1 := Syscall(SYS_CHFLAGS, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
334 if e1 != 0 {
335 err = errnoErr(e1)
336 }
337 return
338 }
339
340
341
342 func Chmod(path string, mode uint32) (err error) {
343 var _p0 *byte
344 _p0, err = BytePtrFromString(path)
345 if err != nil {
346 return
347 }
348 _, _, e1 := Syscall(SYS_CHMOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
349 if e1 != 0 {
350 err = errnoErr(e1)
351 }
352 return
353 }
354
355
356
357 func Chown(path string, uid int, gid int) (err error) {
358 var _p0 *byte
359 _p0, err = BytePtrFromString(path)
360 if err != nil {
361 return
362 }
363 _, _, e1 := Syscall(SYS_CHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
364 if e1 != 0 {
365 err = errnoErr(e1)
366 }
367 return
368 }
369
370
371
372 func Chroot(path string) (err error) {
373 var _p0 *byte
374 _p0, err = BytePtrFromString(path)
375 if err != nil {
376 return
377 }
378 _, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0)
379 if e1 != 0 {
380 err = errnoErr(e1)
381 }
382 return
383 }
384
385
386
387 func Close(fd int) (err error) {
388 _, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
389 if e1 != 0 {
390 err = errnoErr(e1)
391 }
392 return
393 }
394
395
396
397 func Dup(fd int) (nfd int, err error) {
398 r0, _, e1 := Syscall(SYS_DUP, uintptr(fd), 0, 0)
399 nfd = int(r0)
400 if e1 != 0 {
401 err = errnoErr(e1)
402 }
403 return
404 }
405
406
407
408 func Dup2(from int, to int) (err error) {
409 _, _, e1 := Syscall(SYS_DUP2, uintptr(from), uintptr(to), 0)
410 if e1 != 0 {
411 err = errnoErr(e1)
412 }
413 return
414 }
415
416
417
418 func Fchdir(fd int) (err error) {
419 _, _, e1 := Syscall(SYS_FCHDIR, uintptr(fd), 0, 0)
420 if e1 != 0 {
421 err = errnoErr(e1)
422 }
423 return
424 }
425
426
427
428 func Fchflags(fd int, flags int) (err error) {
429 _, _, e1 := Syscall(SYS_FCHFLAGS, uintptr(fd), uintptr(flags), 0)
430 if e1 != 0 {
431 err = errnoErr(e1)
432 }
433 return
434 }
435
436
437
438 func Fchmod(fd int, mode uint32) (err error) {
439 _, _, e1 := Syscall(SYS_FCHMOD, uintptr(fd), uintptr(mode), 0)
440 if e1 != 0 {
441 err = errnoErr(e1)
442 }
443 return
444 }
445
446
447
448 func Fchown(fd int, uid int, gid int) (err error) {
449 _, _, e1 := Syscall(SYS_FCHOWN, uintptr(fd), uintptr(uid), uintptr(gid))
450 if e1 != 0 {
451 err = errnoErr(e1)
452 }
453 return
454 }
455
456
457
458 func Flock(fd int, how int) (err error) {
459 _, _, e1 := Syscall(SYS_FLOCK, uintptr(fd), uintptr(how), 0)
460 if e1 != 0 {
461 err = errnoErr(e1)
462 }
463 return
464 }
465
466
467
468 func Fpathconf(fd int, name int) (val int, err error) {
469 r0, _, e1 := Syscall(SYS_FPATHCONF, uintptr(fd), uintptr(name), 0)
470 val = int(r0)
471 if e1 != 0 {
472 err = errnoErr(e1)
473 }
474 return
475 }
476
477
478
479 func Fstat(fd int, stat *Stat_t) (err error) {
480 _, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
481 if e1 != 0 {
482 err = errnoErr(e1)
483 }
484 return
485 }
486
487
488
489 func Fstatfs(fd int, stat *Statfs_t) (err error) {
490 _, _, e1 := Syscall(SYS_FSTATFS, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
491 if e1 != 0 {
492 err = errnoErr(e1)
493 }
494 return
495 }
496
497
498
499 func Fsync(fd int) (err error) {
500 _, _, e1 := Syscall(SYS_FSYNC, uintptr(fd), 0, 0)
501 if e1 != 0 {
502 err = errnoErr(e1)
503 }
504 return
505 }
506
507
508
509 func Ftruncate(fd int, length int64) (err error) {
510 _, _, e1 := Syscall(SYS_FTRUNCATE, uintptr(fd), 0, uintptr(length))
511 if e1 != 0 {
512 err = errnoErr(e1)
513 }
514 return
515 }
516
517
518
519 func Getegid() (egid int) {
520 r0, _, _ := RawSyscall(SYS_GETEGID, 0, 0, 0)
521 egid = int(r0)
522 return
523 }
524
525
526
527 func Geteuid() (uid int) {
528 r0, _, _ := RawSyscall(SYS_GETEUID, 0, 0, 0)
529 uid = int(r0)
530 return
531 }
532
533
534
535 func Getgid() (gid int) {
536 r0, _, _ := RawSyscall(SYS_GETGID, 0, 0, 0)
537 gid = int(r0)
538 return
539 }
540
541
542
543 func Getpgid(pid int) (pgid int, err error) {
544 r0, _, e1 := RawSyscall(SYS_GETPGID, uintptr(pid), 0, 0)
545 pgid = int(r0)
546 if e1 != 0 {
547 err = errnoErr(e1)
548 }
549 return
550 }
551
552
553
554 func Getpgrp() (pgrp int) {
555 r0, _, _ := RawSyscall(SYS_GETPGRP, 0, 0, 0)
556 pgrp = int(r0)
557 return
558 }
559
560
561
562 func Getpid() (pid int) {
563 r0, _, _ := RawSyscall(SYS_GETPID, 0, 0, 0)
564 pid = int(r0)
565 return
566 }
567
568
569
570 func Getppid() (ppid int) {
571 r0, _, _ := RawSyscall(SYS_GETPPID, 0, 0, 0)
572 ppid = int(r0)
573 return
574 }
575
576
577
578 func Getpriority(which int, who int) (prio int, err error) {
579 r0, _, e1 := Syscall(SYS_GETPRIORITY, uintptr(which), uintptr(who), 0)
580 prio = int(r0)
581 if e1 != 0 {
582 err = errnoErr(e1)
583 }
584 return
585 }
586
587
588
589 func Getrlimit(which int, lim *Rlimit) (err error) {
590 _, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
591 if e1 != 0 {
592 err = errnoErr(e1)
593 }
594 return
595 }
596
597
598
599 func Getrusage(who int, rusage *Rusage) (err error) {
600 _, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
601 if e1 != 0 {
602 err = errnoErr(e1)
603 }
604 return
605 }
606
607
608
609 func Getsid(pid int) (sid int, err error) {
610 r0, _, e1 := RawSyscall(SYS_GETSID, uintptr(pid), 0, 0)
611 sid = int(r0)
612 if e1 != 0 {
613 err = errnoErr(e1)
614 }
615 return
616 }
617
618
619
620 func Gettimeofday(tv *Timeval) (err error) {
621 _, _, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tv)), 0, 0)
622 if e1 != 0 {
623 err = errnoErr(e1)
624 }
625 return
626 }
627
628
629
630 func Getuid() (uid int) {
631 r0, _, _ := RawSyscall(SYS_GETUID, 0, 0, 0)
632 uid = int(r0)
633 return
634 }
635
636
637
638 func Issetugid() (tainted bool) {
639 r0, _, _ := Syscall(SYS_ISSETUGID, 0, 0, 0)
640 tainted = bool(r0 != 0)
641 return
642 }
643
644
645
646 func Kill(pid int, signum Signal) (err error) {
647 _, _, e1 := Syscall(SYS_KILL, uintptr(pid), uintptr(signum), 0)
648 if e1 != 0 {
649 err = errnoErr(e1)
650 }
651 return
652 }
653
654
655
656 func Kqueue() (fd int, err error) {
657 r0, _, e1 := Syscall(SYS_KQUEUE, 0, 0, 0)
658 fd = int(r0)
659 if e1 != 0 {
660 err = errnoErr(e1)
661 }
662 return
663 }
664
665
666
667 func Lchown(path string, uid int, gid int) (err error) {
668 var _p0 *byte
669 _p0, err = BytePtrFromString(path)
670 if err != nil {
671 return
672 }
673 _, _, e1 := Syscall(SYS_LCHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
674 if e1 != 0 {
675 err = errnoErr(e1)
676 }
677 return
678 }
679
680
681
682 func Link(path string, link string) (err error) {
683 var _p0 *byte
684 _p0, err = BytePtrFromString(path)
685 if err != nil {
686 return
687 }
688 var _p1 *byte
689 _p1, err = BytePtrFromString(link)
690 if err != nil {
691 return
692 }
693 _, _, e1 := Syscall(SYS_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
694 if e1 != 0 {
695 err = errnoErr(e1)
696 }
697 return
698 }
699
700
701
702 func Listen(s int, backlog int) (err error) {
703 _, _, e1 := Syscall(SYS_LISTEN, uintptr(s), uintptr(backlog), 0)
704 if e1 != 0 {
705 err = errnoErr(e1)
706 }
707 return
708 }
709
710
711
712 func Lstat(path string, stat *Stat_t) (err error) {
713 var _p0 *byte
714 _p0, err = BytePtrFromString(path)
715 if err != nil {
716 return
717 }
718 _, _, e1 := Syscall(SYS_LSTAT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
719 if e1 != 0 {
720 err = errnoErr(e1)
721 }
722 return
723 }
724
725
726
727 func Mkdir(path string, mode uint32) (err error) {
728 var _p0 *byte
729 _p0, err = BytePtrFromString(path)
730 if err != nil {
731 return
732 }
733 _, _, e1 := Syscall(SYS_MKDIR, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
734 if e1 != 0 {
735 err = errnoErr(e1)
736 }
737 return
738 }
739
740
741
742 func Mkfifo(path string, mode uint32) (err error) {
743 var _p0 *byte
744 _p0, err = BytePtrFromString(path)
745 if err != nil {
746 return
747 }
748 _, _, e1 := Syscall(SYS_MKFIFO, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
749 if e1 != 0 {
750 err = errnoErr(e1)
751 }
752 return
753 }
754
755
756
757 func Mknod(path string, mode uint32, dev int) (err error) {
758 var _p0 *byte
759 _p0, err = BytePtrFromString(path)
760 if err != nil {
761 return
762 }
763 _, _, e1 := Syscall(SYS_MKNOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
764 if e1 != 0 {
765 err = errnoErr(e1)
766 }
767 return
768 }
769
770
771
772 func Nanosleep(time *Timespec, leftover *Timespec) (err error) {
773 _, _, e1 := Syscall(SYS_NANOSLEEP, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
774 if e1 != 0 {
775 err = errnoErr(e1)
776 }
777 return
778 }
779
780
781
782 func Open(path string, mode int, perm uint32) (fd int, err error) {
783 var _p0 *byte
784 _p0, err = BytePtrFromString(path)
785 if err != nil {
786 return
787 }
788 r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
789 fd = int(r0)
790 if e1 != 0 {
791 err = errnoErr(e1)
792 }
793 return
794 }
795
796
797
798 func Pathconf(path string, name int) (val int, err error) {
799 var _p0 *byte
800 _p0, err = BytePtrFromString(path)
801 if err != nil {
802 return
803 }
804 r0, _, e1 := Syscall(SYS_PATHCONF, uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
805 val = int(r0)
806 if e1 != 0 {
807 err = errnoErr(e1)
808 }
809 return
810 }
811
812
813
814 func Pread(fd int, p []byte, offset int64) (n int, err error) {
815 var _p0 unsafe.Pointer
816 if len(p) > 0 {
817 _p0 = unsafe.Pointer(&p[0])
818 } else {
819 _p0 = unsafe.Pointer(&_zero)
820 }
821 r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), 0, uintptr(offset), 0)
822 n = int(r0)
823 if e1 != 0 {
824 err = errnoErr(e1)
825 }
826 return
827 }
828
829
830
831 func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
832 var _p0 unsafe.Pointer
833 if len(p) > 0 {
834 _p0 = unsafe.Pointer(&p[0])
835 } else {
836 _p0 = unsafe.Pointer(&_zero)
837 }
838 r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), 0, uintptr(offset), 0)
839 n = int(r0)
840 if e1 != 0 {
841 err = errnoErr(e1)
842 }
843 return
844 }
845
846
847
848 func read(fd int, p []byte) (n int, err error) {
849 var _p0 unsafe.Pointer
850 if len(p) > 0 {
851 _p0 = unsafe.Pointer(&p[0])
852 } else {
853 _p0 = unsafe.Pointer(&_zero)
854 }
855 r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p)))
856 n = int(r0)
857 if e1 != 0 {
858 err = errnoErr(e1)
859 }
860 return
861 }
862
863
864
865 func Readlink(path string, buf []byte) (n int, err error) {
866 var _p0 *byte
867 _p0, err = BytePtrFromString(path)
868 if err != nil {
869 return
870 }
871 var _p1 unsafe.Pointer
872 if len(buf) > 0 {
873 _p1 = unsafe.Pointer(&buf[0])
874 } else {
875 _p1 = unsafe.Pointer(&_zero)
876 }
877 r0, _, e1 := Syscall(SYS_READLINK, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
878 n = int(r0)
879 if e1 != 0 {
880 err = errnoErr(e1)
881 }
882 return
883 }
884
885
886
887 func Rename(from string, to string) (err error) {
888 var _p0 *byte
889 _p0, err = BytePtrFromString(from)
890 if err != nil {
891 return
892 }
893 var _p1 *byte
894 _p1, err = BytePtrFromString(to)
895 if err != nil {
896 return
897 }
898 _, _, e1 := Syscall(SYS_RENAME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
899 if e1 != 0 {
900 err = errnoErr(e1)
901 }
902 return
903 }
904
905
906
907 func Revoke(path string) (err error) {
908 var _p0 *byte
909 _p0, err = BytePtrFromString(path)
910 if err != nil {
911 return
912 }
913 _, _, e1 := Syscall(SYS_REVOKE, uintptr(unsafe.Pointer(_p0)), 0, 0)
914 if e1 != 0 {
915 err = errnoErr(e1)
916 }
917 return
918 }
919
920
921
922 func Rmdir(path string) (err error) {
923 var _p0 *byte
924 _p0, err = BytePtrFromString(path)
925 if err != nil {
926 return
927 }
928 _, _, e1 := Syscall(SYS_RMDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
929 if e1 != 0 {
930 err = errnoErr(e1)
931 }
932 return
933 }
934
935
936
937 func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
938 r0, _, e1 := Syscall6(SYS_LSEEK, uintptr(fd), 0, uintptr(offset), uintptr(whence), 0, 0)
939 newoffset = int64(r0)
940 if e1 != 0 {
941 err = errnoErr(e1)
942 }
943 return
944 }
945
946
947
948 func Select(n int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (err error) {
949 _, _, e1 := Syscall6(SYS_SELECT, uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
950 if e1 != 0 {
951 err = errnoErr(e1)
952 }
953 return
954 }
955
956
957
958 func Setegid(egid int) (err error) {
959 _, _, e1 := RawSyscall(SYS_SETEGID, uintptr(egid), 0, 0)
960 if e1 != 0 {
961 err = errnoErr(e1)
962 }
963 return
964 }
965
966
967
968 func Seteuid(euid int) (err error) {
969 _, _, e1 := RawSyscall(SYS_SETEUID, uintptr(euid), 0, 0)
970 if e1 != 0 {
971 err = errnoErr(e1)
972 }
973 return
974 }
975
976
977
978 func Setgid(gid int) (err error) {
979 _, _, e1 := RawSyscall(SYS_SETGID, uintptr(gid), 0, 0)
980 if e1 != 0 {
981 err = errnoErr(e1)
982 }
983 return
984 }
985
986
987
988 func Setlogin(name string) (err error) {
989 var _p0 *byte
990 _p0, err = BytePtrFromString(name)
991 if err != nil {
992 return
993 }
994 _, _, e1 := Syscall(SYS_SETLOGIN, uintptr(unsafe.Pointer(_p0)), 0, 0)
995 if e1 != 0 {
996 err = errnoErr(e1)
997 }
998 return
999 }
1000
1001
1002
1003 func Setpgid(pid int, pgid int) (err error) {
1004 _, _, e1 := RawSyscall(SYS_SETPGID, uintptr(pid), uintptr(pgid), 0)
1005 if e1 != 0 {
1006 err = errnoErr(e1)
1007 }
1008 return
1009 }
1010
1011
1012
1013 func Setpriority(which int, who int, prio int) (err error) {
1014 _, _, e1 := Syscall(SYS_SETPRIORITY, uintptr(which), uintptr(who), uintptr(prio))
1015 if e1 != 0 {
1016 err = errnoErr(e1)
1017 }
1018 return
1019 }
1020
1021
1022
1023 func Setregid(rgid int, egid int) (err error) {
1024 _, _, e1 := RawSyscall(SYS_SETREGID, uintptr(rgid), uintptr(egid), 0)
1025 if e1 != 0 {
1026 err = errnoErr(e1)
1027 }
1028 return
1029 }
1030
1031
1032
1033 func Setreuid(ruid int, euid int) (err error) {
1034 _, _, e1 := RawSyscall(SYS_SETREUID, uintptr(ruid), uintptr(euid), 0)
1035 if e1 != 0 {
1036 err = errnoErr(e1)
1037 }
1038 return
1039 }
1040
1041
1042
1043 func Setrlimit(which int, lim *Rlimit) (err error) {
1044 _, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
1045 if e1 != 0 {
1046 err = errnoErr(e1)
1047 }
1048 return
1049 }
1050
1051
1052
1053 func Setsid() (pid int, err error) {
1054 r0, _, e1 := RawSyscall(SYS_SETSID, 0, 0, 0)
1055 pid = int(r0)
1056 if e1 != 0 {
1057 err = errnoErr(e1)
1058 }
1059 return
1060 }
1061
1062
1063
1064 func Settimeofday(tp *Timeval) (err error) {
1065 _, _, e1 := RawSyscall(SYS_SETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
1066 if e1 != 0 {
1067 err = errnoErr(e1)
1068 }
1069 return
1070 }
1071
1072
1073
1074 func Setuid(uid int) (err error) {
1075 _, _, e1 := RawSyscall(SYS_SETUID, uintptr(uid), 0, 0)
1076 if e1 != 0 {
1077 err = errnoErr(e1)
1078 }
1079 return
1080 }
1081
1082
1083
1084 func Stat(path string, stat *Stat_t) (err error) {
1085 var _p0 *byte
1086 _p0, err = BytePtrFromString(path)
1087 if err != nil {
1088 return
1089 }
1090 _, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
1091 if e1 != 0 {
1092 err = errnoErr(e1)
1093 }
1094 return
1095 }
1096
1097
1098
1099 func Statfs(path string, stat *Statfs_t) (err error) {
1100 var _p0 *byte
1101 _p0, err = BytePtrFromString(path)
1102 if err != nil {
1103 return
1104 }
1105 _, _, e1 := Syscall(SYS_STATFS, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
1106 if e1 != 0 {
1107 err = errnoErr(e1)
1108 }
1109 return
1110 }
1111
1112
1113
1114 func Symlink(path string, link string) (err error) {
1115 var _p0 *byte
1116 _p0, err = BytePtrFromString(path)
1117 if err != nil {
1118 return
1119 }
1120 var _p1 *byte
1121 _p1, err = BytePtrFromString(link)
1122 if err != nil {
1123 return
1124 }
1125 _, _, e1 := Syscall(SYS_SYMLINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
1126 if e1 != 0 {
1127 err = errnoErr(e1)
1128 }
1129 return
1130 }
1131
1132
1133
1134 func Sync() (err error) {
1135 _, _, e1 := Syscall(SYS_SYNC, 0, 0, 0)
1136 if e1 != 0 {
1137 err = errnoErr(e1)
1138 }
1139 return
1140 }
1141
1142
1143
1144 func Truncate(path string, length int64) (err error) {
1145 var _p0 *byte
1146 _p0, err = BytePtrFromString(path)
1147 if err != nil {
1148 return
1149 }
1150 _, _, e1 := Syscall(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), 0, uintptr(length))
1151 if e1 != 0 {
1152 err = errnoErr(e1)
1153 }
1154 return
1155 }
1156
1157
1158
1159 func Umask(newmask int) (oldmask int) {
1160 r0, _, _ := Syscall(SYS_UMASK, uintptr(newmask), 0, 0)
1161 oldmask = int(r0)
1162 return
1163 }
1164
1165
1166
1167 func Unlink(path string) (err error) {
1168 var _p0 *byte
1169 _p0, err = BytePtrFromString(path)
1170 if err != nil {
1171 return
1172 }
1173 _, _, e1 := Syscall(SYS_UNLINK, uintptr(unsafe.Pointer(_p0)), 0, 0)
1174 if e1 != 0 {
1175 err = errnoErr(e1)
1176 }
1177 return
1178 }
1179
1180
1181
1182 func Unmount(path string, flags int) (err error) {
1183 var _p0 *byte
1184 _p0, err = BytePtrFromString(path)
1185 if err != nil {
1186 return
1187 }
1188 _, _, e1 := Syscall(SYS_UNMOUNT, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
1189 if e1 != 0 {
1190 err = errnoErr(e1)
1191 }
1192 return
1193 }
1194
1195
1196
1197 func write(fd int, p []byte) (n int, err error) {
1198 var _p0 unsafe.Pointer
1199 if len(p) > 0 {
1200 _p0 = unsafe.Pointer(&p[0])
1201 } else {
1202 _p0 = unsafe.Pointer(&_zero)
1203 }
1204 r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)))
1205 n = int(r0)
1206 if e1 != 0 {
1207 err = errnoErr(e1)
1208 }
1209 return
1210 }
1211
1212
1213
1214 func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
1215 r0, _, e1 := Syscall9(SYS_MMAP, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), 0, uintptr(pos), 0, 0)
1216 ret = uintptr(r0)
1217 if e1 != 0 {
1218 err = errnoErr(e1)
1219 }
1220 return
1221 }
1222
1223
1224
1225 func munmap(addr uintptr, length uintptr) (err error) {
1226 _, _, e1 := Syscall(SYS_MUNMAP, uintptr(addr), uintptr(length), 0)
1227 if e1 != 0 {
1228 err = errnoErr(e1)
1229 }
1230 return
1231 }
1232
1233
1234
1235 func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
1236 r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
1237 n = int(r0)
1238 if e1 != 0 {
1239 err = errnoErr(e1)
1240 }
1241 return
1242 }
1243
1244
1245
1246 func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
1247 r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
1248 n = int(r0)
1249 if e1 != 0 {
1250 err = errnoErr(e1)
1251 }
1252 return
1253 }
1254
1255
1256
1257 func utimensat(dirfd int, path string, times *[2]Timespec, flag int) (err error) {
1258 var _p0 *byte
1259 _p0, err = BytePtrFromString(path)
1260 if err != nil {
1261 return
1262 }
1263 _, _, e1 := Syscall6(SYS_UTIMENSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), uintptr(flag), 0, 0)
1264 if e1 != 0 {
1265 err = errnoErr(e1)
1266 }
1267 return
1268 }
1269
1270
1271
1272 func getcwd(buf []byte) (n int, err error) {
1273 var _p0 unsafe.Pointer
1274 if len(buf) > 0 {
1275 _p0 = unsafe.Pointer(&buf[0])
1276 } else {
1277 _p0 = unsafe.Pointer(&_zero)
1278 }
1279 r0, _, e1 := Syscall(SYS___GETCWD, uintptr(_p0), uintptr(len(buf)), 0)
1280 n = int(r0)
1281 if e1 != 0 {
1282 err = errnoErr(e1)
1283 }
1284 return
1285 }
1286
1287
1288
1289 func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) {
1290 var _p0 unsafe.Pointer
1291 if len(mib) > 0 {
1292 _p0 = unsafe.Pointer(&mib[0])
1293 } else {
1294 _p0 = unsafe.Pointer(&_zero)
1295 }
1296 _, _, e1 := Syscall6(SYS___SYSCTL, uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
1297 if e1 != 0 {
1298 err = errnoErr(e1)
1299 }
1300 return
1301 }
1302
View as plain text