← Back to branch summary

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

« back to all changes in this revision

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