vendor/golang.org/x/sys/unix/zsyscall_dragonfly_amd64.go
changeset 256 6d9efbef00a9
parent 251 1c52a0eeb952
child 265 05c40b36d3b2
equal deleted inserted replaced
255:4f153a23adab 256:6d9efbef00a9
     1 // go run mksyscall.go -dragonfly -tags dragonfly,amd64 syscall_bsd.go syscall_dragonfly.go syscall_dragonfly_amd64.go
     1 // go run mksyscall.go -dragonfly -tags dragonfly,amd64 syscall_bsd.go syscall_dragonfly.go syscall_dragonfly_amd64.go
     2 // Code generated by the command above; see README.md. DO NOT EDIT.
     2 // Code generated by the command above; see README.md. DO NOT EDIT.
     3 
     3 
       
     4 //go:build dragonfly && amd64
     4 // +build dragonfly,amd64
     5 // +build dragonfly,amd64
     5 
     6 
     6 package unix
     7 package unix
     7 
     8 
     8 import (
     9 import (
   212 	return
   213 	return
   213 }
   214 }
   214 
   215 
   215 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
   216 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
   216 
   217 
       
   218 func utimes(path string, timeval *[2]Timeval) (err error) {
       
   219 	var _p0 *byte
       
   220 	_p0, err = BytePtrFromString(path)
       
   221 	if err != nil {
       
   222 		return
       
   223 	}
       
   224 	_, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
       
   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 futimes(fd int, timeval *[2]Timeval) (err error) {
       
   234 	_, _, e1 := Syscall(SYS_FUTIMES, uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
       
   235 	if e1 != 0 {
       
   236 		err = errnoErr(e1)
       
   237 	}
       
   238 	return
       
   239 }
       
   240 
       
   241 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   242 
       
   243 func poll(fds *PollFd, nfds int, timeout int) (n int, err error) {
       
   244 	r0, _, e1 := Syscall(SYS_POLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout))
       
   245 	n = int(r0)
       
   246 	if e1 != 0 {
       
   247 		err = errnoErr(e1)
       
   248 	}
       
   249 	return
       
   250 }
       
   251 
       
   252 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   253 
       
   254 func Madvise(b []byte, behav int) (err error) {
       
   255 	var _p0 unsafe.Pointer
       
   256 	if len(b) > 0 {
       
   257 		_p0 = unsafe.Pointer(&b[0])
       
   258 	} else {
       
   259 		_p0 = unsafe.Pointer(&_zero)
       
   260 	}
       
   261 	_, _, e1 := Syscall(SYS_MADVISE, uintptr(_p0), uintptr(len(b)), uintptr(behav))
       
   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 Mlock(b []byte) (err error) {
       
   271 	var _p0 unsafe.Pointer
       
   272 	if len(b) > 0 {
       
   273 		_p0 = unsafe.Pointer(&b[0])
       
   274 	} else {
       
   275 		_p0 = unsafe.Pointer(&_zero)
       
   276 	}
       
   277 	_, _, e1 := Syscall(SYS_MLOCK, uintptr(_p0), uintptr(len(b)), 0)
       
   278 	if e1 != 0 {
       
   279 		err = errnoErr(e1)
       
   280 	}
       
   281 	return
       
   282 }
       
   283 
       
   284 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   285 
       
   286 func Mlockall(flags int) (err error) {
       
   287 	_, _, e1 := Syscall(SYS_MLOCKALL, uintptr(flags), 0, 0)
       
   288 	if e1 != 0 {
       
   289 		err = errnoErr(e1)
       
   290 	}
       
   291 	return
       
   292 }
       
   293 
       
   294 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   295 
       
   296 func Mprotect(b []byte, prot int) (err error) {
       
   297 	var _p0 unsafe.Pointer
       
   298 	if len(b) > 0 {
       
   299 		_p0 = unsafe.Pointer(&b[0])
       
   300 	} else {
       
   301 		_p0 = unsafe.Pointer(&_zero)
       
   302 	}
       
   303 	_, _, e1 := Syscall(SYS_MPROTECT, uintptr(_p0), uintptr(len(b)), uintptr(prot))
       
   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 Msync(b []byte, flags int) (err error) {
       
   313 	var _p0 unsafe.Pointer
       
   314 	if len(b) > 0 {
       
   315 		_p0 = unsafe.Pointer(&b[0])
       
   316 	} else {
       
   317 		_p0 = unsafe.Pointer(&_zero)
       
   318 	}
       
   319 	_, _, e1 := Syscall(SYS_MSYNC, uintptr(_p0), uintptr(len(b)), uintptr(flags))
       
   320 	if e1 != 0 {
       
   321 		err = errnoErr(e1)
       
   322 	}
       
   323 	return
       
   324 }
       
   325 
       
   326 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   327 
       
   328 func Munlock(b []byte) (err error) {
       
   329 	var _p0 unsafe.Pointer
       
   330 	if len(b) > 0 {
       
   331 		_p0 = unsafe.Pointer(&b[0])
       
   332 	} else {
       
   333 		_p0 = unsafe.Pointer(&_zero)
       
   334 	}
       
   335 	_, _, e1 := Syscall(SYS_MUNLOCK, uintptr(_p0), uintptr(len(b)), 0)
       
   336 	if e1 != 0 {
       
   337 		err = errnoErr(e1)
       
   338 	}
       
   339 	return
       
   340 }
       
   341 
       
   342 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   343 
       
   344 func Munlockall() (err error) {
       
   345 	_, _, e1 := Syscall(SYS_MUNLOCKALL, 0, 0, 0)
       
   346 	if e1 != 0 {
       
   347 		err = errnoErr(e1)
       
   348 	}
       
   349 	return
       
   350 }
       
   351 
       
   352 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   353 
       
   354 func pipe() (r int, w int, err error) {
       
   355 	r0, r1, e1 := RawSyscall(SYS_PIPE, 0, 0, 0)
       
   356 	r = int(r0)
       
   357 	w = int(r1)
       
   358 	if e1 != 0 {
       
   359 		err = errnoErr(e1)
       
   360 	}
       
   361 	return
       
   362 }
       
   363 
       
   364 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   365 
       
   366 func pipe2(p *[2]_C_int, flags int) (r int, w int, err error) {
       
   367 	r0, r1, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
       
   368 	r = int(r0)
       
   369 	w = int(r1)
       
   370 	if e1 != 0 {
       
   371 		err = errnoErr(e1)
       
   372 	}
       
   373 	return
       
   374 }
       
   375 
       
   376 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   377 
       
   378 func extpread(fd int, p []byte, flags int, offset int64) (n int, err error) {
       
   379 	var _p0 unsafe.Pointer
       
   380 	if len(p) > 0 {
       
   381 		_p0 = unsafe.Pointer(&p[0])
       
   382 	} else {
       
   383 		_p0 = unsafe.Pointer(&_zero)
       
   384 	}
       
   385 	r0, _, e1 := Syscall6(SYS_EXTPREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(offset), 0)
       
   386 	n = int(r0)
       
   387 	if e1 != 0 {
       
   388 		err = errnoErr(e1)
       
   389 	}
       
   390 	return
       
   391 }
       
   392 
       
   393 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   394 
       
   395 func extpwrite(fd int, p []byte, flags int, offset int64) (n int, err error) {
       
   396 	var _p0 unsafe.Pointer
       
   397 	if len(p) > 0 {
       
   398 		_p0 = unsafe.Pointer(&p[0])
       
   399 	} else {
       
   400 		_p0 = unsafe.Pointer(&_zero)
       
   401 	}
       
   402 	r0, _, e1 := Syscall6(SYS_EXTPWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(offset), 0)
       
   403 	n = int(r0)
       
   404 	if e1 != 0 {
       
   405 		err = errnoErr(e1)
       
   406 	}
       
   407 	return
       
   408 }
       
   409 
       
   410 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   411 
       
   412 func Getcwd(buf []byte) (n int, err error) {
       
   413 	var _p0 unsafe.Pointer
       
   414 	if len(buf) > 0 {
       
   415 		_p0 = unsafe.Pointer(&buf[0])
       
   416 	} else {
       
   417 		_p0 = unsafe.Pointer(&_zero)
       
   418 	}
       
   419 	r0, _, e1 := Syscall(SYS___GETCWD, uintptr(_p0), uintptr(len(buf)), 0)
       
   420 	n = int(r0)
       
   421 	if e1 != 0 {
       
   422 		err = errnoErr(e1)
       
   423 	}
       
   424 	return
       
   425 }
       
   426 
       
   427 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   428 
       
   429 func ioctl(fd int, req uint, arg uintptr) (err error) {
       
   430 	_, _, e1 := Syscall(SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(arg))
       
   431 	if e1 != 0 {
       
   432 		err = errnoErr(e1)
       
   433 	}
       
   434 	return
       
   435 }
       
   436 
       
   437 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   438 
   217 func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) {
   439 func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) {
   218 	var _p0 unsafe.Pointer
   440 	var _p0 unsafe.Pointer
   219 	if len(mib) > 0 {
   441 	if len(mib) > 0 {
   220 		_p0 = unsafe.Pointer(&mib[0])
   442 		_p0 = unsafe.Pointer(&mib[0])
   221 	} else {
   443 	} else {
   228 	return
   450 	return
   229 }
   451 }
   230 
   452 
   231 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
   453 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
   232 
   454 
   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 	if e1 != 0 {
       
   241 		err = errnoErr(e1)
       
   242 	}
       
   243 	return
       
   244 }
       
   245 
       
   246 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   247 
       
   248 func futimes(fd int, timeval *[2]Timeval) (err error) {
       
   249 	_, _, e1 := Syscall(SYS_FUTIMES, uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
       
   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 poll(fds *PollFd, nfds int, timeout int) (n int, err error) {
       
   259 	r0, _, e1 := Syscall(SYS_POLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout))
       
   260 	n = int(r0)
       
   261 	if e1 != 0 {
       
   262 		err = errnoErr(e1)
       
   263 	}
       
   264 	return
       
   265 }
       
   266 
       
   267 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   268 
       
   269 func Madvise(b []byte, behav int) (err error) {
       
   270 	var _p0 unsafe.Pointer
       
   271 	if len(b) > 0 {
       
   272 		_p0 = unsafe.Pointer(&b[0])
       
   273 	} else {
       
   274 		_p0 = unsafe.Pointer(&_zero)
       
   275 	}
       
   276 	_, _, e1 := Syscall(SYS_MADVISE, uintptr(_p0), uintptr(len(b)), uintptr(behav))
       
   277 	if e1 != 0 {
       
   278 		err = errnoErr(e1)
       
   279 	}
       
   280 	return
       
   281 }
       
   282 
       
   283 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   284 
       
   285 func Mlock(b []byte) (err error) {
       
   286 	var _p0 unsafe.Pointer
       
   287 	if len(b) > 0 {
       
   288 		_p0 = unsafe.Pointer(&b[0])
       
   289 	} else {
       
   290 		_p0 = unsafe.Pointer(&_zero)
       
   291 	}
       
   292 	_, _, e1 := Syscall(SYS_MLOCK, uintptr(_p0), uintptr(len(b)), 0)
       
   293 	if e1 != 0 {
       
   294 		err = errnoErr(e1)
       
   295 	}
       
   296 	return
       
   297 }
       
   298 
       
   299 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   300 
       
   301 func Mlockall(flags int) (err error) {
       
   302 	_, _, e1 := Syscall(SYS_MLOCKALL, uintptr(flags), 0, 0)
       
   303 	if e1 != 0 {
       
   304 		err = errnoErr(e1)
       
   305 	}
       
   306 	return
       
   307 }
       
   308 
       
   309 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   310 
       
   311 func Mprotect(b []byte, prot int) (err error) {
       
   312 	var _p0 unsafe.Pointer
       
   313 	if len(b) > 0 {
       
   314 		_p0 = unsafe.Pointer(&b[0])
       
   315 	} else {
       
   316 		_p0 = unsafe.Pointer(&_zero)
       
   317 	}
       
   318 	_, _, e1 := Syscall(SYS_MPROTECT, uintptr(_p0), uintptr(len(b)), uintptr(prot))
       
   319 	if e1 != 0 {
       
   320 		err = errnoErr(e1)
       
   321 	}
       
   322 	return
       
   323 }
       
   324 
       
   325 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   326 
       
   327 func Msync(b []byte, flags int) (err error) {
       
   328 	var _p0 unsafe.Pointer
       
   329 	if len(b) > 0 {
       
   330 		_p0 = unsafe.Pointer(&b[0])
       
   331 	} else {
       
   332 		_p0 = unsafe.Pointer(&_zero)
       
   333 	}
       
   334 	_, _, e1 := Syscall(SYS_MSYNC, uintptr(_p0), uintptr(len(b)), uintptr(flags))
       
   335 	if e1 != 0 {
       
   336 		err = errnoErr(e1)
       
   337 	}
       
   338 	return
       
   339 }
       
   340 
       
   341 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   342 
       
   343 func Munlock(b []byte) (err error) {
       
   344 	var _p0 unsafe.Pointer
       
   345 	if len(b) > 0 {
       
   346 		_p0 = unsafe.Pointer(&b[0])
       
   347 	} else {
       
   348 		_p0 = unsafe.Pointer(&_zero)
       
   349 	}
       
   350 	_, _, e1 := Syscall(SYS_MUNLOCK, uintptr(_p0), uintptr(len(b)), 0)
       
   351 	if e1 != 0 {
       
   352 		err = errnoErr(e1)
       
   353 	}
       
   354 	return
       
   355 }
       
   356 
       
   357 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   358 
       
   359 func Munlockall() (err error) {
       
   360 	_, _, e1 := Syscall(SYS_MUNLOCKALL, 0, 0, 0)
       
   361 	if e1 != 0 {
       
   362 		err = errnoErr(e1)
       
   363 	}
       
   364 	return
       
   365 }
       
   366 
       
   367 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   368 
       
   369 func pipe() (r int, w int, err error) {
       
   370 	r0, r1, e1 := RawSyscall(SYS_PIPE, 0, 0, 0)
       
   371 	r = int(r0)
       
   372 	w = int(r1)
       
   373 	if e1 != 0 {
       
   374 		err = errnoErr(e1)
       
   375 	}
       
   376 	return
       
   377 }
       
   378 
       
   379 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   380 
       
   381 func extpread(fd int, p []byte, flags int, offset int64) (n int, err error) {
       
   382 	var _p0 unsafe.Pointer
       
   383 	if len(p) > 0 {
       
   384 		_p0 = unsafe.Pointer(&p[0])
       
   385 	} else {
       
   386 		_p0 = unsafe.Pointer(&_zero)
       
   387 	}
       
   388 	r0, _, e1 := Syscall6(SYS_EXTPREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(offset), 0)
       
   389 	n = int(r0)
       
   390 	if e1 != 0 {
       
   391 		err = errnoErr(e1)
       
   392 	}
       
   393 	return
       
   394 }
       
   395 
       
   396 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   397 
       
   398 func extpwrite(fd int, p []byte, flags int, offset int64) (n int, err error) {
       
   399 	var _p0 unsafe.Pointer
       
   400 	if len(p) > 0 {
       
   401 		_p0 = unsafe.Pointer(&p[0])
       
   402 	} else {
       
   403 		_p0 = unsafe.Pointer(&_zero)
       
   404 	}
       
   405 	r0, _, e1 := Syscall6(SYS_EXTPWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(offset), 0)
       
   406 	n = int(r0)
       
   407 	if e1 != 0 {
       
   408 		err = errnoErr(e1)
       
   409 	}
       
   410 	return
       
   411 }
       
   412 
       
   413 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   414 
       
   415 func Getcwd(buf []byte) (n int, err error) {
       
   416 	var _p0 unsafe.Pointer
       
   417 	if len(buf) > 0 {
       
   418 		_p0 = unsafe.Pointer(&buf[0])
       
   419 	} else {
       
   420 		_p0 = unsafe.Pointer(&_zero)
       
   421 	}
       
   422 	r0, _, e1 := Syscall(SYS___GETCWD, uintptr(_p0), uintptr(len(buf)), 0)
       
   423 	n = int(r0)
       
   424 	if e1 != 0 {
       
   425 		err = errnoErr(e1)
       
   426 	}
       
   427 	return
       
   428 }
       
   429 
       
   430 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   431 
       
   432 func ioctl(fd int, req uint, arg uintptr) (err error) {
       
   433 	_, _, e1 := Syscall(SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(arg))
       
   434 	if e1 != 0 {
       
   435 		err = errnoErr(e1)
       
   436 	}
       
   437 	return
       
   438 }
       
   439 
       
   440 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
       
   441 
       
   442 func Access(path string, mode uint32) (err error) {
   455 func Access(path string, mode uint32) (err error) {
   443 	var _p0 *byte
   456 	var _p0 *byte
   444 	_p0, err = BytePtrFromString(path)
   457 	_p0, err = BytePtrFromString(path)
   445 	if err != nil {
   458 	if err != nil {
   446 		return
   459 		return