Source file src/os/file_posix.go

Documentation: os

     1  // Copyright 2009 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // +build aix darwin dragonfly freebsd js,wasm linux nacl netbsd openbsd solaris windows
     6  
     7  package os
     8  
     9  import (
    10  	"syscall"
    11  	"time"
    12  )
    13  
    14  func sigpipe() // implemented in package runtime
    15  
    16  // syscallMode returns the syscall-specific mode bits from Go's portable mode bits.
    17  func syscallMode(i FileMode) (o uint32) {
    18  	o |= uint32(i.Perm())
    19  	if i&ModeSetuid != 0 {
    20  		o |= syscall.S_ISUID
    21  	}
    22  	if i&ModeSetgid != 0 {
    23  		o |= syscall.S_ISGID
    24  	}
    25  	if i&ModeSticky != 0 {
    26  		o |= syscall.S_ISVTX
    27  	}
    28  	// No mapping for Go's ModeTemporary (plan9 only).
    29  	return
    30  }
    31  
    32  // See docs in file.go:Chmod.
    33  func chmod(name string, mode FileMode) error {
    34  	if e := syscall.Chmod(fixLongPath(name), syscallMode(mode)); e != nil {
    35  		return &PathError{"chmod", name, e}
    36  	}
    37  	return nil
    38  }
    39  
    40  // See docs in file.go:(*File).Chmod.
    41  func (f *File) chmod(mode FileMode) error {
    42  	if err := f.checkValid("chmod"); err != nil {
    43  		return err
    44  	}
    45  	if e := f.pfd.Fchmod(syscallMode(mode)); e != nil {
    46  		return f.wrapErr("chmod", e)
    47  	}
    48  	return nil
    49  }
    50  
    51  // Chown changes the numeric uid and gid of the named file.
    52  // If the file is a symbolic link, it changes the uid and gid of the link's target.
    53  // A uid or gid of -1 means to not change that value.
    54  // If there is an error, it will be of type *PathError.
    55  //
    56  // On Windows or Plan 9, Chown always returns the syscall.EWINDOWS or
    57  // EPLAN9 error, wrapped in *PathError.
    58  func Chown(name string, uid, gid int) error {
    59  	if e := syscall.Chown(name, uid, gid); e != nil {
    60  		return &PathError{"chown", name, e}
    61  	}
    62  	return nil
    63  }
    64  
    65  // Lchown changes the numeric uid and gid of the named file.
    66  // If the file is a symbolic link, it changes the uid and gid of the link itself.
    67  // If there is an error, it will be of type *PathError.
    68  //
    69  // On Windows, it always returns the syscall.EWINDOWS error, wrapped
    70  // in *PathError.
    71  func Lchown(name string, uid, gid int) error {
    72  	if e := syscall.Lchown(name, uid, gid); e != nil {
    73  		return &PathError{"lchown", name, e}
    74  	}
    75  	return nil
    76  }
    77  
    78  // Chown changes the numeric uid and gid of the named file.
    79  // If there is an error, it will be of type *PathError.
    80  //
    81  // On Windows, it always returns the syscall.EWINDOWS error, wrapped
    82  // in *PathError.
    83  func (f *File) Chown(uid, gid int) error {
    84  	if err := f.checkValid("chown"); err != nil {
    85  		return err
    86  	}
    87  	if e := f.pfd.Fchown(uid, gid); e != nil {
    88  		return f.wrapErr("chown", e)
    89  	}
    90  	return nil
    91  }
    92  
    93  // Truncate changes the size of the file.
    94  // It does not change the I/O offset.
    95  // If there is an error, it will be of type *PathError.
    96  func (f *File) Truncate(size int64) error {
    97  	if err := f.checkValid("truncate"); err != nil {
    98  		return err
    99  	}
   100  	if e := f.pfd.Ftruncate(size); e != nil {
   101  		return f.wrapErr("truncate", e)
   102  	}
   103  	return nil
   104  }
   105  
   106  // Sync commits the current contents of the file to stable storage.
   107  // Typically, this means flushing the file system's in-memory copy
   108  // of recently written data to disk.
   109  func (f *File) Sync() error {
   110  	if err := f.checkValid("sync"); err != nil {
   111  		return err
   112  	}
   113  	if e := f.pfd.Fsync(); e != nil {
   114  		return f.wrapErr("sync", e)
   115  	}
   116  	return nil
   117  }
   118  
   119  // Chtimes changes the access and modification times of the named
   120  // file, similar to the Unix utime() or utimes() functions.
   121  //
   122  // The underlying filesystem may truncate or round the values to a
   123  // less precise time unit.
   124  // If there is an error, it will be of type *PathError.
   125  func Chtimes(name string, atime time.Time, mtime time.Time) error {
   126  	var utimes [2]syscall.Timespec
   127  	utimes[0] = syscall.NsecToTimespec(atime.UnixNano())
   128  	utimes[1] = syscall.NsecToTimespec(mtime.UnixNano())
   129  	if e := syscall.UtimesNano(fixLongPath(name), utimes[0:]); e != nil {
   130  		return &PathError{"chtimes", name, e}
   131  	}
   132  	return nil
   133  }
   134  
   135  // Chdir changes the current working directory to the file,
   136  // which must be a directory.
   137  // If there is an error, it will be of type *PathError.
   138  func (f *File) Chdir() error {
   139  	if err := f.checkValid("chdir"); err != nil {
   140  		return err
   141  	}
   142  	if e := f.pfd.Fchdir(); e != nil {
   143  		return f.wrapErr("chdir", e)
   144  	}
   145  	return nil
   146  }
   147  
   148  // setDeadline sets the read and write deadline.
   149  func (f *File) setDeadline(t time.Time) error {
   150  	if err := f.checkValid("SetDeadline"); err != nil {
   151  		return err
   152  	}
   153  	return f.pfd.SetDeadline(t)
   154  }
   155  
   156  // setReadDeadline sets the read deadline.
   157  func (f *File) setReadDeadline(t time.Time) error {
   158  	if err := f.checkValid("SetReadDeadline"); err != nil {
   159  		return err
   160  	}
   161  	return f.pfd.SetReadDeadline(t)
   162  }
   163  
   164  // setWriteDeadline sets the write deadline.
   165  func (f *File) setWriteDeadline(t time.Time) error {
   166  	if err := f.checkValid("SetWriteDeadline"); err != nil {
   167  		return err
   168  	}
   169  	return f.pfd.SetWriteDeadline(t)
   170  }
   171  
   172  // checkValid checks whether f is valid for use.
   173  // If not, it returns an appropriate error, perhaps incorporating the operation name op.
   174  func (f *File) checkValid(op string) error {
   175  	if f == nil {
   176  		return ErrInvalid
   177  	}
   178  	return nil
   179  }
   180  

View as plain text