← Back to branch summary

~ubuntu-branches/ubuntu/vivid/golang/vivid

« back to all changes in this revision

Viewing changes to src/pkg/syscall/zsyscall_linux_arm.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_arm.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 {
1046
1341
 
1047
1342
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1048
1343
 
 
1344
func accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) {
 
1345
        r0, _, e1 := Syscall6(SYS_ACCEPT4, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
 
1346
        fd = int(r0)
 
1347
        if e1 != 0 {
 
1348
                err = e1
 
1349
        }
 
1350
        return
 
1351
}
 
1352
 
 
1353
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1354
 
1049
1355
func bind(s int, addr uintptr, addrlen _Socklen) (err error) {
1050
1356
        _, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen))
1051
1357
        if e1 != 0 {
1171
1477
 
1172
1478
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1173
1479
 
1174
 
func socketpair(domain int, typ int, flags int, fd *[2]int) (err error) {
 
1480
func socketpair(domain int, typ int, flags int, fd *[2]int32) (err error) {
1175
1481
        _, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(flags), uintptr(unsafe.Pointer(fd)), 0, 0)
1176
1482
        if e1 != 0 {
1177
1483
                err = e1
1203
1509
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1204
1510
 
1205
1511
func Chown(path string, uid int, gid int) (err error) {
1206
 
        _, _, e1 := Syscall(SYS_CHOWN32, uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(uid), uintptr(gid))
 
1512
        var _p0 *byte
 
1513
        _p0, err = BytePtrFromString(path)
 
1514
        if err != nil {
 
1515
                return
 
1516
        }
 
1517
        _, _, e1 := Syscall(SYS_CHOWN32, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
1207
1518
        if e1 != 0 {
1208
1519
                err = e1
1209
1520
        }
1232
1543
 
1233
1544
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1234
1545
 
1235
 
func Fstatfs(fd int, buf *Statfs_t) (err error) {
1236
 
        _, _, e1 := Syscall(SYS_FSTATFS64, uintptr(fd), uintptr(unsafe.Pointer(buf)), 0)
1237
 
        if e1 != 0 {
1238
 
                err = e1
1239
 
        }
1240
 
        return
1241
 
}
1242
 
 
1243
 
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1244
 
 
1245
1546
func Getegid() (egid int) {
1246
1547
        r0, _, _ := RawSyscall(SYS_GETEGID32, 0, 0, 0)
1247
1548
        egid = int(r0)
1275
1576
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1276
1577
 
1277
1578
func Lchown(path string, uid int, gid int) (err error) {
1278
 
        _, _, e1 := Syscall(SYS_LCHOWN32, uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(uid), uintptr(gid))
 
1579
        var _p0 *byte
 
1580
        _p0, err = BytePtrFromString(path)
 
1581
        if err != nil {
 
1582
                return
 
1583
        }
 
1584
        _, _, e1 := Syscall(SYS_LCHOWN32, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
1279
1585
        if e1 != 0 {
1280
1586
                err = e1
1281
1587
        }
1295
1601
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1296
1602
 
1297
1603
func Lstat(path string, stat *Stat_t) (err error) {
1298
 
        _, _, e1 := Syscall(SYS_LSTAT64, uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(unsafe.Pointer(stat)), 0)
 
1604
        var _p0 *byte
 
1605
        _p0, err = BytePtrFromString(path)
 
1606
        if err != nil {
 
1607
                return
 
1608
        }
 
1609
        _, _, e1 := Syscall(SYS_LSTAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
1299
1610
        if e1 != 0 {
1300
1611
                err = e1
1301
1612
        }
1304
1615
 
1305
1616
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1306
1617
 
1307
 
func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
 
1618
func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
1308
1619
        r0, _, e1 := Syscall6(SYS_SENDFILE64, uintptr(outfd), uintptr(infd), uintptr(unsafe.Pointer(offset)), uintptr(count), 0, 0)
1309
1620
        written = int(r0)
1310
1621
        if e1 != 0 {
1418
1729
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1419
1730
 
1420
1731
func Stat(path string, stat *Stat_t) (err error) {
1421
 
        _, _, e1 := Syscall(SYS_STAT64, uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(unsafe.Pointer(stat)), 0)
1422
 
        if e1 != 0 {
1423
 
                err = e1
 
1732
        var _p0 *byte
 
1733
        _p0, err = BytePtrFromString(path)
 
1734
        if err != nil {
 
1735
                return
1424
1736
        }
1425
 
        return
1426
 
}
1427
 
 
1428
 
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1429
 
 
1430
 
func Statfs(path string, buf *Statfs_t) (err error) {
1431
 
        _, _, e1 := Syscall(SYS_STATFS64, uintptr(unsafe.Pointer(StringBytePtr(path))), uintptr(unsafe.Pointer(buf)), 0)
 
1737
        _, _, e1 := Syscall(SYS_STAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
1432
1738
        if e1 != 0 {
1433
1739
                err = e1
1434
1740
        }
1493
1799
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1494
1800
 
1495
1801
func Truncate(path string, length int64) (err error) {
1496
 
        _, _, e1 := Syscall6(SYS_TRUNCATE64, uintptr(unsafe.Pointer(StringBytePtr(path))), 0, uintptr(length), uintptr(length>>32), 0, 0)
 
1802
        var _p0 *byte
 
1803
        _p0, err = BytePtrFromString(path)
 
1804
        if err != nil {
 
1805
                return
 
1806
        }
 
1807
        _, _, e1 := Syscall6(SYS_TRUNCATE64, uintptr(unsafe.Pointer(_p0)), 0, uintptr(length), uintptr(length>>32), 0, 0)
1497
1808
        if e1 != 0 {
1498
1809
                err = e1
1499
1810
        }
1520
1831
        }
1521
1832
        return
1522
1833
}
 
1834
 
 
1835
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1836
 
 
1837
func getrlimit(resource int, rlim *rlimit32) (err error) {
 
1838
        _, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0)
 
1839
        if e1 != 0 {
 
1840
                err = e1
 
1841
        }
 
1842
        return
 
1843
}
 
1844
 
 
1845
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
1846
 
 
1847
func setrlimit(resource int, rlim *rlimit32) (err error) {
 
1848
        _, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0)
 
1849
        if e1 != 0 {
 
1850
                err = e1
 
1851
        }
 
1852
        return
 
1853
}