本文整理汇总了Golang中syscall.Seek函数的典型用法代码示例。如果您正苦于以下问题:Golang Seek函数的具体用法?Golang Seek怎么用?Golang Seek使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了Seek函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: coalesce
func coalesce(parentFile *os.File, childFile *os.File) error {
blockSize, err := getFileSystemBlockSize(childFile)
if err != nil {
panic("can't get FS block size, error: " + err.Error())
}
var data, hole int64
for {
data, err = syscall.Seek(int(childFile.Fd()), hole, seekData)
if err != nil {
// reaches EOF
errno := err.(syscall.Errno)
if errno == syscall.ENXIO {
break
} else {
// unexpected errors
log.Fatal("Failed to syscall.Seek SEEK_DATA")
return err
}
}
hole, err = syscall.Seek(int(childFile.Fd()), data, seekHole)
if err != nil {
log.Fatal("Failed to syscall.Seek SEEK_HOLE")
return err
}
// now we have a data start offset and length(hole - data)
// let's read from child and write to parent file block by block
_, err = parentFile.Seek(data, os.SEEK_SET)
if err != nil {
log.Fatal("Failed to os.Seek os.SEEK_SET")
return err
}
offset := data
buffer := fio.AllocateAligned(blockSize)
for offset != hole {
// read a block from child, maybe use bufio or Reader stream
n, err := fio.ReadAt(childFile, buffer, offset)
if n != len(buffer) || err != nil {
log.Fatal("Failed to read from childFile")
return err
}
// write a block to parent
n, err = fio.WriteAt(parentFile, buffer, offset)
if n != len(buffer) || err != nil {
log.Fatal("Failed to write to parentFile")
return err
}
offset += int64(n)
}
}
return nil
}
示例2: Lseek
func (k *PosixKernel) Lseek(fd co.Fd, offset co.Off, whence int) uint64 {
off, err := syscall.Seek(int(fd), int64(offset), whence)
if err != nil {
return Errno(err)
}
return uint64(off)
}
示例3: main
func main() {
flag.Var(&windowSize, "window-size", "Window size in Go `duration` format (default \"10m\")")
flag.IntVar(&maxRestarts, "max-restarts", 5, "Max `restarts` within window-size duration")
flag.StringVar(&metadataDir, "metadata-dir", "/run/runlimit", "Metadata `dir`, where metadata files are stored")
flag.StringVar(&metadataKey, "metadata-key", "", "Metadata key, which will form part of the metadata file name")
flag.StringVar(&svCmd, "sv-cmd", "", "Command to use to stop a service")
flag.Parse()
if windowSize == 0 || maxRestarts == 0 {
fatal("-max-restarts and/or -window-size cannot be 0")
}
cmdline := flag.Args()
if len(cmdline) < 1 {
fatal("No command supplied")
}
cwd, err := os.Getwd()
assert(err)
if metadataKey == "" {
metadataKey = nonalphanumeric.ReplaceAllString(cwd, "_")
}
metafile := filepath.Join(metadataDir, fmt.Sprintf("%s.meta", metadataKey))
f, err := os.OpenFile(metafile, os.O_RDWR|os.O_CREATE, os.FileMode(0644))
assert(err)
defer f.Close()
assert(syscall.Flock(int(f.Fd()), syscall.LOCK_NB|syscall.LOCK_EX))
metadata := &Metadata{}
if err := json.NewDecoder(f).Decode(metadata); err != nil && err != io.EOF {
warning("metadata corrupted, ignoring...")
}
if limit(metadata, time.Duration(windowSize), maxRestarts) {
signals := make(chan os.Signal)
signal.Notify(signals, syscall.SIGTERM)
if svCmd != "" {
parts, err := shlex.Split(svCmd, true)
assert(err)
go func() {
if out, err := exec.Command(parts[0], parts[1:]...).Output(); err != nil {
warning("command exited abnormally with output %s", string(out))
}
}()
select {
case <-signals:
break
case <-time.After(5 * time.Second):
warning("timed out while waiting for TERM from %s", parts[0])
}
}
fatal("max restart intensity reached")
}
assert(syscall.Ftruncate(int(f.Fd()), 0))
_, err = syscall.Seek(int(f.Fd()), 0, 0)
assert(err)
if err := json.NewEncoder(f).Encode(metadata); err != nil {
warning("could not write metadata: %s", err.Error())
}
assert(chainlib.Exec(cmdline, nil))
}
示例4: OpenFile
// OpenFile is the generalized open call; most users will use Open
// or Create instead. It opens the named file with specified flag
// (O_RDONLY etc.) and perm, (0666 etc.) if applicable. If successful,
// methods on the returned File can be used for I/O.
// If there is an error, it will be of type *PathError.
func OpenFile(name string, flag int, perm FileMode) (file *File, err error) {
if DisableWritesForAppEngine && flag&(O_WRONLY|O_RDWR|O_CREATE|O_EXCL) != 0 {
return nil, &PathError{"open", name, errDisabledWrites}
}
var (
fd int
e error
create bool
excl bool
trunc bool
append bool
)
if flag&O_CREATE == O_CREATE {
flag = flag & ^O_CREATE
create = true
}
if flag&O_EXCL == O_EXCL {
excl = true
}
if flag&O_TRUNC == O_TRUNC {
trunc = true
}
// O_APPEND is emulated on Plan 9
if flag&O_APPEND == O_APPEND {
flag = flag &^ O_APPEND
append = true
}
syscall.ForkLock.RLock()
if (create && trunc) || excl {
fd, e = syscall.Create(name, flag, syscallMode(perm))
} else {
fd, e = syscall.Open(name, flag)
if e != nil && create {
var e1 error
fd, e1 = syscall.Create(name, flag, syscallMode(perm))
if e1 == nil {
e = nil
}
}
}
syscall.ForkLock.RUnlock()
if e != nil {
return nil, &PathError{"open", name, e}
}
if append {
if _, e = syscall.Seek(fd, 0, SEEK_END); e != nil {
return nil, &PathError{"seek", name, e}
}
}
return NewFile(uintptr(fd), name), nil
}
示例5: pread
// pread reads len(b) bytes from the File starting at byte offset off.
// It returns the number of bytes read and the error, if any.
// EOF is signaled by a zero count with err set to 0.
func (f *File) pread(b []byte, off int64) (n int, err int) {
f.l.Lock()
defer f.l.Unlock()
curoffset, e := syscall.Seek(f.fd, 0, 1)
if e != 0 {
return 0, e
}
defer syscall.Seek(f.fd, curoffset, 0)
o := syscall.Overlapped{
OffsetHigh: uint32(off >> 32),
Offset: uint32(off),
}
var done uint32
e = syscall.ReadFile(int32(f.fd), b, &done, &o)
if e != 0 {
return 0, e
}
return int(done), 0
}
示例6: pwrite
// pwrite writes len(b) bytes to the File starting at byte offset off.
// It returns the number of bytes written and an error, if any.
func (f *File) pwrite(b []byte, off int64) (n int, err error) {
f.l.Lock()
defer f.l.Unlock()
curoffset, e := syscall.Seek(f.fd, 0, 1)
if e != nil {
return 0, e
}
defer syscall.Seek(f.fd, curoffset, 0)
o := syscall.Overlapped{
OffsetHigh: uint32(off >> 32),
Offset: uint32(off),
}
var done uint32
e = syscall.WriteFile(syscall.Handle(f.fd), b, &done, &o)
if e != nil {
return 0, e
}
return int(done), nil
}
示例7: Seek
// Seek sets the offset for the next Read or Write on file to offset, interpreted
// according to whence: 0 means relative to the origin of the file, 1 means
// relative to the current offset, and 2 means relative to the end.
// It returns the new offset and an Error, if any.
func (file *File) Seek(offset int64, whence int) (ret int64, err Error) {
r, e := syscall.Seek(file.fd, offset, whence)
if e == 0 && file.dirinfo != nil && r != 0 {
e = syscall.EISDIR
}
if e != 0 {
return 0, &PathError{"seek", file.name, Errno(e)}
}
return r, nil
}
示例8: Seek
func (file *File) Seek(offset int64, whence int) (ret int, err os.Error) {
if file == nil {
return -1, os.EINVAL
}
fmt.Printf("file.Seek(%d,%d)\n", offset, whence)
r, e := syscall.Seek(file.fd, offset, whence)
if e != 0 {
err = os.Errno(e)
}
return int(r), err
}
示例9: TestSeekFailure
func TestSeekFailure(t *testing.T) {
_, err := syscall.Seek(-1, 0, 0)
if err == nil {
t.Fatalf("Seek(-1, 0, 0) did not fail")
}
str := err.Error() // used to crash on Linux
t.Logf("Seek: %v", str)
if str == "" {
t.Fatalf("Seek(-1, 0, 0) return error with empty message")
}
}
示例10: OpenFile
// OpenFile is the generalized open call; most users will use Open
// or Create instead. It opens the named file with specified flag
// (O_RDONLY etc.) and perm, (0666 etc.) if applicable. If successful,
// methods on the returned File can be used for I/O.
// It returns the File and an error, if any.
func OpenFile(name string, flag int, perm uint32) (file *File, err error) {
var (
fd int
e syscall.Error
create bool
excl bool
trunc bool
append bool
)
if flag&O_CREATE == O_CREATE {
flag = flag & ^O_CREATE
create = true
}
if flag&O_EXCL == O_EXCL {
excl = true
}
if flag&O_TRUNC == O_TRUNC {
trunc = true
}
// O_APPEND is emulated on Plan 9
if flag&O_APPEND == O_APPEND {
flag = flag &^ O_APPEND
append = true
}
syscall.ForkLock.RLock()
if (create && trunc) || excl {
fd, e = syscall.Create(name, flag, perm)
} else {
fd, e = syscall.Open(name, flag)
if e != nil && create {
var e1 syscall.Error
fd, e1 = syscall.Create(name, flag, perm)
if e1 == nil {
e = nil
}
}
}
syscall.ForkLock.RUnlock()
if e != nil {
return nil, &PathError{"open", name, e}
}
if append {
if _, e = syscall.Seek(fd, 0, SEEK_END); e != nil {
return nil, &PathError{"seek", name, e}
}
}
return NewFile(fd, name), nil
}
示例11: WriteBlock
func (dio *DiskIO) WriteBlock(blockaddr uint64, buffer []byte) (uint, error) {
var noff int64 = int64(blockaddr) * int64(dio.BlockSize)
_, err := syscall.Seek(dio.fileDescriptor, noff, 0)
if err != nil {
return 0, err
}
num, err := syscall.Write(dio.fileDescriptor, buffer)
if err != nil {
return 0, err
}
return uint(num), nil
}
示例12: OpenFile
// OpenFile is the generalized open call; most users will use Open
// or Create instead. It opens the named file with specified flag
// (O_RDONLY etc.) and perm, (0666 etc.) if applicable. If successful,
// methods on the returned File can be used for I/O.
// If there is an error, it will be of type *PathError.
func OpenFile(name string, flag int, perm FileMode) (*File, error) {
var (
fd int
e error
create bool
excl bool
trunc bool
append bool
)
if flag&O_CREATE == O_CREATE {
flag = flag & ^O_CREATE
create = true
}
if flag&O_EXCL == O_EXCL {
excl = true
}
if flag&O_TRUNC == O_TRUNC {
trunc = true
}
// O_APPEND is emulated on Plan 9
if flag&O_APPEND == O_APPEND {
flag = flag &^ O_APPEND
append = true
}
if (create && trunc) || excl {
fd, e = syscall.Create(name, flag, syscallMode(perm))
} else {
fd, e = syscall.Open(name, flag)
if e != nil && create {
var e1 error
fd, e1 = syscall.Create(name, flag, syscallMode(perm))
if e1 == nil {
e = nil
}
}
}
if e != nil {
return nil, &PathError{"open", name, e}
}
if append {
if _, e = syscall.Seek(fd, 0, io.SeekEnd); e != nil {
return nil, &PathError{"seek", name, e}
}
}
return NewFile(uintptr(fd), name), nil
}
示例13: pread
// pread reads len(b) bytes from the File starting at byte offset off.
// It returns the number of bytes read and the error, if any.
// EOF is signaled by a zero count with err set to 0.
func (f *File) pread(b []byte, off int64) (n int, err error) {
f.l.Lock()
defer f.l.Unlock()
curoffset, e := syscall.Seek(f.fd, 0, 1)
if e != nil {
return 0, e
}
defer syscall.Seek(f.fd, curoffset, 0)
o := syscall.Overlapped{
OffsetHigh: uint32(off >> 32),
Offset: uint32(off),
}
var done uint32
e = syscall.ReadFile(syscall.Handle(f.fd), b, &done, &o)
if e != nil {
if e == syscall.ERROR_HANDLE_EOF {
// end of file
return 0, nil
}
return 0, e
}
return int(done), nil
}
示例14: HashData
func (_entity *Entity) HashData(_hasher1 hasher.Hasher) (_hash []byte, _error Error) {
if !_entity.IsRegular() {
return nil, newError("dup", _entity.Path, -1, syscall.EBADF)
}
var _descriptor, _errno int
_descriptor = _entity.Descriptor
if _descriptor < 0 {
return nil, newError("dup", _entity.Path, _entity.Descriptor, syscall.EBADF)
}
_descriptor, _errno = syscall.Dup(_descriptor)
if _errno != 0 {
return nil, newError("dup", _entity.Path, _entity.Descriptor, _errno)
}
defer syscall.Close(_descriptor)
_, _errno = syscall.Seek(_descriptor, 0, 0 /* syscall.SEEK_SET */)
if _errno != 0 {
return nil, newError("seek", _entity.Path, _descriptor, _errno)
}
_hasher := _hasher1.Create()
_buffer := make([]byte, _bufferSize)
for {
var _limit int
_limit, _errno = syscall.Read(_descriptor, _buffer)
if _errno != 0 {
return nil, newError("read", _entity.Path, _descriptor, _errno)
}
if _limit == 0 {
break
}
_error = hasher.HashUpdate(_hasher, _buffer[:_limit])
if _error != nil {
return nil, newError("hash", _entity.Path, _descriptor, syscall.EIO)
}
}
_hash, _error = hasher.HashFinalize(_hasher)
if _error != nil {
return nil, newError("hash", _entity.Path, _descriptor, syscall.EIO)
}
if _entity.Hashes == nil {
_entity.Hashes = make(map[string][]byte, 1)
}
_entity.Hashes[_hasher1.Identifier()] = _hash
return _hash, nil
}
示例15: Wait
func (g *GPIO) Wait() (bool, error) {
if g.fd == 0 {
fd, err := syscall.Open(g.valuePath, syscall.O_RDONLY, 0666)
if err != nil {
return false, err
}
g.fd = fd
g.fdSet = new(syscall.FdSet)
FD_SET(g.fd, g.fdSet)
g.buf = make([]byte, 64)
syscall.Read(g.fd, g.buf)
}
syscall.Select(g.fd+1, nil, nil, g.fdSet, nil)
syscall.Seek(g.fd, 0, 0)
_, err := syscall.Read(g.fd, g.buf)
if err != nil {
return false, err
}
return string(g.buf[:2]) == "1\n", nil
}