vendor/golang.org/x/sys/unix/zsyscall_linux.go
changeset 256 6d9efbef00a9
parent 251 1c52a0eeb952
child 260 445e01aede7e
equal deleted inserted replaced
255:4f153a23adab 256:6d9efbef00a9
       
     1 // Code generated by mkmerge.go; DO NOT EDIT.
       
     2 
       
     3 //go:build linux
       
     4 // +build linux
       
     5 
       
     6 package unix
       
     7 
       
     8 import (
       
     9 	"syscall"
       
    10 	"unsafe"
       
    11 )
       
    12 
       
    13 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
    14 
       
    15 func FanotifyInit(flags uint, event_f_flags uint) (fd int, err error) {
       
    16 	r0, _, e1 := Syscall(SYS_FANOTIFY_INIT, uintptr(flags), uintptr(event_f_flags), 0)
       
    17 	fd = int(r0)
       
    18 	if e1 != 0 {
       
    19 		err = errnoErr(e1)
       
    20 	}
       
    21 	return
       
    22 }
       
    23 
       
    24 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
    25 
       
    26 func fchmodat(dirfd int, path string, mode uint32) (err error) {
       
    27 	var _p0 *byte
       
    28 	_p0, err = BytePtrFromString(path)
       
    29 	if err != nil {
       
    30 		return
       
    31 	}
       
    32 	_, _, e1 := Syscall(SYS_FCHMODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
       
    33 	if e1 != 0 {
       
    34 		err = errnoErr(e1)
       
    35 	}
       
    36 	return
       
    37 }
       
    38 
       
    39 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
    40 
       
    41 func ioctl(fd int, req uint, arg uintptr) (err error) {
       
    42 	_, _, e1 := Syscall(SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(arg))
       
    43 	if e1 != 0 {
       
    44 		err = errnoErr(e1)
       
    45 	}
       
    46 	return
       
    47 }
       
    48 
       
    49 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
    50 
       
    51 func Linkat(olddirfd int, oldpath string, newdirfd int, newpath string, flags int) (err error) {
       
    52 	var _p0 *byte
       
    53 	_p0, err = BytePtrFromString(oldpath)
       
    54 	if err != nil {
       
    55 		return
       
    56 	}
       
    57 	var _p1 *byte
       
    58 	_p1, err = BytePtrFromString(newpath)
       
    59 	if err != nil {
       
    60 		return
       
    61 	}
       
    62 	_, _, e1 := Syscall6(SYS_LINKAT, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
       
    63 	if e1 != 0 {
       
    64 		err = errnoErr(e1)
       
    65 	}
       
    66 	return
       
    67 }
       
    68 
       
    69 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
    70 
       
    71 func openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) {
       
    72 	var _p0 *byte
       
    73 	_p0, err = BytePtrFromString(path)
       
    74 	if err != nil {
       
    75 		return
       
    76 	}
       
    77 	r0, _, e1 := Syscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(mode), 0, 0)
       
    78 	fd = int(r0)
       
    79 	if e1 != 0 {
       
    80 		err = errnoErr(e1)
       
    81 	}
       
    82 	return
       
    83 }
       
    84 
       
    85 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
    86 
       
    87 func openat2(dirfd int, path string, open_how *OpenHow, size int) (fd int, err error) {
       
    88 	var _p0 *byte
       
    89 	_p0, err = BytePtrFromString(path)
       
    90 	if err != nil {
       
    91 		return
       
    92 	}
       
    93 	r0, _, e1 := Syscall6(SYS_OPENAT2, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(open_how)), uintptr(size), 0, 0)
       
    94 	fd = int(r0)
       
    95 	if e1 != 0 {
       
    96 		err = errnoErr(e1)
       
    97 	}
       
    98 	return
       
    99 }
       
   100 
       
   101 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   102 
       
   103 func ppoll(fds *PollFd, nfds int, timeout *Timespec, sigmask *Sigset_t) (n int, err error) {
       
   104 	r0, _, e1 := Syscall6(SYS_PPOLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(unsafe.Pointer(timeout)), uintptr(unsafe.Pointer(sigmask)), 0, 0)
       
   105 	n = int(r0)
       
   106 	if e1 != 0 {
       
   107 		err = errnoErr(e1)
       
   108 	}
       
   109 	return
       
   110 }
       
   111 
       
   112 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   113 
       
   114 func Readlinkat(dirfd int, path string, buf []byte) (n int, err error) {
       
   115 	var _p0 *byte
       
   116 	_p0, err = BytePtrFromString(path)
       
   117 	if err != nil {
       
   118 		return
       
   119 	}
       
   120 	var _p1 unsafe.Pointer
       
   121 	if len(buf) > 0 {
       
   122 		_p1 = unsafe.Pointer(&buf[0])
       
   123 	} else {
       
   124 		_p1 = unsafe.Pointer(&_zero)
       
   125 	}
       
   126 	r0, _, e1 := Syscall6(SYS_READLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
       
   127 	n = int(r0)
       
   128 	if e1 != 0 {
       
   129 		err = errnoErr(e1)
       
   130 	}
       
   131 	return
       
   132 }
       
   133 
       
   134 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   135 
       
   136 func Symlinkat(oldpath string, newdirfd int, newpath string) (err error) {
       
   137 	var _p0 *byte
       
   138 	_p0, err = BytePtrFromString(oldpath)
       
   139 	if err != nil {
       
   140 		return
       
   141 	}
       
   142 	var _p1 *byte
       
   143 	_p1, err = BytePtrFromString(newpath)
       
   144 	if err != nil {
       
   145 		return
       
   146 	}
       
   147 	_, _, e1 := Syscall(SYS_SYMLINKAT, uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
       
   148 	if e1 != 0 {
       
   149 		err = errnoErr(e1)
       
   150 	}
       
   151 	return
       
   152 }
       
   153 
       
   154 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   155 
       
   156 func Unlinkat(dirfd int, path string, flags int) (err error) {
       
   157 	var _p0 *byte
       
   158 	_p0, err = BytePtrFromString(path)
       
   159 	if err != nil {
       
   160 		return
       
   161 	}
       
   162 	_, _, e1 := Syscall(SYS_UNLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
       
   163 	if e1 != 0 {
       
   164 		err = errnoErr(e1)
       
   165 	}
       
   166 	return
       
   167 }
       
   168 
       
   169 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   170 
       
   171 func utimensat(dirfd int, path string, times *[2]Timespec, flags int) (err error) {
       
   172 	var _p0 *byte
       
   173 	_p0, err = BytePtrFromString(path)
       
   174 	if err != nil {
       
   175 		return
       
   176 	}
       
   177 	_, _, e1 := Syscall6(SYS_UTIMENSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), uintptr(flags), 0, 0)
       
   178 	if e1 != 0 {
       
   179 		err = errnoErr(e1)
       
   180 	}
       
   181 	return
       
   182 }
       
   183 
       
   184 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   185 
       
   186 func Getcwd(buf []byte) (n int, err error) {
       
   187 	var _p0 unsafe.Pointer
       
   188 	if len(buf) > 0 {
       
   189 		_p0 = unsafe.Pointer(&buf[0])
       
   190 	} else {
       
   191 		_p0 = unsafe.Pointer(&_zero)
       
   192 	}
       
   193 	r0, _, e1 := Syscall(SYS_GETCWD, uintptr(_p0), uintptr(len(buf)), 0)
       
   194 	n = int(r0)
       
   195 	if e1 != 0 {
       
   196 		err = errnoErr(e1)
       
   197 	}
       
   198 	return
       
   199 }
       
   200 
       
   201 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   202 
       
   203 func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) {
       
   204 	r0, _, e1 := Syscall6(SYS_WAIT4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
       
   205 	wpid = int(r0)
       
   206 	if e1 != 0 {
       
   207 		err = errnoErr(e1)
       
   208 	}
       
   209 	return
       
   210 }
       
   211 
       
   212 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   213 
       
   214 func KeyctlInt(cmd int, arg2 int, arg3 int, arg4 int, arg5 int) (ret int, err error) {
       
   215 	r0, _, e1 := Syscall6(SYS_KEYCTL, uintptr(cmd), uintptr(arg2), uintptr(arg3), uintptr(arg4), uintptr(arg5), 0)
       
   216 	ret = int(r0)
       
   217 	if e1 != 0 {
       
   218 		err = errnoErr(e1)
       
   219 	}
       
   220 	return
       
   221 }
       
   222 
       
   223 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   224 
       
   225 func KeyctlBuffer(cmd int, arg2 int, buf []byte, arg5 int) (ret int, err error) {
       
   226 	var _p0 unsafe.Pointer
       
   227 	if len(buf) > 0 {
       
   228 		_p0 = unsafe.Pointer(&buf[0])
       
   229 	} else {
       
   230 		_p0 = unsafe.Pointer(&_zero)
       
   231 	}
       
   232 	r0, _, e1 := Syscall6(SYS_KEYCTL, uintptr(cmd), uintptr(arg2), uintptr(_p0), uintptr(len(buf)), uintptr(arg5), 0)
       
   233 	ret = int(r0)
       
   234 	if e1 != 0 {
       
   235 		err = errnoErr(e1)
       
   236 	}
       
   237 	return
       
   238 }
       
   239 
       
   240 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   241 
       
   242 func keyctlJoin(cmd int, arg2 string) (ret int, err error) {
       
   243 	var _p0 *byte
       
   244 	_p0, err = BytePtrFromString(arg2)
       
   245 	if err != nil {
       
   246 		return
       
   247 	}
       
   248 	r0, _, e1 := Syscall(SYS_KEYCTL, uintptr(cmd), uintptr(unsafe.Pointer(_p0)), 0)
       
   249 	ret = int(r0)
       
   250 	if e1 != 0 {
       
   251 		err = errnoErr(e1)
       
   252 	}
       
   253 	return
       
   254 }
       
   255 
       
   256 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   257 
       
   258 func keyctlSearch(cmd int, arg2 int, arg3 string, arg4 string, arg5 int) (ret int, err error) {
       
   259 	var _p0 *byte
       
   260 	_p0, err = BytePtrFromString(arg3)
       
   261 	if err != nil {
       
   262 		return
       
   263 	}
       
   264 	var _p1 *byte
       
   265 	_p1, err = BytePtrFromString(arg4)
       
   266 	if err != nil {
       
   267 		return
       
   268 	}
       
   269 	r0, _, e1 := Syscall6(SYS_KEYCTL, uintptr(cmd), uintptr(arg2), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(arg5), 0)
       
   270 	ret = int(r0)
       
   271 	if e1 != 0 {
       
   272 		err = errnoErr(e1)
       
   273 	}
       
   274 	return
       
   275 }
       
   276 
       
   277 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   278 
       
   279 func keyctlIOV(cmd int, arg2 int, payload []Iovec, arg5 int) (err error) {
       
   280 	var _p0 unsafe.Pointer
       
   281 	if len(payload) > 0 {
       
   282 		_p0 = unsafe.Pointer(&payload[0])
       
   283 	} else {
       
   284 		_p0 = unsafe.Pointer(&_zero)
       
   285 	}
       
   286 	_, _, e1 := Syscall6(SYS_KEYCTL, uintptr(cmd), uintptr(arg2), uintptr(_p0), uintptr(len(payload)), uintptr(arg5), 0)
       
   287 	if e1 != 0 {
       
   288 		err = errnoErr(e1)
       
   289 	}
       
   290 	return
       
   291 }
       
   292 
       
   293 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   294 
       
   295 func keyctlDH(cmd int, arg2 *KeyctlDHParams, buf []byte) (ret int, err error) {
       
   296 	var _p0 unsafe.Pointer
       
   297 	if len(buf) > 0 {
       
   298 		_p0 = unsafe.Pointer(&buf[0])
       
   299 	} else {
       
   300 		_p0 = unsafe.Pointer(&_zero)
       
   301 	}
       
   302 	r0, _, e1 := Syscall6(SYS_KEYCTL, uintptr(cmd), uintptr(unsafe.Pointer(arg2)), uintptr(_p0), uintptr(len(buf)), 0, 0)
       
   303 	ret = int(r0)
       
   304 	if e1 != 0 {
       
   305 		err = errnoErr(e1)
       
   306 	}
       
   307 	return
       
   308 }
       
   309 
       
   310 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   311 
       
   312 func keyctlRestrictKeyringByType(cmd int, arg2 int, keyType string, restriction string) (err error) {
       
   313 	var _p0 *byte
       
   314 	_p0, err = BytePtrFromString(keyType)
       
   315 	if err != nil {
       
   316 		return
       
   317 	}
       
   318 	var _p1 *byte
       
   319 	_p1, err = BytePtrFromString(restriction)
       
   320 	if err != nil {
       
   321 		return
       
   322 	}
       
   323 	_, _, e1 := Syscall6(SYS_KEYCTL, uintptr(cmd), uintptr(arg2), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0, 0)
       
   324 	if e1 != 0 {
       
   325 		err = errnoErr(e1)
       
   326 	}
       
   327 	return
       
   328 }
       
   329 
       
   330 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   331 
       
   332 func keyctlRestrictKeyring(cmd int, arg2 int) (err error) {
       
   333 	_, _, e1 := Syscall(SYS_KEYCTL, uintptr(cmd), uintptr(arg2), 0)
       
   334 	if e1 != 0 {
       
   335 		err = errnoErr(e1)
       
   336 	}
       
   337 	return
       
   338 }
       
   339 
       
   340 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   341 
       
   342 func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
       
   343 	_, _, e1 := Syscall6(SYS_PTRACE, uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
       
   344 	if e1 != 0 {
       
   345 		err = errnoErr(e1)
       
   346 	}
       
   347 	return
       
   348 }
       
   349 
       
   350 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   351 
       
   352 func reboot(magic1 uint, magic2 uint, cmd int, arg string) (err error) {
       
   353 	var _p0 *byte
       
   354 	_p0, err = BytePtrFromString(arg)
       
   355 	if err != nil {
       
   356 		return
       
   357 	}
       
   358 	_, _, e1 := Syscall6(SYS_REBOOT, uintptr(magic1), uintptr(magic2), uintptr(cmd), uintptr(unsafe.Pointer(_p0)), 0, 0)
       
   359 	if e1 != 0 {
       
   360 		err = errnoErr(e1)
       
   361 	}
       
   362 	return
       
   363 }
       
   364 
       
   365 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   366 
       
   367 func mount(source string, target string, fstype string, flags uintptr, data *byte) (err error) {
       
   368 	var _p0 *byte
       
   369 	_p0, err = BytePtrFromString(source)
       
   370 	if err != nil {
       
   371 		return
       
   372 	}
       
   373 	var _p1 *byte
       
   374 	_p1, err = BytePtrFromString(target)
       
   375 	if err != nil {
       
   376 		return
       
   377 	}
       
   378 	var _p2 *byte
       
   379 	_p2, err = BytePtrFromString(fstype)
       
   380 	if err != nil {
       
   381 		return
       
   382 	}
       
   383 	_, _, e1 := Syscall6(SYS_MOUNT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(_p2)), uintptr(flags), uintptr(unsafe.Pointer(data)), 0)
       
   384 	if e1 != 0 {
       
   385 		err = errnoErr(e1)
       
   386 	}
       
   387 	return
       
   388 }
       
   389 
       
   390 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   391 
       
   392 func Acct(path string) (err error) {
       
   393 	var _p0 *byte
       
   394 	_p0, err = BytePtrFromString(path)
       
   395 	if err != nil {
       
   396 		return
       
   397 	}
       
   398 	_, _, e1 := Syscall(SYS_ACCT, uintptr(unsafe.Pointer(_p0)), 0, 0)
       
   399 	if e1 != 0 {
       
   400 		err = errnoErr(e1)
       
   401 	}
       
   402 	return
       
   403 }
       
   404 
       
   405 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   406 
       
   407 func AddKey(keyType string, description string, payload []byte, ringid int) (id int, err error) {
       
   408 	var _p0 *byte
       
   409 	_p0, err = BytePtrFromString(keyType)
       
   410 	if err != nil {
       
   411 		return
       
   412 	}
       
   413 	var _p1 *byte
       
   414 	_p1, err = BytePtrFromString(description)
       
   415 	if err != nil {
       
   416 		return
       
   417 	}
       
   418 	var _p2 unsafe.Pointer
       
   419 	if len(payload) > 0 {
       
   420 		_p2 = unsafe.Pointer(&payload[0])
       
   421 	} else {
       
   422 		_p2 = unsafe.Pointer(&_zero)
       
   423 	}
       
   424 	r0, _, e1 := Syscall6(SYS_ADD_KEY, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(payload)), uintptr(ringid), 0)
       
   425 	id = int(r0)
       
   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 Adjtimex(buf *Timex) (state int, err error) {
       
   435 	r0, _, e1 := Syscall(SYS_ADJTIMEX, uintptr(unsafe.Pointer(buf)), 0, 0)
       
   436 	state = int(r0)
       
   437 	if e1 != 0 {
       
   438 		err = errnoErr(e1)
       
   439 	}
       
   440 	return
       
   441 }
       
   442 
       
   443 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   444 
       
   445 func Capget(hdr *CapUserHeader, data *CapUserData) (err error) {
       
   446 	_, _, e1 := RawSyscall(SYS_CAPGET, uintptr(unsafe.Pointer(hdr)), uintptr(unsafe.Pointer(data)), 0)
       
   447 	if e1 != 0 {
       
   448 		err = errnoErr(e1)
       
   449 	}
       
   450 	return
       
   451 }
       
   452 
       
   453 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   454 
       
   455 func Capset(hdr *CapUserHeader, data *CapUserData) (err error) {
       
   456 	_, _, e1 := RawSyscall(SYS_CAPSET, uintptr(unsafe.Pointer(hdr)), uintptr(unsafe.Pointer(data)), 0)
       
   457 	if e1 != 0 {
       
   458 		err = errnoErr(e1)
       
   459 	}
       
   460 	return
       
   461 }
       
   462 
       
   463 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   464 
       
   465 func Chdir(path string) (err error) {
       
   466 	var _p0 *byte
       
   467 	_p0, err = BytePtrFromString(path)
       
   468 	if err != nil {
       
   469 		return
       
   470 	}
       
   471 	_, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
       
   472 	if e1 != 0 {
       
   473 		err = errnoErr(e1)
       
   474 	}
       
   475 	return
       
   476 }
       
   477 
       
   478 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   479 
       
   480 func Chroot(path string) (err error) {
       
   481 	var _p0 *byte
       
   482 	_p0, err = BytePtrFromString(path)
       
   483 	if err != nil {
       
   484 		return
       
   485 	}
       
   486 	_, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0)
       
   487 	if e1 != 0 {
       
   488 		err = errnoErr(e1)
       
   489 	}
       
   490 	return
       
   491 }
       
   492 
       
   493 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   494 
       
   495 func ClockGetres(clockid int32, res *Timespec) (err error) {
       
   496 	_, _, e1 := Syscall(SYS_CLOCK_GETRES, uintptr(clockid), uintptr(unsafe.Pointer(res)), 0)
       
   497 	if e1 != 0 {
       
   498 		err = errnoErr(e1)
       
   499 	}
       
   500 	return
       
   501 }
       
   502 
       
   503 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   504 
       
   505 func ClockGettime(clockid int32, time *Timespec) (err error) {
       
   506 	_, _, e1 := Syscall(SYS_CLOCK_GETTIME, uintptr(clockid), uintptr(unsafe.Pointer(time)), 0)
       
   507 	if e1 != 0 {
       
   508 		err = errnoErr(e1)
       
   509 	}
       
   510 	return
       
   511 }
       
   512 
       
   513 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   514 
       
   515 func ClockNanosleep(clockid int32, flags int, request *Timespec, remain *Timespec) (err error) {
       
   516 	_, _, e1 := Syscall6(SYS_CLOCK_NANOSLEEP, uintptr(clockid), uintptr(flags), uintptr(unsafe.Pointer(request)), uintptr(unsafe.Pointer(remain)), 0, 0)
       
   517 	if e1 != 0 {
       
   518 		err = errnoErr(e1)
       
   519 	}
       
   520 	return
       
   521 }
       
   522 
       
   523 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   524 
       
   525 func Close(fd int) (err error) {
       
   526 	_, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
       
   527 	if e1 != 0 {
       
   528 		err = errnoErr(e1)
       
   529 	}
       
   530 	return
       
   531 }
       
   532 
       
   533 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   534 
       
   535 func CloseRange(first uint, last uint, flags uint) (err error) {
       
   536 	_, _, e1 := Syscall(SYS_CLOSE_RANGE, uintptr(first), uintptr(last), uintptr(flags))
       
   537 	if e1 != 0 {
       
   538 		err = errnoErr(e1)
       
   539 	}
       
   540 	return
       
   541 }
       
   542 
       
   543 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   544 
       
   545 func CopyFileRange(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int, err error) {
       
   546 	r0, _, e1 := Syscall6(SYS_COPY_FILE_RANGE, uintptr(rfd), uintptr(unsafe.Pointer(roff)), uintptr(wfd), uintptr(unsafe.Pointer(woff)), uintptr(len), uintptr(flags))
       
   547 	n = int(r0)
       
   548 	if e1 != 0 {
       
   549 		err = errnoErr(e1)
       
   550 	}
       
   551 	return
       
   552 }
       
   553 
       
   554 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   555 
       
   556 func DeleteModule(name string, flags int) (err error) {
       
   557 	var _p0 *byte
       
   558 	_p0, err = BytePtrFromString(name)
       
   559 	if err != nil {
       
   560 		return
       
   561 	}
       
   562 	_, _, e1 := Syscall(SYS_DELETE_MODULE, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
       
   563 	if e1 != 0 {
       
   564 		err = errnoErr(e1)
       
   565 	}
       
   566 	return
       
   567 }
       
   568 
       
   569 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   570 
       
   571 func Dup(oldfd int) (fd int, err error) {
       
   572 	r0, _, e1 := Syscall(SYS_DUP, uintptr(oldfd), 0, 0)
       
   573 	fd = int(r0)
       
   574 	if e1 != 0 {
       
   575 		err = errnoErr(e1)
       
   576 	}
       
   577 	return
       
   578 }
       
   579 
       
   580 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   581 
       
   582 func Dup3(oldfd int, newfd int, flags int) (err error) {
       
   583 	_, _, e1 := Syscall(SYS_DUP3, uintptr(oldfd), uintptr(newfd), uintptr(flags))
       
   584 	if e1 != 0 {
       
   585 		err = errnoErr(e1)
       
   586 	}
       
   587 	return
       
   588 }
       
   589 
       
   590 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   591 
       
   592 func EpollCreate1(flag int) (fd int, err error) {
       
   593 	r0, _, e1 := RawSyscall(SYS_EPOLL_CREATE1, uintptr(flag), 0, 0)
       
   594 	fd = int(r0)
       
   595 	if e1 != 0 {
       
   596 		err = errnoErr(e1)
       
   597 	}
       
   598 	return
       
   599 }
       
   600 
       
   601 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   602 
       
   603 func EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) {
       
   604 	_, _, e1 := RawSyscall6(SYS_EPOLL_CTL, uintptr(epfd), uintptr(op), uintptr(fd), uintptr(unsafe.Pointer(event)), 0, 0)
       
   605 	if e1 != 0 {
       
   606 		err = errnoErr(e1)
       
   607 	}
       
   608 	return
       
   609 }
       
   610 
       
   611 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   612 
       
   613 func Eventfd(initval uint, flags int) (fd int, err error) {
       
   614 	r0, _, e1 := Syscall(SYS_EVENTFD2, uintptr(initval), uintptr(flags), 0)
       
   615 	fd = int(r0)
       
   616 	if e1 != 0 {
       
   617 		err = errnoErr(e1)
       
   618 	}
       
   619 	return
       
   620 }
       
   621 
       
   622 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   623 
       
   624 func Exit(code int) {
       
   625 	SyscallNoError(SYS_EXIT_GROUP, uintptr(code), 0, 0)
       
   626 	return
       
   627 }
       
   628 
       
   629 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   630 
       
   631 func Fchdir(fd int) (err error) {
       
   632 	_, _, e1 := Syscall(SYS_FCHDIR, uintptr(fd), 0, 0)
       
   633 	if e1 != 0 {
       
   634 		err = errnoErr(e1)
       
   635 	}
       
   636 	return
       
   637 }
       
   638 
       
   639 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   640 
       
   641 func Fchmod(fd int, mode uint32) (err error) {
       
   642 	_, _, e1 := Syscall(SYS_FCHMOD, uintptr(fd), uintptr(mode), 0)
       
   643 	if e1 != 0 {
       
   644 		err = errnoErr(e1)
       
   645 	}
       
   646 	return
       
   647 }
       
   648 
       
   649 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   650 
       
   651 func Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error) {
       
   652 	var _p0 *byte
       
   653 	_p0, err = BytePtrFromString(path)
       
   654 	if err != nil {
       
   655 		return
       
   656 	}
       
   657 	_, _, e1 := Syscall6(SYS_FCHOWNAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
       
   658 	if e1 != 0 {
       
   659 		err = errnoErr(e1)
       
   660 	}
       
   661 	return
       
   662 }
       
   663 
       
   664 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   665 
       
   666 func Fdatasync(fd int) (err error) {
       
   667 	_, _, e1 := Syscall(SYS_FDATASYNC, uintptr(fd), 0, 0)
       
   668 	if e1 != 0 {
       
   669 		err = errnoErr(e1)
       
   670 	}
       
   671 	return
       
   672 }
       
   673 
       
   674 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   675 
       
   676 func Fgetxattr(fd int, attr string, dest []byte) (sz int, err error) {
       
   677 	var _p0 *byte
       
   678 	_p0, err = BytePtrFromString(attr)
       
   679 	if err != nil {
       
   680 		return
       
   681 	}
       
   682 	var _p1 unsafe.Pointer
       
   683 	if len(dest) > 0 {
       
   684 		_p1 = unsafe.Pointer(&dest[0])
       
   685 	} else {
       
   686 		_p1 = unsafe.Pointer(&_zero)
       
   687 	}
       
   688 	r0, _, e1 := Syscall6(SYS_FGETXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest)), 0, 0)
       
   689 	sz = int(r0)
       
   690 	if e1 != 0 {
       
   691 		err = errnoErr(e1)
       
   692 	}
       
   693 	return
       
   694 }
       
   695 
       
   696 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   697 
       
   698 func FinitModule(fd int, params string, flags int) (err error) {
       
   699 	var _p0 *byte
       
   700 	_p0, err = BytePtrFromString(params)
       
   701 	if err != nil {
       
   702 		return
       
   703 	}
       
   704 	_, _, e1 := Syscall(SYS_FINIT_MODULE, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
       
   705 	if e1 != 0 {
       
   706 		err = errnoErr(e1)
       
   707 	}
       
   708 	return
       
   709 }
       
   710 
       
   711 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   712 
       
   713 func Flistxattr(fd int, dest []byte) (sz int, err error) {
       
   714 	var _p0 unsafe.Pointer
       
   715 	if len(dest) > 0 {
       
   716 		_p0 = unsafe.Pointer(&dest[0])
       
   717 	} else {
       
   718 		_p0 = unsafe.Pointer(&_zero)
       
   719 	}
       
   720 	r0, _, e1 := Syscall(SYS_FLISTXATTR, uintptr(fd), uintptr(_p0), uintptr(len(dest)))
       
   721 	sz = int(r0)
       
   722 	if e1 != 0 {
       
   723 		err = errnoErr(e1)
       
   724 	}
       
   725 	return
       
   726 }
       
   727 
       
   728 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   729 
       
   730 func Flock(fd int, how int) (err error) {
       
   731 	_, _, e1 := Syscall(SYS_FLOCK, uintptr(fd), uintptr(how), 0)
       
   732 	if e1 != 0 {
       
   733 		err = errnoErr(e1)
       
   734 	}
       
   735 	return
       
   736 }
       
   737 
       
   738 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   739 
       
   740 func Fremovexattr(fd int, attr string) (err error) {
       
   741 	var _p0 *byte
       
   742 	_p0, err = BytePtrFromString(attr)
       
   743 	if err != nil {
       
   744 		return
       
   745 	}
       
   746 	_, _, e1 := Syscall(SYS_FREMOVEXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), 0)
       
   747 	if e1 != 0 {
       
   748 		err = errnoErr(e1)
       
   749 	}
       
   750 	return
       
   751 }
       
   752 
       
   753 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   754 
       
   755 func Fsetxattr(fd int, attr string, dest []byte, flags int) (err error) {
       
   756 	var _p0 *byte
       
   757 	_p0, err = BytePtrFromString(attr)
       
   758 	if err != nil {
       
   759 		return
       
   760 	}
       
   761 	var _p1 unsafe.Pointer
       
   762 	if len(dest) > 0 {
       
   763 		_p1 = unsafe.Pointer(&dest[0])
       
   764 	} else {
       
   765 		_p1 = unsafe.Pointer(&_zero)
       
   766 	}
       
   767 	_, _, e1 := Syscall6(SYS_FSETXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest)), uintptr(flags), 0)
       
   768 	if e1 != 0 {
       
   769 		err = errnoErr(e1)
       
   770 	}
       
   771 	return
       
   772 }
       
   773 
       
   774 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   775 
       
   776 func Fsync(fd int) (err error) {
       
   777 	_, _, e1 := Syscall(SYS_FSYNC, uintptr(fd), 0, 0)
       
   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 Getdents(fd int, buf []byte) (n int, err error) {
       
   787 	var _p0 unsafe.Pointer
       
   788 	if len(buf) > 0 {
       
   789 		_p0 = unsafe.Pointer(&buf[0])
       
   790 	} else {
       
   791 		_p0 = unsafe.Pointer(&_zero)
       
   792 	}
       
   793 	r0, _, e1 := Syscall(SYS_GETDENTS64, uintptr(fd), uintptr(_p0), uintptr(len(buf)))
       
   794 	n = int(r0)
       
   795 	if e1 != 0 {
       
   796 		err = errnoErr(e1)
       
   797 	}
       
   798 	return
       
   799 }
       
   800 
       
   801 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   802 
       
   803 func Getpgid(pid int) (pgid int, err error) {
       
   804 	r0, _, e1 := RawSyscall(SYS_GETPGID, uintptr(pid), 0, 0)
       
   805 	pgid = int(r0)
       
   806 	if e1 != 0 {
       
   807 		err = errnoErr(e1)
       
   808 	}
       
   809 	return
       
   810 }
       
   811 
       
   812 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   813 
       
   814 func Getpid() (pid int) {
       
   815 	r0, _ := RawSyscallNoError(SYS_GETPID, 0, 0, 0)
       
   816 	pid = int(r0)
       
   817 	return
       
   818 }
       
   819 
       
   820 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   821 
       
   822 func Getppid() (ppid int) {
       
   823 	r0, _ := RawSyscallNoError(SYS_GETPPID, 0, 0, 0)
       
   824 	ppid = int(r0)
       
   825 	return
       
   826 }
       
   827 
       
   828 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   829 
       
   830 func Getpriority(which int, who int) (prio int, err error) {
       
   831 	r0, _, e1 := Syscall(SYS_GETPRIORITY, uintptr(which), uintptr(who), 0)
       
   832 	prio = int(r0)
       
   833 	if e1 != 0 {
       
   834 		err = errnoErr(e1)
       
   835 	}
       
   836 	return
       
   837 }
       
   838 
       
   839 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   840 
       
   841 func Getrandom(buf []byte, flags int) (n int, err error) {
       
   842 	var _p0 unsafe.Pointer
       
   843 	if len(buf) > 0 {
       
   844 		_p0 = unsafe.Pointer(&buf[0])
       
   845 	} else {
       
   846 		_p0 = unsafe.Pointer(&_zero)
       
   847 	}
       
   848 	r0, _, e1 := Syscall(SYS_GETRANDOM, uintptr(_p0), uintptr(len(buf)), uintptr(flags))
       
   849 	n = int(r0)
       
   850 	if e1 != 0 {
       
   851 		err = errnoErr(e1)
       
   852 	}
       
   853 	return
       
   854 }
       
   855 
       
   856 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   857 
       
   858 func Getrusage(who int, rusage *Rusage) (err error) {
       
   859 	_, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
       
   860 	if e1 != 0 {
       
   861 		err = errnoErr(e1)
       
   862 	}
       
   863 	return
       
   864 }
       
   865 
       
   866 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   867 
       
   868 func Getsid(pid int) (sid int, err error) {
       
   869 	r0, _, e1 := RawSyscall(SYS_GETSID, uintptr(pid), 0, 0)
       
   870 	sid = int(r0)
       
   871 	if e1 != 0 {
       
   872 		err = errnoErr(e1)
       
   873 	}
       
   874 	return
       
   875 }
       
   876 
       
   877 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   878 
       
   879 func Gettid() (tid int) {
       
   880 	r0, _ := RawSyscallNoError(SYS_GETTID, 0, 0, 0)
       
   881 	tid = int(r0)
       
   882 	return
       
   883 }
       
   884 
       
   885 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   886 
       
   887 func Getxattr(path string, attr string, dest []byte) (sz int, err error) {
       
   888 	var _p0 *byte
       
   889 	_p0, err = BytePtrFromString(path)
       
   890 	if err != nil {
       
   891 		return
       
   892 	}
       
   893 	var _p1 *byte
       
   894 	_p1, err = BytePtrFromString(attr)
       
   895 	if err != nil {
       
   896 		return
       
   897 	}
       
   898 	var _p2 unsafe.Pointer
       
   899 	if len(dest) > 0 {
       
   900 		_p2 = unsafe.Pointer(&dest[0])
       
   901 	} else {
       
   902 		_p2 = unsafe.Pointer(&_zero)
       
   903 	}
       
   904 	r0, _, e1 := Syscall6(SYS_GETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(dest)), 0, 0)
       
   905 	sz = 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 InitModule(moduleImage []byte, params string) (err error) {
       
   915 	var _p0 unsafe.Pointer
       
   916 	if len(moduleImage) > 0 {
       
   917 		_p0 = unsafe.Pointer(&moduleImage[0])
       
   918 	} else {
       
   919 		_p0 = unsafe.Pointer(&_zero)
       
   920 	}
       
   921 	var _p1 *byte
       
   922 	_p1, err = BytePtrFromString(params)
       
   923 	if err != nil {
       
   924 		return
       
   925 	}
       
   926 	_, _, e1 := Syscall(SYS_INIT_MODULE, uintptr(_p0), uintptr(len(moduleImage)), uintptr(unsafe.Pointer(_p1)))
       
   927 	if e1 != 0 {
       
   928 		err = errnoErr(e1)
       
   929 	}
       
   930 	return
       
   931 }
       
   932 
       
   933 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   934 
       
   935 func InotifyAddWatch(fd int, pathname string, mask uint32) (watchdesc int, err error) {
       
   936 	var _p0 *byte
       
   937 	_p0, err = BytePtrFromString(pathname)
       
   938 	if err != nil {
       
   939 		return
       
   940 	}
       
   941 	r0, _, e1 := Syscall(SYS_INOTIFY_ADD_WATCH, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(mask))
       
   942 	watchdesc = int(r0)
       
   943 	if e1 != 0 {
       
   944 		err = errnoErr(e1)
       
   945 	}
       
   946 	return
       
   947 }
       
   948 
       
   949 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   950 
       
   951 func InotifyInit1(flags int) (fd int, err error) {
       
   952 	r0, _, e1 := RawSyscall(SYS_INOTIFY_INIT1, uintptr(flags), 0, 0)
       
   953 	fd = int(r0)
       
   954 	if e1 != 0 {
       
   955 		err = errnoErr(e1)
       
   956 	}
       
   957 	return
       
   958 }
       
   959 
       
   960 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   961 
       
   962 func InotifyRmWatch(fd int, watchdesc uint32) (success int, err error) {
       
   963 	r0, _, e1 := RawSyscall(SYS_INOTIFY_RM_WATCH, uintptr(fd), uintptr(watchdesc), 0)
       
   964 	success = int(r0)
       
   965 	if e1 != 0 {
       
   966 		err = errnoErr(e1)
       
   967 	}
       
   968 	return
       
   969 }
       
   970 
       
   971 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   972 
       
   973 func Kill(pid int, sig syscall.Signal) (err error) {
       
   974 	_, _, e1 := RawSyscall(SYS_KILL, uintptr(pid), uintptr(sig), 0)
       
   975 	if e1 != 0 {
       
   976 		err = errnoErr(e1)
       
   977 	}
       
   978 	return
       
   979 }
       
   980 
       
   981 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   982 
       
   983 func Klogctl(typ int, buf []byte) (n int, err error) {
       
   984 	var _p0 unsafe.Pointer
       
   985 	if len(buf) > 0 {
       
   986 		_p0 = unsafe.Pointer(&buf[0])
       
   987 	} else {
       
   988 		_p0 = unsafe.Pointer(&_zero)
       
   989 	}
       
   990 	r0, _, e1 := Syscall(SYS_SYSLOG, uintptr(typ), uintptr(_p0), uintptr(len(buf)))
       
   991 	n = int(r0)
       
   992 	if e1 != 0 {
       
   993 		err = errnoErr(e1)
       
   994 	}
       
   995 	return
       
   996 }
       
   997 
       
   998 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   999 
       
  1000 func Lgetxattr(path string, attr string, dest []byte) (sz int, err error) {
       
  1001 	var _p0 *byte
       
  1002 	_p0, err = BytePtrFromString(path)
       
  1003 	if err != nil {
       
  1004 		return
       
  1005 	}
       
  1006 	var _p1 *byte
       
  1007 	_p1, err = BytePtrFromString(attr)
       
  1008 	if err != nil {
       
  1009 		return
       
  1010 	}
       
  1011 	var _p2 unsafe.Pointer
       
  1012 	if len(dest) > 0 {
       
  1013 		_p2 = unsafe.Pointer(&dest[0])
       
  1014 	} else {
       
  1015 		_p2 = unsafe.Pointer(&_zero)
       
  1016 	}
       
  1017 	r0, _, e1 := Syscall6(SYS_LGETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(dest)), 0, 0)
       
  1018 	sz = int(r0)
       
  1019 	if e1 != 0 {
       
  1020 		err = errnoErr(e1)
       
  1021 	}
       
  1022 	return
       
  1023 }
       
  1024 
       
  1025 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1026 
       
  1027 func Listxattr(path string, dest []byte) (sz int, err error) {
       
  1028 	var _p0 *byte
       
  1029 	_p0, err = BytePtrFromString(path)
       
  1030 	if err != nil {
       
  1031 		return
       
  1032 	}
       
  1033 	var _p1 unsafe.Pointer
       
  1034 	if len(dest) > 0 {
       
  1035 		_p1 = unsafe.Pointer(&dest[0])
       
  1036 	} else {
       
  1037 		_p1 = unsafe.Pointer(&_zero)
       
  1038 	}
       
  1039 	r0, _, e1 := Syscall(SYS_LISTXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest)))
       
  1040 	sz = int(r0)
       
  1041 	if e1 != 0 {
       
  1042 		err = errnoErr(e1)
       
  1043 	}
       
  1044 	return
       
  1045 }
       
  1046 
       
  1047 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1048 
       
  1049 func Llistxattr(path string, dest []byte) (sz int, err error) {
       
  1050 	var _p0 *byte
       
  1051 	_p0, err = BytePtrFromString(path)
       
  1052 	if err != nil {
       
  1053 		return
       
  1054 	}
       
  1055 	var _p1 unsafe.Pointer
       
  1056 	if len(dest) > 0 {
       
  1057 		_p1 = unsafe.Pointer(&dest[0])
       
  1058 	} else {
       
  1059 		_p1 = unsafe.Pointer(&_zero)
       
  1060 	}
       
  1061 	r0, _, e1 := Syscall(SYS_LLISTXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest)))
       
  1062 	sz = int(r0)
       
  1063 	if e1 != 0 {
       
  1064 		err = errnoErr(e1)
       
  1065 	}
       
  1066 	return
       
  1067 }
       
  1068 
       
  1069 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1070 
       
  1071 func Lremovexattr(path string, attr string) (err error) {
       
  1072 	var _p0 *byte
       
  1073 	_p0, err = BytePtrFromString(path)
       
  1074 	if err != nil {
       
  1075 		return
       
  1076 	}
       
  1077 	var _p1 *byte
       
  1078 	_p1, err = BytePtrFromString(attr)
       
  1079 	if err != nil {
       
  1080 		return
       
  1081 	}
       
  1082 	_, _, e1 := Syscall(SYS_LREMOVEXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
       
  1083 	if e1 != 0 {
       
  1084 		err = errnoErr(e1)
       
  1085 	}
       
  1086 	return
       
  1087 }
       
  1088 
       
  1089 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1090 
       
  1091 func Lsetxattr(path string, attr string, data []byte, flags int) (err error) {
       
  1092 	var _p0 *byte
       
  1093 	_p0, err = BytePtrFromString(path)
       
  1094 	if err != nil {
       
  1095 		return
       
  1096 	}
       
  1097 	var _p1 *byte
       
  1098 	_p1, err = BytePtrFromString(attr)
       
  1099 	if err != nil {
       
  1100 		return
       
  1101 	}
       
  1102 	var _p2 unsafe.Pointer
       
  1103 	if len(data) > 0 {
       
  1104 		_p2 = unsafe.Pointer(&data[0])
       
  1105 	} else {
       
  1106 		_p2 = unsafe.Pointer(&_zero)
       
  1107 	}
       
  1108 	_, _, e1 := Syscall6(SYS_LSETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(data)), uintptr(flags), 0)
       
  1109 	if e1 != 0 {
       
  1110 		err = errnoErr(e1)
       
  1111 	}
       
  1112 	return
       
  1113 }
       
  1114 
       
  1115 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1116 
       
  1117 func MemfdCreate(name string, flags int) (fd int, err error) {
       
  1118 	var _p0 *byte
       
  1119 	_p0, err = BytePtrFromString(name)
       
  1120 	if err != nil {
       
  1121 		return
       
  1122 	}
       
  1123 	r0, _, e1 := Syscall(SYS_MEMFD_CREATE, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
       
  1124 	fd = int(r0)
       
  1125 	if e1 != 0 {
       
  1126 		err = errnoErr(e1)
       
  1127 	}
       
  1128 	return
       
  1129 }
       
  1130 
       
  1131 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1132 
       
  1133 func Mkdirat(dirfd int, path string, mode uint32) (err error) {
       
  1134 	var _p0 *byte
       
  1135 	_p0, err = BytePtrFromString(path)
       
  1136 	if err != nil {
       
  1137 		return
       
  1138 	}
       
  1139 	_, _, e1 := Syscall(SYS_MKDIRAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
       
  1140 	if e1 != 0 {
       
  1141 		err = errnoErr(e1)
       
  1142 	}
       
  1143 	return
       
  1144 }
       
  1145 
       
  1146 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1147 
       
  1148 func Mknodat(dirfd int, path string, mode uint32, dev int) (err error) {
       
  1149 	var _p0 *byte
       
  1150 	_p0, err = BytePtrFromString(path)
       
  1151 	if err != nil {
       
  1152 		return
       
  1153 	}
       
  1154 	_, _, e1 := Syscall6(SYS_MKNODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev), 0, 0)
       
  1155 	if e1 != 0 {
       
  1156 		err = errnoErr(e1)
       
  1157 	}
       
  1158 	return
       
  1159 }
       
  1160 
       
  1161 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1162 
       
  1163 func Nanosleep(time *Timespec, leftover *Timespec) (err error) {
       
  1164 	_, _, e1 := Syscall(SYS_NANOSLEEP, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
       
  1165 	if e1 != 0 {
       
  1166 		err = errnoErr(e1)
       
  1167 	}
       
  1168 	return
       
  1169 }
       
  1170 
       
  1171 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1172 
       
  1173 func PerfEventOpen(attr *PerfEventAttr, pid int, cpu int, groupFd int, flags int) (fd int, err error) {
       
  1174 	r0, _, e1 := Syscall6(SYS_PERF_EVENT_OPEN, uintptr(unsafe.Pointer(attr)), uintptr(pid), uintptr(cpu), uintptr(groupFd), uintptr(flags), 0)
       
  1175 	fd = int(r0)
       
  1176 	if e1 != 0 {
       
  1177 		err = errnoErr(e1)
       
  1178 	}
       
  1179 	return
       
  1180 }
       
  1181 
       
  1182 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1183 
       
  1184 func PivotRoot(newroot string, putold string) (err error) {
       
  1185 	var _p0 *byte
       
  1186 	_p0, err = BytePtrFromString(newroot)
       
  1187 	if err != nil {
       
  1188 		return
       
  1189 	}
       
  1190 	var _p1 *byte
       
  1191 	_p1, err = BytePtrFromString(putold)
       
  1192 	if err != nil {
       
  1193 		return
       
  1194 	}
       
  1195 	_, _, e1 := Syscall(SYS_PIVOT_ROOT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
       
  1196 	if e1 != 0 {
       
  1197 		err = errnoErr(e1)
       
  1198 	}
       
  1199 	return
       
  1200 }
       
  1201 
       
  1202 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1203 
       
  1204 func prlimit(pid int, resource int, newlimit *Rlimit, old *Rlimit) (err error) {
       
  1205 	_, _, e1 := RawSyscall6(SYS_PRLIMIT64, uintptr(pid), uintptr(resource), uintptr(unsafe.Pointer(newlimit)), uintptr(unsafe.Pointer(old)), 0, 0)
       
  1206 	if e1 != 0 {
       
  1207 		err = errnoErr(e1)
       
  1208 	}
       
  1209 	return
       
  1210 }
       
  1211 
       
  1212 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1213 
       
  1214 func Prctl(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (err error) {
       
  1215 	_, _, e1 := Syscall6(SYS_PRCTL, uintptr(option), uintptr(arg2), uintptr(arg3), uintptr(arg4), uintptr(arg5), 0)
       
  1216 	if e1 != 0 {
       
  1217 		err = errnoErr(e1)
       
  1218 	}
       
  1219 	return
       
  1220 }
       
  1221 
       
  1222 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1223 
       
  1224 func Pselect(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timespec, sigmask *Sigset_t) (n int, err error) {
       
  1225 	r0, _, e1 := Syscall6(SYS_PSELECT6, uintptr(nfd), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), uintptr(unsafe.Pointer(sigmask)))
       
  1226 	n = int(r0)
       
  1227 	if e1 != 0 {
       
  1228 		err = errnoErr(e1)
       
  1229 	}
       
  1230 	return
       
  1231 }
       
  1232 
       
  1233 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1234 
       
  1235 func read(fd int, p []byte) (n int, err error) {
       
  1236 	var _p0 unsafe.Pointer
       
  1237 	if len(p) > 0 {
       
  1238 		_p0 = unsafe.Pointer(&p[0])
       
  1239 	} else {
       
  1240 		_p0 = unsafe.Pointer(&_zero)
       
  1241 	}
       
  1242 	r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p)))
       
  1243 	n = int(r0)
       
  1244 	if e1 != 0 {
       
  1245 		err = errnoErr(e1)
       
  1246 	}
       
  1247 	return
       
  1248 }
       
  1249 
       
  1250 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1251 
       
  1252 func Removexattr(path string, attr string) (err error) {
       
  1253 	var _p0 *byte
       
  1254 	_p0, err = BytePtrFromString(path)
       
  1255 	if err != nil {
       
  1256 		return
       
  1257 	}
       
  1258 	var _p1 *byte
       
  1259 	_p1, err = BytePtrFromString(attr)
       
  1260 	if err != nil {
       
  1261 		return
       
  1262 	}
       
  1263 	_, _, e1 := Syscall(SYS_REMOVEXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
       
  1264 	if e1 != 0 {
       
  1265 		err = errnoErr(e1)
       
  1266 	}
       
  1267 	return
       
  1268 }
       
  1269 
       
  1270 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1271 
       
  1272 func Renameat2(olddirfd int, oldpath string, newdirfd int, newpath string, flags uint) (err error) {
       
  1273 	var _p0 *byte
       
  1274 	_p0, err = BytePtrFromString(oldpath)
       
  1275 	if err != nil {
       
  1276 		return
       
  1277 	}
       
  1278 	var _p1 *byte
       
  1279 	_p1, err = BytePtrFromString(newpath)
       
  1280 	if err != nil {
       
  1281 		return
       
  1282 	}
       
  1283 	_, _, e1 := Syscall6(SYS_RENAMEAT2, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
       
  1284 	if e1 != 0 {
       
  1285 		err = errnoErr(e1)
       
  1286 	}
       
  1287 	return
       
  1288 }
       
  1289 
       
  1290 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1291 
       
  1292 func RequestKey(keyType string, description string, callback string, destRingid int) (id int, err error) {
       
  1293 	var _p0 *byte
       
  1294 	_p0, err = BytePtrFromString(keyType)
       
  1295 	if err != nil {
       
  1296 		return
       
  1297 	}
       
  1298 	var _p1 *byte
       
  1299 	_p1, err = BytePtrFromString(description)
       
  1300 	if err != nil {
       
  1301 		return
       
  1302 	}
       
  1303 	var _p2 *byte
       
  1304 	_p2, err = BytePtrFromString(callback)
       
  1305 	if err != nil {
       
  1306 		return
       
  1307 	}
       
  1308 	r0, _, e1 := Syscall6(SYS_REQUEST_KEY, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(_p2)), uintptr(destRingid), 0, 0)
       
  1309 	id = int(r0)
       
  1310 	if e1 != 0 {
       
  1311 		err = errnoErr(e1)
       
  1312 	}
       
  1313 	return
       
  1314 }
       
  1315 
       
  1316 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1317 
       
  1318 func Setdomainname(p []byte) (err error) {
       
  1319 	var _p0 unsafe.Pointer
       
  1320 	if len(p) > 0 {
       
  1321 		_p0 = unsafe.Pointer(&p[0])
       
  1322 	} else {
       
  1323 		_p0 = unsafe.Pointer(&_zero)
       
  1324 	}
       
  1325 	_, _, e1 := Syscall(SYS_SETDOMAINNAME, uintptr(_p0), uintptr(len(p)), 0)
       
  1326 	if e1 != 0 {
       
  1327 		err = errnoErr(e1)
       
  1328 	}
       
  1329 	return
       
  1330 }
       
  1331 
       
  1332 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1333 
       
  1334 func Sethostname(p []byte) (err error) {
       
  1335 	var _p0 unsafe.Pointer
       
  1336 	if len(p) > 0 {
       
  1337 		_p0 = unsafe.Pointer(&p[0])
       
  1338 	} else {
       
  1339 		_p0 = unsafe.Pointer(&_zero)
       
  1340 	}
       
  1341 	_, _, e1 := Syscall(SYS_SETHOSTNAME, uintptr(_p0), uintptr(len(p)), 0)
       
  1342 	if e1 != 0 {
       
  1343 		err = errnoErr(e1)
       
  1344 	}
       
  1345 	return
       
  1346 }
       
  1347 
       
  1348 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1349 
       
  1350 func Setpgid(pid int, pgid int) (err error) {
       
  1351 	_, _, e1 := RawSyscall(SYS_SETPGID, uintptr(pid), uintptr(pgid), 0)
       
  1352 	if e1 != 0 {
       
  1353 		err = errnoErr(e1)
       
  1354 	}
       
  1355 	return
       
  1356 }
       
  1357 
       
  1358 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1359 
       
  1360 func Setsid() (pid int, err error) {
       
  1361 	r0, _, e1 := RawSyscall(SYS_SETSID, 0, 0, 0)
       
  1362 	pid = int(r0)
       
  1363 	if e1 != 0 {
       
  1364 		err = errnoErr(e1)
       
  1365 	}
       
  1366 	return
       
  1367 }
       
  1368 
       
  1369 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1370 
       
  1371 func Settimeofday(tv *Timeval) (err error) {
       
  1372 	_, _, e1 := RawSyscall(SYS_SETTIMEOFDAY, uintptr(unsafe.Pointer(tv)), 0, 0)
       
  1373 	if e1 != 0 {
       
  1374 		err = errnoErr(e1)
       
  1375 	}
       
  1376 	return
       
  1377 }
       
  1378 
       
  1379 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1380 
       
  1381 func Setns(fd int, nstype int) (err error) {
       
  1382 	_, _, e1 := Syscall(SYS_SETNS, uintptr(fd), uintptr(nstype), 0)
       
  1383 	if e1 != 0 {
       
  1384 		err = errnoErr(e1)
       
  1385 	}
       
  1386 	return
       
  1387 }
       
  1388 
       
  1389 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1390 
       
  1391 func Setpriority(which int, who int, prio int) (err error) {
       
  1392 	_, _, e1 := Syscall(SYS_SETPRIORITY, uintptr(which), uintptr(who), uintptr(prio))
       
  1393 	if e1 != 0 {
       
  1394 		err = errnoErr(e1)
       
  1395 	}
       
  1396 	return
       
  1397 }
       
  1398 
       
  1399 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1400 
       
  1401 func Setxattr(path string, attr string, data []byte, flags int) (err error) {
       
  1402 	var _p0 *byte
       
  1403 	_p0, err = BytePtrFromString(path)
       
  1404 	if err != nil {
       
  1405 		return
       
  1406 	}
       
  1407 	var _p1 *byte
       
  1408 	_p1, err = BytePtrFromString(attr)
       
  1409 	if err != nil {
       
  1410 		return
       
  1411 	}
       
  1412 	var _p2 unsafe.Pointer
       
  1413 	if len(data) > 0 {
       
  1414 		_p2 = unsafe.Pointer(&data[0])
       
  1415 	} else {
       
  1416 		_p2 = unsafe.Pointer(&_zero)
       
  1417 	}
       
  1418 	_, _, e1 := Syscall6(SYS_SETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(data)), uintptr(flags), 0)
       
  1419 	if e1 != 0 {
       
  1420 		err = errnoErr(e1)
       
  1421 	}
       
  1422 	return
       
  1423 }
       
  1424 
       
  1425 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1426 
       
  1427 func signalfd(fd int, sigmask *Sigset_t, maskSize uintptr, flags int) (newfd int, err error) {
       
  1428 	r0, _, e1 := Syscall6(SYS_SIGNALFD4, uintptr(fd), uintptr(unsafe.Pointer(sigmask)), uintptr(maskSize), uintptr(flags), 0, 0)
       
  1429 	newfd = int(r0)
       
  1430 	if e1 != 0 {
       
  1431 		err = errnoErr(e1)
       
  1432 	}
       
  1433 	return
       
  1434 }
       
  1435 
       
  1436 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1437 
       
  1438 func Statx(dirfd int, path string, flags int, mask int, stat *Statx_t) (err error) {
       
  1439 	var _p0 *byte
       
  1440 	_p0, err = BytePtrFromString(path)
       
  1441 	if err != nil {
       
  1442 		return
       
  1443 	}
       
  1444 	_, _, e1 := Syscall6(SYS_STATX, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(mask), uintptr(unsafe.Pointer(stat)), 0)
       
  1445 	if e1 != 0 {
       
  1446 		err = errnoErr(e1)
       
  1447 	}
       
  1448 	return
       
  1449 }
       
  1450 
       
  1451 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1452 
       
  1453 func Sync() {
       
  1454 	SyscallNoError(SYS_SYNC, 0, 0, 0)
       
  1455 	return
       
  1456 }
       
  1457 
       
  1458 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1459 
       
  1460 func Syncfs(fd int) (err error) {
       
  1461 	_, _, e1 := Syscall(SYS_SYNCFS, uintptr(fd), 0, 0)
       
  1462 	if e1 != 0 {
       
  1463 		err = errnoErr(e1)
       
  1464 	}
       
  1465 	return
       
  1466 }
       
  1467 
       
  1468 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1469 
       
  1470 func Sysinfo(info *Sysinfo_t) (err error) {
       
  1471 	_, _, e1 := RawSyscall(SYS_SYSINFO, uintptr(unsafe.Pointer(info)), 0, 0)
       
  1472 	if e1 != 0 {
       
  1473 		err = errnoErr(e1)
       
  1474 	}
       
  1475 	return
       
  1476 }
       
  1477 
       
  1478 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1479 
       
  1480 func TimerfdCreate(clockid int, flags int) (fd int, err error) {
       
  1481 	r0, _, e1 := RawSyscall(SYS_TIMERFD_CREATE, uintptr(clockid), uintptr(flags), 0)
       
  1482 	fd = int(r0)
       
  1483 	if e1 != 0 {
       
  1484 		err = errnoErr(e1)
       
  1485 	}
       
  1486 	return
       
  1487 }
       
  1488 
       
  1489 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1490 
       
  1491 func TimerfdGettime(fd int, currValue *ItimerSpec) (err error) {
       
  1492 	_, _, e1 := RawSyscall(SYS_TIMERFD_GETTIME, uintptr(fd), uintptr(unsafe.Pointer(currValue)), 0)
       
  1493 	if e1 != 0 {
       
  1494 		err = errnoErr(e1)
       
  1495 	}
       
  1496 	return
       
  1497 }
       
  1498 
       
  1499 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1500 
       
  1501 func TimerfdSettime(fd int, flags int, newValue *ItimerSpec, oldValue *ItimerSpec) (err error) {
       
  1502 	_, _, e1 := RawSyscall6(SYS_TIMERFD_SETTIME, uintptr(fd), uintptr(flags), uintptr(unsafe.Pointer(newValue)), uintptr(unsafe.Pointer(oldValue)), 0, 0)
       
  1503 	if e1 != 0 {
       
  1504 		err = errnoErr(e1)
       
  1505 	}
       
  1506 	return
       
  1507 }
       
  1508 
       
  1509 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1510 
       
  1511 func Tgkill(tgid int, tid int, sig syscall.Signal) (err error) {
       
  1512 	_, _, e1 := RawSyscall(SYS_TGKILL, uintptr(tgid), uintptr(tid), uintptr(sig))
       
  1513 	if e1 != 0 {
       
  1514 		err = errnoErr(e1)
       
  1515 	}
       
  1516 	return
       
  1517 }
       
  1518 
       
  1519 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1520 
       
  1521 func Times(tms *Tms) (ticks uintptr, err error) {
       
  1522 	r0, _, e1 := RawSyscall(SYS_TIMES, uintptr(unsafe.Pointer(tms)), 0, 0)
       
  1523 	ticks = uintptr(r0)
       
  1524 	if e1 != 0 {
       
  1525 		err = errnoErr(e1)
       
  1526 	}
       
  1527 	return
       
  1528 }
       
  1529 
       
  1530 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1531 
       
  1532 func Umask(mask int) (oldmask int) {
       
  1533 	r0, _ := RawSyscallNoError(SYS_UMASK, uintptr(mask), 0, 0)
       
  1534 	oldmask = int(r0)
       
  1535 	return
       
  1536 }
       
  1537 
       
  1538 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1539 
       
  1540 func Uname(buf *Utsname) (err error) {
       
  1541 	_, _, e1 := RawSyscall(SYS_UNAME, uintptr(unsafe.Pointer(buf)), 0, 0)
       
  1542 	if e1 != 0 {
       
  1543 		err = errnoErr(e1)
       
  1544 	}
       
  1545 	return
       
  1546 }
       
  1547 
       
  1548 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1549 
       
  1550 func Unmount(target string, flags int) (err error) {
       
  1551 	var _p0 *byte
       
  1552 	_p0, err = BytePtrFromString(target)
       
  1553 	if err != nil {
       
  1554 		return
       
  1555 	}
       
  1556 	_, _, e1 := Syscall(SYS_UMOUNT2, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
       
  1557 	if e1 != 0 {
       
  1558 		err = errnoErr(e1)
       
  1559 	}
       
  1560 	return
       
  1561 }
       
  1562 
       
  1563 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1564 
       
  1565 func Unshare(flags int) (err error) {
       
  1566 	_, _, e1 := Syscall(SYS_UNSHARE, uintptr(flags), 0, 0)
       
  1567 	if e1 != 0 {
       
  1568 		err = errnoErr(e1)
       
  1569 	}
       
  1570 	return
       
  1571 }
       
  1572 
       
  1573 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1574 
       
  1575 func write(fd int, p []byte) (n int, err error) {
       
  1576 	var _p0 unsafe.Pointer
       
  1577 	if len(p) > 0 {
       
  1578 		_p0 = unsafe.Pointer(&p[0])
       
  1579 	} else {
       
  1580 		_p0 = unsafe.Pointer(&_zero)
       
  1581 	}
       
  1582 	r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)))
       
  1583 	n = int(r0)
       
  1584 	if e1 != 0 {
       
  1585 		err = errnoErr(e1)
       
  1586 	}
       
  1587 	return
       
  1588 }
       
  1589 
       
  1590 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1591 
       
  1592 func exitThread(code int) (err error) {
       
  1593 	_, _, e1 := Syscall(SYS_EXIT, uintptr(code), 0, 0)
       
  1594 	if e1 != 0 {
       
  1595 		err = errnoErr(e1)
       
  1596 	}
       
  1597 	return
       
  1598 }
       
  1599 
       
  1600 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1601 
       
  1602 func readlen(fd int, p *byte, np int) (n int, err error) {
       
  1603 	r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(p)), uintptr(np))
       
  1604 	n = int(r0)
       
  1605 	if e1 != 0 {
       
  1606 		err = errnoErr(e1)
       
  1607 	}
       
  1608 	return
       
  1609 }
       
  1610 
       
  1611 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1612 
       
  1613 func writelen(fd int, p *byte, np int) (n int, err error) {
       
  1614 	r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(unsafe.Pointer(p)), uintptr(np))
       
  1615 	n = int(r0)
       
  1616 	if e1 != 0 {
       
  1617 		err = errnoErr(e1)
       
  1618 	}
       
  1619 	return
       
  1620 }
       
  1621 
       
  1622 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1623 
       
  1624 func readv(fd int, iovs []Iovec) (n int, err error) {
       
  1625 	var _p0 unsafe.Pointer
       
  1626 	if len(iovs) > 0 {
       
  1627 		_p0 = unsafe.Pointer(&iovs[0])
       
  1628 	} else {
       
  1629 		_p0 = unsafe.Pointer(&_zero)
       
  1630 	}
       
  1631 	r0, _, e1 := Syscall(SYS_READV, uintptr(fd), uintptr(_p0), uintptr(len(iovs)))
       
  1632 	n = int(r0)
       
  1633 	if e1 != 0 {
       
  1634 		err = errnoErr(e1)
       
  1635 	}
       
  1636 	return
       
  1637 }
       
  1638 
       
  1639 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1640 
       
  1641 func writev(fd int, iovs []Iovec) (n int, err error) {
       
  1642 	var _p0 unsafe.Pointer
       
  1643 	if len(iovs) > 0 {
       
  1644 		_p0 = unsafe.Pointer(&iovs[0])
       
  1645 	} else {
       
  1646 		_p0 = unsafe.Pointer(&_zero)
       
  1647 	}
       
  1648 	r0, _, e1 := Syscall(SYS_WRITEV, uintptr(fd), uintptr(_p0), uintptr(len(iovs)))
       
  1649 	n = int(r0)
       
  1650 	if e1 != 0 {
       
  1651 		err = errnoErr(e1)
       
  1652 	}
       
  1653 	return
       
  1654 }
       
  1655 
       
  1656 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1657 
       
  1658 func preadv(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr) (n int, err error) {
       
  1659 	var _p0 unsafe.Pointer
       
  1660 	if len(iovs) > 0 {
       
  1661 		_p0 = unsafe.Pointer(&iovs[0])
       
  1662 	} else {
       
  1663 		_p0 = unsafe.Pointer(&_zero)
       
  1664 	}
       
  1665 	r0, _, e1 := Syscall6(SYS_PREADV, uintptr(fd), uintptr(_p0), uintptr(len(iovs)), uintptr(offs_l), uintptr(offs_h), 0)
       
  1666 	n = int(r0)
       
  1667 	if e1 != 0 {
       
  1668 		err = errnoErr(e1)
       
  1669 	}
       
  1670 	return
       
  1671 }
       
  1672 
       
  1673 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1674 
       
  1675 func pwritev(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr) (n int, err error) {
       
  1676 	var _p0 unsafe.Pointer
       
  1677 	if len(iovs) > 0 {
       
  1678 		_p0 = unsafe.Pointer(&iovs[0])
       
  1679 	} else {
       
  1680 		_p0 = unsafe.Pointer(&_zero)
       
  1681 	}
       
  1682 	r0, _, e1 := Syscall6(SYS_PWRITEV, uintptr(fd), uintptr(_p0), uintptr(len(iovs)), uintptr(offs_l), uintptr(offs_h), 0)
       
  1683 	n = int(r0)
       
  1684 	if e1 != 0 {
       
  1685 		err = errnoErr(e1)
       
  1686 	}
       
  1687 	return
       
  1688 }
       
  1689 
       
  1690 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1691 
       
  1692 func preadv2(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr, flags int) (n int, err error) {
       
  1693 	var _p0 unsafe.Pointer
       
  1694 	if len(iovs) > 0 {
       
  1695 		_p0 = unsafe.Pointer(&iovs[0])
       
  1696 	} else {
       
  1697 		_p0 = unsafe.Pointer(&_zero)
       
  1698 	}
       
  1699 	r0, _, e1 := Syscall6(SYS_PREADV2, uintptr(fd), uintptr(_p0), uintptr(len(iovs)), uintptr(offs_l), uintptr(offs_h), uintptr(flags))
       
  1700 	n = int(r0)
       
  1701 	if e1 != 0 {
       
  1702 		err = errnoErr(e1)
       
  1703 	}
       
  1704 	return
       
  1705 }
       
  1706 
       
  1707 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1708 
       
  1709 func pwritev2(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr, flags int) (n int, err error) {
       
  1710 	var _p0 unsafe.Pointer
       
  1711 	if len(iovs) > 0 {
       
  1712 		_p0 = unsafe.Pointer(&iovs[0])
       
  1713 	} else {
       
  1714 		_p0 = unsafe.Pointer(&_zero)
       
  1715 	}
       
  1716 	r0, _, e1 := Syscall6(SYS_PWRITEV2, uintptr(fd), uintptr(_p0), uintptr(len(iovs)), uintptr(offs_l), uintptr(offs_h), uintptr(flags))
       
  1717 	n = int(r0)
       
  1718 	if e1 != 0 {
       
  1719 		err = errnoErr(e1)
       
  1720 	}
       
  1721 	return
       
  1722 }
       
  1723 
       
  1724 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1725 
       
  1726 func munmap(addr uintptr, length uintptr) (err error) {
       
  1727 	_, _, e1 := Syscall(SYS_MUNMAP, uintptr(addr), uintptr(length), 0)
       
  1728 	if e1 != 0 {
       
  1729 		err = errnoErr(e1)
       
  1730 	}
       
  1731 	return
       
  1732 }
       
  1733 
       
  1734 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1735 
       
  1736 func Madvise(b []byte, advice int) (err error) {
       
  1737 	var _p0 unsafe.Pointer
       
  1738 	if len(b) > 0 {
       
  1739 		_p0 = unsafe.Pointer(&b[0])
       
  1740 	} else {
       
  1741 		_p0 = unsafe.Pointer(&_zero)
       
  1742 	}
       
  1743 	_, _, e1 := Syscall(SYS_MADVISE, uintptr(_p0), uintptr(len(b)), uintptr(advice))
       
  1744 	if e1 != 0 {
       
  1745 		err = errnoErr(e1)
       
  1746 	}
       
  1747 	return
       
  1748 }
       
  1749 
       
  1750 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1751 
       
  1752 func Mprotect(b []byte, prot int) (err error) {
       
  1753 	var _p0 unsafe.Pointer
       
  1754 	if len(b) > 0 {
       
  1755 		_p0 = unsafe.Pointer(&b[0])
       
  1756 	} else {
       
  1757 		_p0 = unsafe.Pointer(&_zero)
       
  1758 	}
       
  1759 	_, _, e1 := Syscall(SYS_MPROTECT, uintptr(_p0), uintptr(len(b)), uintptr(prot))
       
  1760 	if e1 != 0 {
       
  1761 		err = errnoErr(e1)
       
  1762 	}
       
  1763 	return
       
  1764 }
       
  1765 
       
  1766 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1767 
       
  1768 func Mlock(b []byte) (err error) {
       
  1769 	var _p0 unsafe.Pointer
       
  1770 	if len(b) > 0 {
       
  1771 		_p0 = unsafe.Pointer(&b[0])
       
  1772 	} else {
       
  1773 		_p0 = unsafe.Pointer(&_zero)
       
  1774 	}
       
  1775 	_, _, e1 := Syscall(SYS_MLOCK, uintptr(_p0), uintptr(len(b)), 0)
       
  1776 	if e1 != 0 {
       
  1777 		err = errnoErr(e1)
       
  1778 	}
       
  1779 	return
       
  1780 }
       
  1781 
       
  1782 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1783 
       
  1784 func Mlockall(flags int) (err error) {
       
  1785 	_, _, e1 := Syscall(SYS_MLOCKALL, uintptr(flags), 0, 0)
       
  1786 	if e1 != 0 {
       
  1787 		err = errnoErr(e1)
       
  1788 	}
       
  1789 	return
       
  1790 }
       
  1791 
       
  1792 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1793 
       
  1794 func Msync(b []byte, flags int) (err error) {
       
  1795 	var _p0 unsafe.Pointer
       
  1796 	if len(b) > 0 {
       
  1797 		_p0 = unsafe.Pointer(&b[0])
       
  1798 	} else {
       
  1799 		_p0 = unsafe.Pointer(&_zero)
       
  1800 	}
       
  1801 	_, _, e1 := Syscall(SYS_MSYNC, uintptr(_p0), uintptr(len(b)), uintptr(flags))
       
  1802 	if e1 != 0 {
       
  1803 		err = errnoErr(e1)
       
  1804 	}
       
  1805 	return
       
  1806 }
       
  1807 
       
  1808 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1809 
       
  1810 func Munlock(b []byte) (err error) {
       
  1811 	var _p0 unsafe.Pointer
       
  1812 	if len(b) > 0 {
       
  1813 		_p0 = unsafe.Pointer(&b[0])
       
  1814 	} else {
       
  1815 		_p0 = unsafe.Pointer(&_zero)
       
  1816 	}
       
  1817 	_, _, e1 := Syscall(SYS_MUNLOCK, uintptr(_p0), uintptr(len(b)), 0)
       
  1818 	if e1 != 0 {
       
  1819 		err = errnoErr(e1)
       
  1820 	}
       
  1821 	return
       
  1822 }
       
  1823 
       
  1824 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1825 
       
  1826 func Munlockall() (err error) {
       
  1827 	_, _, e1 := Syscall(SYS_MUNLOCKALL, 0, 0, 0)
       
  1828 	if e1 != 0 {
       
  1829 		err = errnoErr(e1)
       
  1830 	}
       
  1831 	return
       
  1832 }
       
  1833 
       
  1834 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1835 
       
  1836 func faccessat(dirfd int, path string, mode uint32) (err error) {
       
  1837 	var _p0 *byte
       
  1838 	_p0, err = BytePtrFromString(path)
       
  1839 	if err != nil {
       
  1840 		return
       
  1841 	}
       
  1842 	_, _, e1 := Syscall(SYS_FACCESSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
       
  1843 	if e1 != 0 {
       
  1844 		err = errnoErr(e1)
       
  1845 	}
       
  1846 	return
       
  1847 }
       
  1848 
       
  1849 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1850 
       
  1851 func Faccessat2(dirfd int, path string, mode uint32, flags int) (err error) {
       
  1852 	var _p0 *byte
       
  1853 	_p0, err = BytePtrFromString(path)
       
  1854 	if err != nil {
       
  1855 		return
       
  1856 	}
       
  1857 	_, _, e1 := Syscall6(SYS_FACCESSAT2, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
       
  1858 	if e1 != 0 {
       
  1859 		err = errnoErr(e1)
       
  1860 	}
       
  1861 	return
       
  1862 }
       
  1863 
       
  1864 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1865 
       
  1866 func nameToHandleAt(dirFD int, pathname string, fh *fileHandle, mountID *_C_int, flags int) (err error) {
       
  1867 	var _p0 *byte
       
  1868 	_p0, err = BytePtrFromString(pathname)
       
  1869 	if err != nil {
       
  1870 		return
       
  1871 	}
       
  1872 	_, _, e1 := Syscall6(SYS_NAME_TO_HANDLE_AT, uintptr(dirFD), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(fh)), uintptr(unsafe.Pointer(mountID)), uintptr(flags), 0)
       
  1873 	if e1 != 0 {
       
  1874 		err = errnoErr(e1)
       
  1875 	}
       
  1876 	return
       
  1877 }
       
  1878 
       
  1879 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1880 
       
  1881 func openByHandleAt(mountFD int, fh *fileHandle, flags int) (fd int, err error) {
       
  1882 	r0, _, e1 := Syscall(SYS_OPEN_BY_HANDLE_AT, uintptr(mountFD), uintptr(unsafe.Pointer(fh)), uintptr(flags))
       
  1883 	fd = int(r0)
       
  1884 	if e1 != 0 {
       
  1885 		err = errnoErr(e1)
       
  1886 	}
       
  1887 	return
       
  1888 }
       
  1889 
       
  1890 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1891 
       
  1892 func ProcessVMReadv(pid int, localIov []Iovec, remoteIov []RemoteIovec, flags uint) (n int, err error) {
       
  1893 	var _p0 unsafe.Pointer
       
  1894 	if len(localIov) > 0 {
       
  1895 		_p0 = unsafe.Pointer(&localIov[0])
       
  1896 	} else {
       
  1897 		_p0 = unsafe.Pointer(&_zero)
       
  1898 	}
       
  1899 	var _p1 unsafe.Pointer
       
  1900 	if len(remoteIov) > 0 {
       
  1901 		_p1 = unsafe.Pointer(&remoteIov[0])
       
  1902 	} else {
       
  1903 		_p1 = unsafe.Pointer(&_zero)
       
  1904 	}
       
  1905 	r0, _, e1 := Syscall6(SYS_PROCESS_VM_READV, uintptr(pid), uintptr(_p0), uintptr(len(localIov)), uintptr(_p1), uintptr(len(remoteIov)), uintptr(flags))
       
  1906 	n = int(r0)
       
  1907 	if e1 != 0 {
       
  1908 		err = errnoErr(e1)
       
  1909 	}
       
  1910 	return
       
  1911 }
       
  1912 
       
  1913 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1914 
       
  1915 func ProcessVMWritev(pid int, localIov []Iovec, remoteIov []RemoteIovec, flags uint) (n int, err error) {
       
  1916 	var _p0 unsafe.Pointer
       
  1917 	if len(localIov) > 0 {
       
  1918 		_p0 = unsafe.Pointer(&localIov[0])
       
  1919 	} else {
       
  1920 		_p0 = unsafe.Pointer(&_zero)
       
  1921 	}
       
  1922 	var _p1 unsafe.Pointer
       
  1923 	if len(remoteIov) > 0 {
       
  1924 		_p1 = unsafe.Pointer(&remoteIov[0])
       
  1925 	} else {
       
  1926 		_p1 = unsafe.Pointer(&_zero)
       
  1927 	}
       
  1928 	r0, _, e1 := Syscall6(SYS_PROCESS_VM_WRITEV, uintptr(pid), uintptr(_p0), uintptr(len(localIov)), uintptr(_p1), uintptr(len(remoteIov)), uintptr(flags))
       
  1929 	n = int(r0)
       
  1930 	if e1 != 0 {
       
  1931 		err = errnoErr(e1)
       
  1932 	}
       
  1933 	return
       
  1934 }
       
  1935 
       
  1936 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
  1937 
       
  1938 func pipe2(p *[2]_C_int, flags int) (err error) {
       
  1939 	_, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
       
  1940 	if e1 != 0 {
       
  1941 		err = errnoErr(e1)
       
  1942 	}
       
  1943 	return
       
  1944 }