// Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build unix || (js && wasm) || wasip1 package os import ( "internal/poll" "internal/syscall/unix" "io/fs" "runtime" "syscall" _ "unsafe" // for go:linkname ) const _UTIME_OMIT = unix.UTIME_OMIT // fixLongPath is a noop on non-Windows platforms. func fixLongPath(path string) string { return path } func rename(oldname, newname string) error { fi, err := Lstat(newname) if err == nil && fi.IsDir() { // There are two independent errors this function can return: // one for a bad oldname, and one for a bad newname. // At this point we've determined the newname is bad. // But just in case oldname is also bad, prioritize returning // the oldname error because that's what we did historically. // However, if the old name and new name are not the same, yet // they refer to the same file, it implies a case-only // rename on a case-insensitive filesystem, which is ok. if ofi, err := Lstat(oldname); err != nil { if pe, ok := err.(*PathError); ok { err = pe.Err } return &LinkError{"rename", oldname, newname, err} } else if newname == oldname || !SameFile(fi, ofi) { return &LinkError{"rename", oldname, newname, syscall.EEXIST} } } err = ignoringEINTR(func() error { return syscall.Rename(oldname, newname) }) if err != nil { return &LinkError{"rename", oldname, newname, err} } return nil } // file is the real representation of *File. // The extra level of indirection ensures that no clients of os // can overwrite this data, which could cause the finalizer // to close the wrong file descriptor. type file struct { pfd poll.FD name string dirinfo *dirInfo // nil unless directory being read nonblock bool // whether we set nonblocking mode stdoutOrErr bool // whether this is stdout or stderr appendMode bool // whether file is opened for appending } // Fd returns the integer Unix file descriptor referencing the open file. // If f is closed, the file descriptor becomes invalid. // If f is garbage collected, a finalizer may close the file descriptor, // making it invalid; see runtime.SetFinalizer for more information on when // a finalizer might be run. On Unix systems this will cause the SetDeadline // methods to stop working. // Because file descriptors can be reused, the returned file descriptor may // only be closed through the Close method of f, or by its finalizer during // garbage collection. Otherwise, during garbage collection the finalizer // may close an unrelated file descriptor with the same (reused) number. // // As an alternative, see the f.SyscallConn method. func (f *File) Fd() uintptr { if f == nil { return ^(uintptr(0)) } // If we put the file descriptor into nonblocking mode, // then set it to blocking mode before we return it, // because historically we have always returned a descriptor // opened in blocking mode. The File will continue to work, // but any blocking operation will tie up a thread. if f.nonblock { f.pfd.SetBlocking() } return uintptr(f.pfd.Sysfd) } // NewFile returns a new File with the given file descriptor and // name. The returned value will be nil if fd is not a valid file // descriptor. On Unix systems, if the file descriptor is in // non-blocking mode, NewFile will attempt to return a pollable File // (one for which the SetDeadline methods work). // // After passing it to NewFile, fd may become invalid under the same // conditions described in the comments of the Fd method, and the same // constraints apply. func NewFile(fd uintptr, name string) *File { fdi := int(fd) if fdi < 0 { return nil } kind := kindNewFile appendMode := false if flags, err := unix.Fcntl(fdi, syscall.F_GETFL, 0); err == nil { if unix.HasNonblockFlag(flags) { kind = kindNonBlock } appendMode = flags&syscall.O_APPEND != 0 } f := newFile(fdi, name, kind) f.appendMode = appendMode return f } // net_newUnixFile is a hidden entry point called by net.conn.File. // This is used so that a nonblocking network connection will become // blocking if code calls the Fd method. We don't want that for direct // calls to NewFile: passing a nonblocking descriptor to NewFile should // remain nonblocking if you get it back using Fd. But for net.conn.File // the call to NewFile is hidden from the user. Historically in that case // the Fd method has returned a blocking descriptor, and we want to // retain that behavior because existing code expects it and depends on it. // //go:linkname net_newUnixFile net.newUnixFile func net_newUnixFile(fd int, name string) *File { if fd < 0 { panic("invalid FD") } f := newFile(fd, name, kindNonBlock) f.nonblock = true // tell Fd to return blocking descriptor return f } // newFileKind describes the kind of file to newFile. type newFileKind int const ( // kindNewFile means that the descriptor was passed to us via NewFile. kindNewFile newFileKind = iota // kindOpenFile means that the descriptor was opened using // Open, Create, or OpenFile (without O_NONBLOCK). kindOpenFile // kindPipe means that the descriptor was opened using Pipe. kindPipe // kindNonBlock means that the descriptor is already in // non-blocking mode. kindNonBlock // kindNoPoll means that we should not put the descriptor into // non-blocking mode, because we know it is not a pipe or FIFO. // Used by openFdAt for directories. kindNoPoll ) // newFile is like NewFile, but if called from OpenFile or Pipe // (as passed in the kind parameter) it tries to add the file to // the runtime poller. func newFile(fd int, name string, kind newFileKind) *File { f := &File{&file{ pfd: poll.FD{ Sysfd: fd, IsStream: true, ZeroReadIsEOF: true, }, name: name, stdoutOrErr: fd == 1 || fd == 2, }} pollable := kind == kindOpenFile || kind == kindPipe || kind == kindNonBlock // If the caller passed a non-blocking filedes (kindNonBlock), // we assume they know what they are doing so we allow it to be // used with kqueue. if kind == kindOpenFile { switch runtime.GOOS { case "darwin", "ios", "dragonfly", "freebsd", "netbsd", "openbsd": var st syscall.Stat_t err := ignoringEINTR(func() error { return syscall.Fstat(fd, &st) }) typ := st.Mode & syscall.S_IFMT // Don't try to use kqueue with regular files on *BSDs. // On FreeBSD a regular file is always // reported as ready for writing. // On Dragonfly, NetBSD and OpenBSD the fd is signaled // only once as ready (both read and write). // Issue 19093. // Also don't add directories to the netpoller. if err == nil && (typ == syscall.S_IFREG || typ == syscall.S_IFDIR) { pollable = false } // In addition to the behavior described above for regular files, // on Darwin, kqueue does not work properly with fifos: // closing the last writer does not cause a kqueue event // for any readers. See issue #24164. if (runtime.GOOS == "darwin" || runtime.GOOS == "ios") && typ == syscall.S_IFIFO { pollable = false } } } clearNonBlock := false if pollable { if kind == kindNonBlock { // The descriptor is already in non-blocking mode. // We only set f.nonblock if we put the file into // non-blocking mode. } else if err := syscall.SetNonblock(fd, true); err == nil { f.nonblock = true clearNonBlock = true } else { pollable = false } } // An error here indicates a failure to register // with the netpoll system. That can happen for // a file descriptor that is not supported by // epoll/kqueue; for example, disk files on // Linux systems. We assume that any real error // will show up in later I/O. // We do restore the blocking behavior if it was set by us. if pollErr := f.pfd.Init("file", pollable); pollErr != nil && clearNonBlock { if err := syscall.SetNonblock(fd, false); err == nil { f.nonblock = false } } runtime.SetFinalizer(f.file, (*file).close) return f } func sigpipe() // implemented in package runtime // epipecheck raises SIGPIPE if we get an EPIPE error on standard // output or standard error. See the SIGPIPE docs in os/signal, and // issue 11845. func epipecheck(file *File, e error) { if e == syscall.EPIPE && file.stdoutOrErr { sigpipe() } } // DevNull is the name of the operating system's “null device.” // On Unix-like systems, it is "/dev/null"; on Windows, "NUL". const DevNull = "/dev/null" // openFileNolog is the Unix implementation of OpenFile. // Changes here should be reflected in openFdAt, if relevant. func openFileNolog(name string, flag int, perm FileMode) (*File, error) { setSticky := false if !supportsCreateWithStickyBit && flag&O_CREATE != 0 && perm&ModeSticky != 0 { if _, err := Stat(name); IsNotExist(err) { setSticky = true } } var r int var s poll.SysFile for { var e error r, s, e = open(name, flag|syscall.O_CLOEXEC, syscallMode(perm)) if e == nil { break } // We have to check EINTR here, per issues 11180 and 39237. if e == syscall.EINTR { continue } return nil, &PathError{Op: "open", Path: name, Err: e} } // open(2) itself won't handle the sticky bit on *BSD and Solaris if setSticky { setStickyBit(name) } // There's a race here with fork/exec, which we are // content to live with. See ../syscall/exec_unix.go. if !supportsCloseOnExec { syscall.CloseOnExec(r) } kind := kindOpenFile if unix.HasNonblockFlag(flag) { kind = kindNonBlock } f := newFile(r, name, kind) f.pfd.SysFile = s return f, nil } func (file *file) close() error { if file == nil { return syscall.EINVAL } if file.dirinfo != nil { file.dirinfo.close() file.dirinfo = nil } var err error if e := file.pfd.Close(); e != nil { if e == poll.ErrFileClosing { e = ErrClosed } err = &PathError{Op: "close", Path: file.name, Err: e} } // no need for a finalizer anymore runtime.SetFinalizer(file, nil) return err } // 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 (f *File) seek(offset int64, whence int) (ret int64, err error) { if f.dirinfo != nil { // Free cached dirinfo, so we allocate a new one if we // access this file as a directory again. See #35767 and #37161. f.dirinfo.close() f.dirinfo = nil } ret, err = f.pfd.Seek(offset, whence) runtime.KeepAlive(f) return ret, err } // Truncate changes the size of the named file. // If the file is a symbolic link, it changes the size of the link's target. // If there is an error, it will be of type *PathError. func Truncate(name string, size int64) error { e := ignoringEINTR(func() error { return syscall.Truncate(name, size) }) if e != nil { return &PathError{Op: "truncate", Path: name, Err: e} } return nil } // Remove removes the named file or (empty) directory. // If there is an error, it will be of type *PathError. func Remove(name string) error { // System call interface forces us to know // whether name is a file or directory. // Try both: it is cheaper on average than // doing a Stat plus the right one. e := ignoringEINTR(func() error { return syscall.Unlink(name) }) if e == nil { return nil } e1 := ignoringEINTR(func() error { return syscall.Rmdir(name) }) if e1 == nil { return nil } // Both failed: figure out which error to return. // OS X and Linux differ on whether unlink(dir) // returns EISDIR, so can't use that. However, // both agree that rmdir(file) returns ENOTDIR, // so we can use that to decide which error is real. // Rmdir might also return ENOTDIR if given a bad // file path, like /etc/passwd/foo, but in that case, // both errors will be ENOTDIR, so it's okay to // use the error from unlink. if e1 != syscall.ENOTDIR { e = e1 } return &PathError{Op: "remove", Path: name, Err: e} } func tempDir() string { dir := Getenv("TMPDIR") if dir == "" { if runtime.GOOS == "android" { dir = "/data/local/tmp" } else { dir = "/tmp" } } return dir } // Link creates newname as a hard link to the oldname file. // If there is an error, it will be of type *LinkError. func Link(oldname, newname string) error { e := ignoringEINTR(func() error { return syscall.Link(oldname, newname) }) if e != nil { return &LinkError{"link", oldname, newname, e} } return nil } // Symlink creates newname as a symbolic link to oldname. // On Windows, a symlink to a non-existent oldname creates a file symlink; // if oldname is later created as a directory the symlink will not work. // If there is an error, it will be of type *LinkError. func Symlink(oldname, newname string) error { e := ignoringEINTR(func() error { return syscall.Symlink(oldname, newname) }) if e != nil { return &LinkError{"symlink", oldname, newname, e} } return nil } func readlink(name string) (string, error) { for len := 128; ; len *= 2 { b := make([]byte, len) var ( n int e error ) for { n, e = fixCount(syscall.Readlink(name, b)) if e != syscall.EINTR { break } } // buffer too small if (runtime.GOOS == "aix" || runtime.GOOS == "wasip1") && e == syscall.ERANGE { continue } if e != nil { return "", &PathError{Op: "readlink", Path: name, Err: e} } if n < len { return string(b[0:n]), nil } } } type unixDirent struct { parent string name string typ FileMode info FileInfo } func (d *unixDirent) Name() string { return d.name } func (d *unixDirent) IsDir() bool { return d.typ.IsDir() } func (d *unixDirent) Type() FileMode { return d.typ } func (d *unixDirent) Info() (FileInfo, error) { if d.info != nil { return d.info, nil } return lstat(d.parent + "/" + d.name) } func (d *unixDirent) String() string { return fs.FormatDirEntry(d) } func newUnixDirent(parent, name string, typ FileMode) (DirEntry, error) { ude := &unixDirent{ parent: parent, name: name, typ: typ, } if typ != ^FileMode(0) && !testingForceReadDirLstat { return ude, nil } info, err := lstat(parent + "/" + name) if err != nil { return nil, err } ude.typ = info.Mode().Type() ude.info = info return ude, nil }