← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/gabriel-samfira/sys/unix/zsyscall_openbsd_386.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-24 20:56:05 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161024205605-z8lta0uvuhtxwzwl
Initi with beta15

Show diffs side-by-side

added added

removed removed

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