github.com/remobjects/goldbaselibrary@v0.0.0-20230924164425-d458680a936b/Source/Gold/os/file_unix.go (about) 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 6 7 package os 8 9 import ( 10 "internal/poll" 11 "internal/syscall/unix" 12 "io" 13 "runtime" 14 "syscall" 15 ) 16 17 // fixLongPath is a noop on non-Windows platforms. 18 func fixLongPath(path string) string { 19 return path 20 } 21 22 func rename(oldname, newname string) error { 23 fi, err := Lstat(newname) 24 if err == nil && fi.IsDir() { 25 // There are two independent errors this function can return: 26 // one for a bad oldname, and one for a bad newname. 27 // At this point we've determined the newname is bad. 28 // But just in case oldname is also bad, prioritize returning 29 // the oldname error because that's what we did historically. 30 if _, err := Lstat(oldname); err != nil { 31 if pe, ok := err.(*PathError); ok { 32 err = pe.Err 33 } 34 return &LinkError{"rename", oldname, newname, err} 35 } 36 return &LinkError{"rename", oldname, newname, syscall.EEXIST} 37 } 38 err = syscall.Rename(oldname, newname) 39 if err != nil { 40 return &LinkError{"rename", oldname, newname, err} 41 } 42 return nil 43 } 44 45 // file is the real representation of *File. 46 // The extra level of indirection ensures that no clients of os 47 // can overwrite this data, which could cause the finalizer 48 // to close the wrong file descriptor. 49 type file struct { 50 pfd poll.FD 51 name string 52 dirinfo *dirInfo // nil unless directory being read 53 nonblock bool // whether we set nonblocking mode 54 stdoutOrErr bool // whether this is stdout or stderr 55 appendMode bool // whether file is opened for appending 56 } 57 58 // Fd returns the integer Unix file descriptor referencing the open file. 59 // The file descriptor is valid only until f.Close is called or f is garbage collected. 60 // On Unix systems this will cause the SetDeadline methods to stop working. 61 func (f *File) Fd() uintptr { 62 if f == nil { 63 return ^(uintptr(0)) 64 } 65 66 // If we put the file descriptor into nonblocking mode, 67 // then set it to blocking mode before we return it, 68 // because historically we have always returned a descriptor 69 // opened in blocking mode. The File will continue to work, 70 // but any blocking operation will tie up a thread. 71 if f.nonblock { 72 f.pfd.SetBlocking() 73 } 74 75 return uintptr(f.pfd.Sysfd) 76 } 77 78 // NewFile returns a new File with the given file descriptor and 79 // name. The returned value will be nil if fd is not a valid file 80 // descriptor. On Unix systems, if the file descriptor is in 81 // non-blocking mode, NewFile will attempt to return a pollable File 82 // (one for which the SetDeadline methods work). 83 func NewFile(fd uintptr, name string) *File { 84 kind := kindNewFile 85 if nb, err := unix.IsNonblock(int(fd)); err == nil && nb { 86 kind = kindNonBlock 87 } 88 return newFile(fd, name, kind) 89 } 90 91 // newFileKind describes the kind of file to newFile. 92 type newFileKind int 93 94 const ( 95 kindNewFile newFileKind = iota 96 kindOpenFile 97 kindPipe 98 kindNonBlock 99 ) 100 101 // newFile is like NewFile, but if called from OpenFile or Pipe 102 // (as passed in the kind parameter) it tries to add the file to 103 // the runtime poller. 104 func newFile(fd uintptr, name string, kind newFileKind) *File { 105 fdi := int(fd) 106 if fdi < 0 { 107 return nil 108 } 109 f := &File{&file{ 110 pfd: poll.FD{ 111 Sysfd: fdi, 112 IsStream: true, 113 ZeroReadIsEOF: true, 114 }, 115 name: name, 116 stdoutOrErr: fdi == 1 || fdi == 2, 117 }} 118 119 pollable := kind == kindOpenFile || kind == kindPipe || kind == kindNonBlock 120 121 // If the caller passed a non-blocking filedes (kindNonBlock), 122 // we assume they know what they are doing so we allow it to be 123 // used with kqueue. 124 if kind == kindOpenFile { 125 switch runtime.GOOS { 126 case "darwin", "dragonfly", "freebsd", "netbsd", "openbsd": 127 var st syscall.Stat_t 128 err := syscall.Fstat(fdi, &st) 129 typ := st.Mode & syscall.S_IFMT 130 // Don't try to use kqueue with regular files on *BSDs. 131 // On FreeBSD a regular file is always 132 // reported as ready for writing. 133 // On Dragonfly, NetBSD and OpenBSD the fd is signaled 134 // only once as ready (both read and write). 135 // Issue 19093. 136 // Also don't add directories to the netpoller. 137 if err == nil && (typ == syscall.S_IFREG || typ == syscall.S_IFDIR) { 138 pollable = false 139 } 140 141 // In addition to the behavior described above for regular files, 142 // on Darwin, kqueue does not work properly with fifos: 143 // closing the last writer does not cause a kqueue event 144 // for any readers. See issue #24164. 145 if runtime.GOOS == "darwin" && typ == syscall.S_IFIFO { 146 pollable = false 147 } 148 } 149 } 150 151 if err := f.pfd.Init("file", pollable); err != nil { 152 // An error here indicates a failure to register 153 // with the netpoll system. That can happen for 154 // a file descriptor that is not supported by 155 // epoll/kqueue; for example, disk files on 156 // GNU/Linux systems. We assume that any real error 157 // will show up in later I/O. 158 } else if pollable { 159 // We successfully registered with netpoll, so put 160 // the file into nonblocking mode. 161 if err := syscall.SetNonblock(fdi, true); err == nil { 162 f.nonblock = true 163 } 164 } 165 166 runtime.SetFinalizer(f.file, (*file).close) 167 return f 168 } 169 170 // epipecheck raises SIGPIPE if we get an EPIPE error on standard 171 // output or standard error. See the SIGPIPE docs in os/signal, and 172 // issue 11845. 173 func epipecheck(file *File, e error) { 174 if e == syscall.EPIPE && file.stdoutOrErr { 175 sigpipe() 176 } 177 } 178 179 // DevNull is the name of the operating system's ``null device.'' 180 // On Unix-like systems, it is "/dev/null"; on Windows, "NUL". 181 const DevNull = "/dev/null" 182 183 // openFileNolog is the Unix implementation of OpenFile. 184 // Changes here should be reflected in openFdAt, if relevant. 185 func openFileNolog(name string, flag int, perm FileMode) (*File, error) { 186 setSticky := false 187 if !supportsCreateWithStickyBit && flag&O_CREATE != 0 && perm&ModeSticky != 0 { 188 if _, err := Stat(name); IsNotExist(err) { 189 setSticky = true 190 } 191 } 192 193 var r int 194 for { 195 var e error 196 r, e = syscall.Open(name, flag|syscall.O_CLOEXEC, syscallMode(perm)) 197 if e == nil { 198 break 199 } 200 201 // On OS X, sigaction(2) doesn't guarantee that SA_RESTART will cause 202 // open(2) to be restarted for regular files. This is easy to reproduce on 203 // fuse file systems (see https://golang.org/issue/11180). 204 if runtime.GOOS == "darwin" && e == syscall.EINTR { 205 continue 206 } 207 208 return nil, &PathError{"open", name, e} 209 } 210 211 // open(2) itself won't handle the sticky bit on *BSD and Solaris 212 if setSticky { 213 setStickyBit(name) 214 } 215 216 // There's a race here with fork/exec, which we are 217 // content to live with. See ../syscall/exec_unix.go. 218 if !supportsCloseOnExec { 219 syscall.CloseOnExec(r) 220 } 221 222 return newFile(uintptr(r), name, kindOpenFile), nil 223 } 224 225 // Close closes the File, rendering it unusable for I/O. 226 // On files that support SetDeadline, any pending I/O operations will 227 // be canceled and return immediately with an error. 228 // Close will return an error if it has already been called. 229 func (f *File) Close() error { 230 if f == nil { 231 return ErrInvalid 232 } 233 return f.file.close() 234 } 235 236 func (file *file) close() error { 237 if file == nil { 238 return syscall.EINVAL 239 } 240 if file.dirinfo != nil { 241 file.dirinfo.close() 242 } 243 var err error 244 if e := file.pfd.Close(); e != nil { 245 if e == poll.ErrFileClosing { 246 e = ErrClosed 247 } 248 err = &PathError{"close", file.name, e} 249 } 250 251 // no need for a finalizer anymore 252 runtime.SetFinalizer(file, nil) 253 return err 254 } 255 256 // read reads up to len(b) bytes from the File. 257 // It returns the number of bytes read and an error, if any. 258 func (f *File) read(b []byte) (n int, err error) { 259 n, err = f.pfd.Read(b) 260 runtime.KeepAlive(f) 261 return n, err 262 } 263 264 // pread reads len(b) bytes from the File starting at byte offset off. 265 // It returns the number of bytes read and the error, if any. 266 // EOF is signaled by a zero count with err set to nil. 267 func (f *File) pread(b []byte, off int64) (n int, err error) { 268 n, err = f.pfd.Pread(b, off) 269 runtime.KeepAlive(f) 270 return n, err 271 } 272 273 // write writes len(b) bytes to the File. 274 // It returns the number of bytes written and an error, if any. 275 func (f *File) write(b []byte) (n int, err error) { 276 n, err = f.pfd.Write(b) 277 runtime.KeepAlive(f) 278 return n, err 279 } 280 281 // pwrite writes len(b) bytes to the File starting at byte offset off. 282 // It returns the number of bytes written and an error, if any. 283 func (f *File) pwrite(b []byte, off int64) (n int, err error) { 284 n, err = f.pfd.Pwrite(b, off) 285 runtime.KeepAlive(f) 286 return n, err 287 } 288 289 // seek sets the offset for the next Read or Write on file to offset, interpreted 290 // according to whence: 0 means relative to the origin of the file, 1 means 291 // relative to the current offset, and 2 means relative to the end. 292 // It returns the new offset and an error, if any. 293 func (f *File) seek(offset int64, whence int) (ret int64, err error) { 294 ret, err = f.pfd.Seek(offset, whence) 295 runtime.KeepAlive(f) 296 return ret, err 297 } 298 299 // Truncate changes the size of the named file. 300 // If the file is a symbolic link, it changes the size of the link's target. 301 // If there is an error, it will be of type *PathError. 302 func Truncate(name string, size int64) error { 303 if e := syscall.Truncate(name, size); e != nil { 304 return &PathError{"truncate", name, e} 305 } 306 return nil 307 } 308 309 // Remove removes the named file or (empty) directory. 310 // If there is an error, it will be of type *PathError. 311 func Remove(name string) error { 312 // System call interface forces us to know 313 // whether name is a file or directory. 314 // Try both: it is cheaper on average than 315 // doing a Stat plus the right one. 316 e := syscall.Unlink(name) 317 if e == nil { 318 return nil 319 } 320 e1 := syscall.Rmdir(name) 321 if e1 == nil { 322 return nil 323 } 324 325 // Both failed: figure out which error to return. 326 // OS X and Linux differ on whether unlink(dir) 327 // returns EISDIR, so can't use that. However, 328 // both agree that rmdir(file) returns ENOTDIR, 329 // so we can use that to decide which error is real. 330 // Rmdir might also return ENOTDIR if given a bad 331 // file path, like /etc/passwd/foo, but in that case, 332 // both errors will be ENOTDIR, so it's okay to 333 // use the error from unlink. 334 if e1 != syscall.ENOTDIR { 335 e = e1 336 } 337 return &PathError{"remove", name, e} 338 } 339 340 func tempDir() string { 341 dir := Getenv("TMPDIR") 342 if dir == "" { 343 if runtime.GOOS == "android" { 344 dir = "/data/local/tmp" 345 } else { 346 dir = "/tmp" 347 } 348 } 349 return dir 350 } 351 352 // Link creates newname as a hard link to the oldname file. 353 // If there is an error, it will be of type *LinkError. 354 func Link(oldname, newname string) error { 355 e := syscall.Link(oldname, newname) 356 if e != nil { 357 return &LinkError{"link", oldname, newname, e} 358 } 359 return nil 360 } 361 362 // Symlink creates newname as a symbolic link to oldname. 363 // If there is an error, it will be of type *LinkError. 364 func Symlink(oldname, newname string) error { 365 e := syscall.Symlink(oldname, newname) 366 if e != nil { 367 return &LinkError{"symlink", oldname, newname, e} 368 } 369 return nil 370 } 371 372 func (f *File) readdir(n int) (fi []FileInfo, err error) { 373 dirname := f.name 374 if dirname == "" { 375 dirname = "." 376 } 377 names, err := f.Readdirnames(n) 378 fi = make([]FileInfo, 0, len(names)) 379 for _, filename := range names { 380 fip, lerr := lstat(dirname + "/" + filename) 381 if IsNotExist(lerr) { 382 // File disappeared between readdir + stat. 383 // Just treat it as if it didn't exist. 384 continue 385 } 386 if lerr != nil { 387 return fi, lerr 388 } 389 fi = append(fi, fip) 390 } 391 if len(fi) == 0 && err == nil && n > 0 { 392 // Per File.Readdir, the slice must be non-empty or err 393 // must be non-nil if n > 0. 394 err = io.EOF 395 } 396 return fi, err 397 } 398 399 // Readlink returns the destination of the named symbolic link. 400 // If there is an error, it will be of type *PathError. 401 func Readlink(name string) (string, error) { 402 for len := 128; ; len *= 2 { 403 b := make([]byte, len) 404 n, e := fixCount(syscall.Readlink(name, b)) 405 // buffer too small 406 if runtime.GOOS == "aix" && e == syscall.ERANGE { 407 continue 408 } 409 if e != nil { 410 return "", &PathError{"readlink", name, e} 411 } 412 if n < len { 413 return string(b[0:n]), nil 414 } 415 } 416 }