← Back to branch summary

~ubuntu-branches/ubuntu/utopic/golang/utopic

« back to all changes in this revision

Viewing changes to src/pkg/syscall/zsyscall_linux_amd64.go

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-08-20 14:06:23 UTC
  • mfrom: (14.1.23 saucy-proposed)
  • Revision ID: package-import@ubuntu.com-20130820140623-b414jfxi3m0qkmrq
Tags: 2:1.1.2-2ubuntu1
https://launchpad.net/bugs/1211749
https://launchpad.net/bugs/1202027
* Merge from Debian unstable (LP: #1211749, #1202027). Remaining changes:
  - 016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.
  - d/control,control.cross: Update Breaks/Replaces for Ubuntu
    versions to ensure smooth upgrades, regenerate control file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/syscall/zsyscall_linux_amd64.go
8
8
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
9
9
 
10
10
func open(path string, mode int, perm uint32) (fd int, err error) {
11
 
        r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(mode), uintptr(perm))
 
11
        var _p0 *byte
 
12
        _p0, err = BytePtrFromString(path)
 
13
        if err != nil {
 
14
                return
 
15
        }
 
16
        r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
12
17
        fd = int(r0)
13
18
        if e1 != 0 {
14
19
                err = e1
19
24
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
20
25
 
21
26
func openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) {
22
 
        r0, _, e1 := Syscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(flags), uintptr(mode), 0, 0)
 
27
        var _p0 *byte
 
28
        _p0, err = BytePtrFromString(path)
 
29
        if err != nil {
 
30
                return
 
31
        }
 
32
        r0, _, e1 := Syscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(mode), 0, 0)
23
33
        fd = int(r0)
24
34
        if e1 != 0 {
25
35
                err = e1
39
49
 
40
50
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
41
51
 
 
52
func pipe2(p *[2]_C_int, flags int) (err error) {
 
53
        _, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
 
54
        if e1 != 0 {
 
55
                err = e1
 
56
        }
 
57
        return
 
58
}
 
59
 
 
60
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
61
 
42
62
func utimes(path string, times *[2]Timeval) (err error) {
43
 
        _, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(unsafe.Pointer(times)), 0)
 
63
        var _p0 *byte
 
64
        _p0, err = BytePtrFromString(path)
 
65
        if err != nil {
 
66
                return
 
67
        }
 
68
        _, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), 0)
 
69
        if e1 != 0 {
 
70
                err = e1
 
71
        }
 
72
        return
 
73
}
 
74
 
 
75
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
76
 
 
77
func utimensat(dirfd int, path string, times *[2]Timespec) (err error) {
 
78
        var _p0 *byte
 
79
        _p0, err = BytePtrFromString(path)
 
80
        if err != nil {
 
81
                return
 
82
        }
 
83
        _, _, e1 := Syscall(SYS_UTIMENSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)))
44
84
        if e1 != 0 {
45
85
                err = e1
46
86
        }
98
138
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
99
139
 
100
140
func reboot(magic1 uint, magic2 uint, cmd int, arg string) (err error) {
101
 
        _, _, e1 := Syscall6(SYS_REBOOT, uintptr(magic1), uintptr(magic2), uintptr(cmd), uintptr(unsafe.Pointer(StringBytePtr(arg))), 0, 0)
 
141
        var _p0 *byte
 
142
        _p0, err = BytePtrFromString(arg)
 
143
        if err != nil {
 
144
                return
 
145
        }
 
146
        _, _, e1 := Syscall6(SYS_REBOOT, uintptr(magic1), uintptr(magic2), uintptr(cmd), uintptr(unsafe.Pointer(_p0)), 0, 0)
102
147
        if e1 != 0 {
103
148
                err = e1
104
149
        }
108
153
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
109
154
 
110
155
func mount(source string, target string, fstype string, flags uintptr, data *byte) (err error) {
111
 
        _, _, e1 := Syscall6(SYS_MOUNT, uintptr(unsafe.Pointer(StringBytePtr(source))), uintptr(unsafe.Pointer(StringBytePtr(target))), uintptr(unsafe.Pointer(StringBytePtr(fstype))), uintptr(flags), uintptr(unsafe.Pointer(data)), 0)
 
156
        var _p0 *byte
 
157
        _p0, err = BytePtrFromString(source)
 
158
        if err != nil {
 
159
                return
 
160
        }
 
161
        var _p1 *byte
 
162
        _p1, err = BytePtrFromString(target)
 
163
        if err != nil {
 
164
                return
 
165
        }
 
166
        var _p2 *byte
 
167
        _p2, err = BytePtrFromString(fstype)
 
168
        if err != nil {
 
169
                return
 
170
        }
 
171
        _, _, e1 := Syscall6(SYS_MOUNT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(_p2)), uintptr(flags), uintptr(unsafe.Pointer(data)), 0)
112
172
        if e1 != 0 {
113
173
                err = e1
114
174
        }
118
178
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
119
179
 
120
180
func Access(path string, mode uint32) (err error) {
121
 
        _, _, e1 := Syscall(SYS_ACCESS, uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(mode), 0)
 
181
        var _p0 *byte
 
182
        _p0, err = BytePtrFromString(path)
 
183
        if err != nil {
 
184
                return
 
185
        }
 
186
        _, _, e1 := Syscall(SYS_ACCESS, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
122
187
        if e1 != 0 {
123
188
                err = e1
124
189
        }
128
193
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
129
194
 
130
195
func Acct(path string) (err error) {
131
 
        _, _, e1 := Syscall(SYS_ACCT, uintptr(unsafe.Pointer(StringBytePtr(path))), 0, 0)
 
196
        var _p0 *byte
 
197
        _p0, err = BytePtrFromString(path)
 
198
        if err != nil {
 
199
                return
 
200
        }
 
201
        _, _, e1 := Syscall(SYS_ACCT, uintptr(unsafe.Pointer(_p0)), 0, 0)
132
202
        if e1 != 0 {
133
203
                err = e1
134
204
        }
149
219
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
150
220
 
151
221
func Chdir(path string) (err error) {
152
 
        _, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(StringBytePtr(path))), 0, 0)
 
222
        var _p0 *byte
 
223
        _p0, err = BytePtrFromString(path)
 
224
        if err != nil {
 
225
                return
 
226
        }
 
227
        _, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
153
228
        if e1 != 0 {
154
229
                err = e1
155
230
        }
159
234
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
160
235
 
161
236
func Chmod(path string, mode uint32) (err error) {
162
 
        _, _, e1 := Syscall(SYS_CHMOD, uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(mode), 0)
 
237
        var _p0 *byte
 
238
        _p0, err = BytePtrFromString(path)
 
239
        if err != nil {
 
240
                return
 
241
        }
 
242
        _, _, e1 := Syscall(SYS_CHMOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
163
243
        if e1 != 0 {
164
244
                err = e1
165
245
        }
169
249
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
170
250
 
171
251
func Chroot(path string) (err error) {
172
 
        _, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(StringBytePtr(path))), 0, 0)
 
252
        var _p0 *byte
 
253
        _p0, err = BytePtrFromString(path)
 
254
        if err != nil {
 
255
                return
 
256
        }
 
257
        _, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0)
173
258
        if e1 != 0 {
174
259
                err = e1
175
260
        }
189
274
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
190
275
 
191
276
func Creat(path string, mode uint32) (fd int, err error) {
192
 
        r0, _, e1 := Syscall(SYS_CREAT, uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(mode), 0)
 
277
        var _p0 *byte
 
278
        _p0, err = BytePtrFromString(path)
 
279
        if err != nil {
 
280
                return
 
281
        }
 
282
        r0, _, e1 := Syscall(SYS_CREAT, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
193
283
        fd = int(r0)
194
284
        if e1 != 0 {
195
285
                err = e1
277
367
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
278
368
 
279
369
func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
280
 
        _, _, e1 := Syscall6(SYS_FACCESSAT, uintptr(dirfd), uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(mode), uintptr(flags), 0, 0)
 
370
        var _p0 *byte
 
371
        _p0, err = BytePtrFromString(path)
 
372
        if err != nil {
 
373
                return
 
374
        }
 
375
        _, _, e1 := Syscall6(SYS_FACCESSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
281
376
        if e1 != 0 {
282
377
                err = e1
283
378
        }
317
412
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
318
413
 
319
414
func Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) {
320
 
        _, _, e1 := Syscall6(SYS_FCHMODAT, uintptr(dirfd), uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(mode), uintptr(flags), 0, 0)
 
415
        var _p0 *byte
 
416
        _p0, err = BytePtrFromString(path)
 
417
        if err != nil {
 
418
                return
 
419
        }
 
420
        _, _, e1 := Syscall6(SYS_FCHMODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
321
421
        if e1 != 0 {
322
422
                err = e1
323
423
        }
327
427
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
328
428
 
329
429
func Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error) {
330
 
        _, _, e1 := Syscall6(SYS_FCHOWNAT, uintptr(dirfd), uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(uid), uintptr(gid), uintptr(flags), 0)
 
430
        var _p0 *byte
 
431
        _p0, err = BytePtrFromString(path)
 
432
        if err != nil {
 
433
                return
 
434
        }
 
435
        _, _, e1 := Syscall6(SYS_FCHOWNAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
331
436
        if e1 != 0 {
332
437
                err = e1
333
438
        }
429
534
 
430
535
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
431
536
 
432
 
func Getrlimit(resource int, rlim *Rlimit) (err error) {
433
 
        _, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0)
434
 
        if e1 != 0 {
435
 
                err = e1
436
 
        }
437
 
        return
438
 
}
439
 
 
440
 
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
441
 
 
442
537
func Getrusage(who int, rusage *Rusage) (err error) {
443
538
        _, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
444
539
        if e1 != 0 {
457
552
 
458
553
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
459
554
 
 
555
func Getxattr(path string, attr string, dest []byte) (sz int, err error) {
 
556
        var _p0 *byte
 
557
        _p0, err = BytePtrFromString(path)
 
558
        if err != nil {
 
559
                return
 
560
        }
 
561
        var _p1 *byte
 
562
        _p1, err = BytePtrFromString(attr)
 
563
        if err != nil {
 
564
                return
 
565
        }
 
566
        var _p2 unsafe.Pointer
 
567
        if len(dest) > 0 {
 
568
                _p2 = unsafe.Pointer(&dest[0])
 
569
        } else {
 
570
                _p2 = unsafe.Pointer(&_zero)
 
571
        }
 
572
        r0, _, e1 := Syscall6(SYS_GETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(dest)), 0, 0)
 
573
        sz = int(r0)
 
574
        if e1 != 0 {
 
575
                err = e1
 
576
        }
 
577
        return
 
578
}
 
579
 
 
580
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
581
 
460
582
func InotifyAddWatch(fd int, pathname string, mask uint32) (watchdesc int, err error) {
461
 
        r0, _, e1 := Syscall(SYS_INOTIFY_ADD_WATCH, uintptr(fd), uintptr(unsafe.Pointer(StringBytePtr(pathname))), uintptr(mask))
 
583
        var _p0 *byte
 
584
        _p0, err = BytePtrFromString(pathname)
 
585
        if err != nil {
 
586
                return
 
587
        }
 
588
        r0, _, e1 := Syscall(SYS_INOTIFY_ADD_WATCH, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(mask))
462
589
        watchdesc = int(r0)
463
590
        if e1 != 0 {
464
591
                err = e1
529
656
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
530
657
 
531
658
func Link(oldpath string, newpath string) (err error) {
532
 
        _, _, e1 := Syscall(SYS_LINK, uintptr(unsafe.Pointer(StringBytePtr(oldpath))), uintptr(unsafe.Pointer(StringBytePtr(newpath))), 0)
 
659
        var _p0 *byte
 
660
        _p0, err = BytePtrFromString(oldpath)
 
661
        if err != nil {
 
662
                return
 
663
        }
 
664
        var _p1 *byte
 
665
        _p1, err = BytePtrFromString(newpath)
 
666
        if err != nil {
 
667
                return
 
668
        }
 
669
        _, _, e1 := Syscall(SYS_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 
670
        if e1 != 0 {
 
671
                err = e1
 
672
        }
 
673
        return
 
674
}
 
675
 
 
676
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
677
 
 
678
func Listxattr(path string, dest []byte) (sz int, err error) {
 
679
        var _p0 *byte
 
680
        _p0, err = BytePtrFromString(path)
 
681
        if err != nil {
 
682
                return
 
683
        }
 
684
        var _p1 unsafe.Pointer
 
685
        if len(dest) > 0 {
 
686
                _p1 = unsafe.Pointer(&dest[0])
 
687
        } else {
 
688
                _p1 = unsafe.Pointer(&_zero)
 
689
        }
 
690
        r0, _, e1 := Syscall(SYS_LISTXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest)))
 
691
        sz = int(r0)
533
692
        if e1 != 0 {
534
693
                err = e1
535
694
        }
539
698
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
540
699
 
541
700
func Mkdir(path string, mode uint32) (err error) {
542
 
        _, _, e1 := Syscall(SYS_MKDIR, uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(mode), 0)
 
701
        var _p0 *byte
 
702
        _p0, err = BytePtrFromString(path)
 
703
        if err != nil {
 
704
                return
 
705
        }
 
706
        _, _, e1 := Syscall(SYS_MKDIR, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
543
707
        if e1 != 0 {
544
708
                err = e1
545
709
        }
549
713
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
550
714
 
551
715
func Mkdirat(dirfd int, path string, mode uint32) (err error) {
552
 
        _, _, e1 := Syscall(SYS_MKDIRAT, uintptr(dirfd), uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(mode))
 
716
        var _p0 *byte
 
717
        _p0, err = BytePtrFromString(path)
 
718
        if err != nil {
 
719
                return
 
720
        }
 
721
        _, _, e1 := Syscall(SYS_MKDIRAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
553
722
        if e1 != 0 {
554
723
                err = e1
555
724
        }
559
728
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
560
729
 
561
730
func Mknod(path string, mode uint32, dev int) (err error) {
562
 
        _, _, e1 := Syscall(SYS_MKNOD, uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(mode), uintptr(dev))
 
731
        var _p0 *byte
 
732
        _p0, err = BytePtrFromString(path)
 
733
        if err != nil {
 
734
                return
 
735
        }
 
736
        _, _, e1 := Syscall(SYS_MKNOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
563
737
        if e1 != 0 {
564
738
                err = e1
565
739
        }
569
743
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
570
744
 
571
745
func Mknodat(dirfd int, path string, mode uint32, dev int) (err error) {
572
 
        _, _, e1 := Syscall6(SYS_MKNODAT, uintptr(dirfd), uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(mode), uintptr(dev), 0, 0)
 
746
        var _p0 *byte
 
747
        _p0, err = BytePtrFromString(path)
 
748
        if err != nil {
 
749
                return
 
750
        }
 
751
        _, _, e1 := Syscall6(SYS_MKNODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev), 0, 0)
573
752
        if e1 != 0 {
574
753
                err = e1
575
754
        }
599
778
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
600
779
 
601
780
func PivotRoot(newroot string, putold string) (err error) {
602
 
        _, _, e1 := Syscall(SYS_PIVOT_ROOT, uintptr(unsafe.Pointer(StringBytePtr(newroot))), uintptr(unsafe.Pointer(StringBytePtr(putold))), 0)
603
 
        if e1 != 0 {
604
 
                err = e1
605
 
        }
606
 
        return
607
 
}
608
 
 
609
 
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
610
 
 
611
 
func Read(fd int, p []byte) (n int, err error) {
 
781
        var _p0 *byte
 
782
        _p0, err = BytePtrFromString(newroot)
 
783
        if err != nil {
 
784
                return
 
785
        }
 
786
        var _p1 *byte
 
787
        _p1, err = BytePtrFromString(putold)
 
788
        if err != nil {
 
789
                return
 
790
        }
 
791
        _, _, e1 := Syscall(SYS_PIVOT_ROOT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 
792
        if e1 != 0 {
 
793
                err = e1
 
794
        }
 
795
        return
 
796
}
 
797
 
 
798
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
799
 
 
800
func prlimit(pid int, resource int, old *Rlimit, newlimit *Rlimit) (err error) {
 
801
        _, _, e1 := RawSyscall6(SYS_PRLIMIT64, uintptr(pid), uintptr(resource), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(newlimit)), 0, 0)
 
802
        if e1 != 0 {
 
803
                err = e1
 
804
        }
 
805
        return
 
806
}
 
807
 
 
808
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
809
 
 
810
func read(fd int, p []byte) (n int, err error) {
612
811
        var _p0 unsafe.Pointer
613
812
        if len(p) > 0 {
614
813
                _p0 = unsafe.Pointer(&p[0])
626
825
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
627
826
 
628
827
func Readlink(path string, buf []byte) (n int, err error) {
629
 
        var _p0 unsafe.Pointer
 
828
        var _p0 *byte
 
829
        _p0, err = BytePtrFromString(path)
 
830
        if err != nil {
 
831
                return
 
832
        }
 
833
        var _p1 unsafe.Pointer
630
834
        if len(buf) > 0 {
631
 
                _p0 = unsafe.Pointer(&buf[0])
 
835
                _p1 = unsafe.Pointer(&buf[0])
632
836
        } else {
633
 
                _p0 = unsafe.Pointer(&_zero)
 
837
                _p1 = unsafe.Pointer(&_zero)
634
838
        }
635
 
        r0, _, e1 := Syscall(SYS_READLINK, uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(_p0), uintptr(len(buf)))
 
839
        r0, _, e1 := Syscall(SYS_READLINK, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
636
840
        n = int(r0)
637
841
        if e1 != 0 {
638
842
                err = e1
642
846
 
643
847
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
644
848
 
 
849
func Removexattr(path string, attr string) (err error) {
 
850
        var _p0 *byte
 
851
        _p0, err = BytePtrFromString(path)
 
852
        if err != nil {
 
853
                return
 
854
        }
 
855
        var _p1 *byte
 
856
        _p1, err = BytePtrFromString(attr)
 
857
        if err != nil {
 
858
                return
 
859
        }
 
860
        _, _, e1 := Syscall(SYS_REMOVEXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 
861
        if e1 != 0 {
 
862
                err = e1
 
863
        }
 
864
        return
 
865
}
 
866
 
 
867
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
868
 
645
869
func Rename(oldpath string, newpath string) (err error) {
646
 
        _, _, e1 := Syscall(SYS_RENAME, uintptr(unsafe.Pointer(StringBytePtr(oldpath))), uintptr(unsafe.Pointer(StringBytePtr(newpath))), 0)
 
870
        var _p0 *byte
 
871
        _p0, err = BytePtrFromString(oldpath)
 
872
        if err != nil {
 
873
                return
 
874
        }
 
875
        var _p1 *byte
 
876
        _p1, err = BytePtrFromString(newpath)
 
877
        if err != nil {
 
878
                return
 
879
        }
 
880
        _, _, e1 := Syscall(SYS_RENAME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
647
881
        if e1 != 0 {
648
882
                err = e1
649
883
        }
653
887
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
654
888
 
655
889
func Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error) {
656
 
        _, _, e1 := Syscall6(SYS_RENAMEAT, uintptr(olddirfd), uintptr(unsafe.Pointer(StringBytePtr(oldpath))), uintptr(newdirfd), uintptr(unsafe.Pointer(StringBytePtr(newpath))), 0, 0)
 
890
        var _p0 *byte
 
891
        _p0, err = BytePtrFromString(oldpath)
 
892
        if err != nil {
 
893
                return
 
894
        }
 
895
        var _p1 *byte
 
896
        _p1, err = BytePtrFromString(newpath)
 
897
        if err != nil {
 
898
                return
 
899
        }
 
900
        _, _, e1 := Syscall6(SYS_RENAMEAT, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)), 0, 0)
657
901
        if e1 != 0 {
658
902
                err = e1
659
903
        }
663
907
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
664
908
 
665
909
func Rmdir(path string) (err error) {
666
 
        _, _, e1 := Syscall(SYS_RMDIR, uintptr(unsafe.Pointer(StringBytePtr(path))), 0, 0)
 
910
        var _p0 *byte
 
911
        _p0, err = BytePtrFromString(path)
 
912
        if err != nil {
 
913
                return
 
914
        }
 
915
        _, _, e1 := Syscall(SYS_RMDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
667
916
        if e1 != 0 {
668
917
                err = e1
669
918
        }
714
963
 
715
964
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
716
965
 
717
 
func Setrlimit(resource int, rlim *Rlimit) (err error) {
718
 
        _, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0)
719
 
        if e1 != 0 {
720
 
                err = e1
721
 
        }
722
 
        return
723
 
}
724
 
 
725
 
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
726
 
 
727
966
func Setsid() (pid int, err error) {
728
967
        r0, _, e1 := RawSyscall(SYS_SETSID, 0, 0, 0)
729
968
        pid = int(r0)
755
994
 
756
995
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
757
996
 
 
997
func Setxattr(path string, attr string, data []byte, flags int) (err error) {
 
998
        var _p0 *byte
 
999
        _p0, err = BytePtrFromString(path)
 
1000
        if err != nil {
 
1001
                return
 
1002
        }
 
1003
        var _p1 *byte
 
1004
        _p1, err = BytePtrFromString(attr)
 
1005
        if err != nil {
 
1006
                return
 
1007
        }
 
1008
        var _p2 unsafe.Pointer
 
1009
        if len(data) > 0 {
 
1010
                _p2 = unsafe.Pointer(&data[0])
 
1011
        } else {
 
1012
                _p2 = unsafe.Pointer(&_zero)
 
1013
        }
 
1014
        _, _, e1 := Syscall6(SYS_SETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(data)), uintptr(flags), 0)
 
1015
        if e1 != 0 {
 
1016
                err = e1
 
1017
        }
 
1018
        return
 
1019
}
 
1020
 
 
1021
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1022
 
758
1023
func Symlink(oldpath string, newpath string) (err error) {
759
 
        _, _, e1 := Syscall(SYS_SYMLINK, uintptr(unsafe.Pointer(StringBytePtr(oldpath))), uintptr(unsafe.Pointer(StringBytePtr(newpath))), 0)
 
1024
        var _p0 *byte
 
1025
        _p0, err = BytePtrFromString(oldpath)
 
1026
        if err != nil {
 
1027
                return
 
1028
        }
 
1029
        var _p1 *byte
 
1030
        _p1, err = BytePtrFromString(newpath)
 
1031
        if err != nil {
 
1032
                return
 
1033
        }
 
1034
        _, _, e1 := Syscall(SYS_SYMLINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
760
1035
        if e1 != 0 {
761
1036
                err = e1
762
1037
        }
833
1108
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
834
1109
 
835
1110
func Unlink(path string) (err error) {
836
 
        _, _, e1 := Syscall(SYS_UNLINK, uintptr(unsafe.Pointer(StringBytePtr(path))), 0, 0)
 
1111
        var _p0 *byte
 
1112
        _p0, err = BytePtrFromString(path)
 
1113
        if err != nil {
 
1114
                return
 
1115
        }
 
1116
        _, _, e1 := Syscall(SYS_UNLINK, uintptr(unsafe.Pointer(_p0)), 0, 0)
837
1117
        if e1 != 0 {
838
1118
                err = e1
839
1119
        }
843
1123
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
844
1124
 
845
1125
func Unlinkat(dirfd int, path string) (err error) {
846
 
        _, _, e1 := Syscall(SYS_UNLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(StringBytePtr(path))), 0)
 
1126
        var _p0 *byte
 
1127
        _p0, err = BytePtrFromString(path)
 
1128
        if err != nil {
 
1129
                return
 
1130
        }
 
1131
        _, _, e1 := Syscall(SYS_UNLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), 0)
847
1132
        if e1 != 0 {
848
1133
                err = e1
849
1134
        }
853
1138
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
854
1139
 
855
1140
func Unmount(target string, flags int) (err error) {
856
 
        _, _, e1 := Syscall(SYS_UMOUNT2, uintptr(unsafe.Pointer(StringBytePtr(target))), uintptr(flags), 0)
 
1141
        var _p0 *byte
 
1142
        _p0, err = BytePtrFromString(target)
 
1143
        if err != nil {
 
1144
                return
 
1145
        }
 
1146
        _, _, e1 := Syscall(SYS_UMOUNT2, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
857
1147
        if e1 != 0 {
858
1148
                err = e1
859
1149
        }
883
1173
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
884
1174
 
885
1175
func Utime(path string, buf *Utimbuf) (err error) {
886
 
        _, _, e1 := Syscall(SYS_UTIME, uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(unsafe.Pointer(buf)), 0)
 
1176
        var _p0 *byte
 
1177
        _p0, err = BytePtrFromString(path)
 
1178
        if err != nil {
 
1179
                return
 
1180
        }
 
1181
        _, _, e1 := Syscall(SYS_UTIME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(buf)), 0)
887
1182
        if e1 != 0 {
888
1183
                err = e1
889
1184
        }
892
1187
 
893
1188
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
894
1189
 
895
 
func Write(fd int, p []byte) (n int, err error) {
 
1190
func write(fd int, p []byte) (n int, err error) {
896
1191
        var _p0 unsafe.Pointer
897
1192
        if len(p) > 0 {
898
1193
                _p0 = unsafe.Pointer(&p[0])
919
1214
 
920
1215
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
921
1216
 
922
 
func read(fd int, p *byte, np int) (n int, err error) {
 
1217
func readlen(fd int, p *byte, np int) (n int, err error) {
923
1218
        r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(p)), uintptr(np))
924
1219
        n = int(r0)
925
1220
        if e1 != 0 {
930
1225
 
931
1226
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
932
1227
 
933
 
func write(fd int, p *byte, np int) (n int, err error) {
 
1228
func writelen(fd int, p *byte, np int) (n int, err error) {
934
1229
        r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(unsafe.Pointer(p)), uintptr(np))
935
1230
        n = int(r0)
936
1231
        if e1 != 0 {
1036
1331
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1037
1332
 
1038
1333
func Chown(path string, uid int, gid int) (err error) {
1039
 
        _, _, e1 := Syscall(SYS_CHOWN, uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(uid), uintptr(gid))
 
1334
        var _p0 *byte
 
1335
        _p0, err = BytePtrFromString(path)
 
1336
        if err != nil {
 
1337
                return
 
1338
        }
 
1339
        _, _, e1 := Syscall(SYS_CHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
1040
1340
        if e1 != 0 {
1041
1341
                err = e1
1042
1342
        }
1109
1409
 
1110
1410
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1111
1411
 
 
1412
func Getrlimit(resource int, rlim *Rlimit) (err error) {
 
1413
        _, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0)
 
1414
        if e1 != 0 {
 
1415
                err = e1
 
1416
        }
 
1417
        return
 
1418
}
 
1419
 
 
1420
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1421
 
1112
1422
func Getuid() (uid int) {
1113
1423
        r0, _, _ := RawSyscall(SYS_GETUID, 0, 0, 0)
1114
1424
        uid = int(r0)
1138
1448
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1139
1449
 
1140
1450
func Lchown(path string, uid int, gid int) (err error) {
1141
 
        _, _, e1 := Syscall(SYS_LCHOWN, uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(uid), uintptr(gid))
 
1451
        var _p0 *byte
 
1452
        _p0, err = BytePtrFromString(path)
 
1453
        if err != nil {
 
1454
                return
 
1455
        }
 
1456
        _, _, e1 := Syscall(SYS_LCHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
1142
1457
        if e1 != 0 {
1143
1458
                err = e1
1144
1459
        }
1158
1473
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1159
1474
 
1160
1475
func Lstat(path string, stat *Stat_t) (err error) {
1161
 
        _, _, e1 := Syscall(SYS_LSTAT, uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(unsafe.Pointer(stat)), 0)
 
1476
        var _p0 *byte
 
1477
        _p0, err = BytePtrFromString(path)
 
1478
        if err != nil {
 
1479
                return
 
1480
        }
 
1481
        _, _, e1 := Syscall(SYS_LSTAT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
1162
1482
        if e1 != 0 {
1163
1483
                err = e1
1164
1484
        }
1223
1543
 
1224
1544
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1225
1545
 
1226
 
func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
 
1546
func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
1227
1547
        r0, _, e1 := Syscall6(SYS_SENDFILE, uintptr(outfd), uintptr(infd), uintptr(unsafe.Pointer(offset)), uintptr(count), 0, 0)
1228
1548
        written = int(r0)
1229
1549
        if e1 != 0 {
1294
1614
 
1295
1615
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1296
1616
 
 
1617
func Setrlimit(resource int, rlim *Rlimit) (err error) {
 
1618
        _, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0)
 
1619
        if e1 != 0 {
 
1620
                err = e1
 
1621
        }
 
1622
        return
 
1623
}
 
1624
 
 
1625
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1626
 
1297
1627
func Setreuid(ruid int, euid int) (err error) {
1298
1628
        _, _, e1 := RawSyscall(SYS_SETREUID, uintptr(ruid), uintptr(euid), 0)
1299
1629
        if e1 != 0 {
1326
1656
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1327
1657
 
1328
1658
func Stat(path string, stat *Stat_t) (err error) {
1329
 
        _, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(unsafe.Pointer(stat)), 0)
 
1659
        var _p0 *byte
 
1660
        _p0, err = BytePtrFromString(path)
 
1661
        if err != nil {
 
1662
                return
 
1663
        }
 
1664
        _, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
1330
1665
        if e1 != 0 {
1331
1666
                err = e1
1332
1667
        }
1336
1671
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1337
1672
 
1338
1673
func Statfs(path string, buf *Statfs_t) (err error) {
1339
 
        _, _, e1 := Syscall(SYS_STATFS, uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(unsafe.Pointer(buf)), 0)
 
1674
        var _p0 *byte
 
1675
        _p0, err = BytePtrFromString(path)
 
1676
        if err != nil {
 
1677
                return
 
1678
        }
 
1679
        _, _, e1 := Syscall(SYS_STATFS, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(buf)), 0)
1340
1680
        if e1 != 0 {
1341
1681
                err = e1
1342
1682
        }
1356
1696
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1357
1697
 
1358
1698
func Truncate(path string, length int64) (err error) {
1359
 
        _, _, e1 := Syscall(SYS_TRUNCATE, uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(length), 0)
 
1699
        var _p0 *byte
 
1700
        _p0, err = BytePtrFromString(path)
 
1701
        if err != nil {
 
1702
                return
 
1703
        }
 
1704
        _, _, e1 := Syscall(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
1360
1705
        if e1 != 0 {
1361
1706
                err = e1
1362
1707
        }
1376
1721
 
1377
1722
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1378
1723
 
 
1724
func accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) {
 
1725
        r0, _, e1 := Syscall6(SYS_ACCEPT4, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
 
1726
        fd = int(r0)
 
1727
        if e1 != 0 {
 
1728
                err = e1
 
1729
        }
 
1730
        return
 
1731
}
 
1732
 
 
1733
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1734
 
1379
1735
func bind(s int, addr uintptr, addrlen _Socklen) (err error) {
1380
1736
        _, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen))
1381
1737
        if e1 != 0 {
1448
1804
 
1449
1805
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1450
1806
 
1451
 
func socketpair(domain int, typ int, proto int, fd *[2]int) (err error) {
 
1807
func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
1452
1808
        _, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
1453
1809
        if e1 != 0 {
1454
1810
                err = e1