Source file src/pkg/os/file_unix.go
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 darwin freebsd linux netbsd openbsd 6 7 package os 8 9 import ( 10 "runtime" 11 "syscall" 12 ) 13 14 // File represents an open file descriptor. 15 type File struct { 16 *file 17 } 18 19 // file is the real representation of *File. 20 // The extra level of indirection ensures that no clients of os 21 // can overwrite this data, which could cause the finalizer 22 // to close the wrong file descriptor. 23 type file struct { 24 fd int 25 name string 26 dirinfo *dirInfo // nil unless directory being read 27 nepipe int // number of consecutive EPIPE in Write 28 } 29 30 // Fd returns the integer Unix file descriptor referencing the open file. 31 func (f *File) Fd() uintptr { 32 if f == nil { 33 return ^(uintptr(0)) 34 } 35 return uintptr(f.fd) 36 } 37 38 // NewFile returns a new File with the given file descriptor and name. 39 func NewFile(fd uintptr, name string) *File { 40 fdi := int(fd) 41 if fdi < 0 { 42 return nil 43 } 44 f := &File{&file{fd: fdi, name: name}} 45 runtime.SetFinalizer(f.file, (*file).close) 46 return f 47 } 48 49 // Auxiliary information if the File describes a directory 50 type dirInfo struct { 51 buf []byte // buffer for directory I/O 52 nbuf int // length of buf; return value from Getdirentries 53 bufp int // location of next record in buf. 54 } 55 56 // DevNull is the name of the operating system's ``null device.'' 57 // On Unix-like systems, it is "/dev/null"; on Windows, "NUL". 58 const DevNull = "/dev/null" 59 60 // OpenFile is the generalized open call; most users will use Open 61 // or Create instead. It opens the named file with specified flag 62 // (O_RDONLY etc.) and perm, (0666 etc.) if applicable. If successful, 63 // methods on the returned File can be used for I/O. 64 // If there is an error, it will be of type *PathError. 65 func OpenFile(name string, flag int, perm FileMode) (file *File, err error) { 66 r, e := syscall.Open(name, flag|syscall.O_CLOEXEC, syscallMode(perm)) 67 if e != nil { 68 return nil, &PathError{"open", name, e} 69 } 70 71 // There's a race here with fork/exec, which we are 72 // content to live with. See ../syscall/exec_unix.go. 73 // On OS X 10.6, the O_CLOEXEC flag is not respected. 74 // On OS X 10.7, the O_CLOEXEC flag works. 75 // Without a cheap & reliable way to detect 10.6 vs 10.7 at 76 // runtime, we just always call syscall.CloseOnExec on Darwin. 77 // Once >=10.7 is prevalent, this extra call can removed. 78 if syscall.O_CLOEXEC == 0 || runtime.GOOS == "darwin" { // O_CLOEXEC not supported 79 syscall.CloseOnExec(r) 80 } 81 82 return NewFile(uintptr(r), name), nil 83 } 84 85 // Close closes the File, rendering it unusable for I/O. 86 // It returns an error, if any. 87 func (f *File) Close() error { 88 return f.file.close() 89 } 90 91 func (file *file) close() error { 92 if file == nil || file.fd < 0 { 93 return syscall.EINVAL 94 } 95 var err error 96 if e := syscall.Close(file.fd); e != nil { 97 err = &PathError{"close", file.name, e} 98 } 99 file.fd = -1 // so it can't be closed again 100 101 // no need for a finalizer anymore 102 runtime.SetFinalizer(file, nil) 103 return err 104 } 105 106 // Stat returns the FileInfo structure describing file. 107 // If there is an error, it will be of type *PathError. 108 func (f *File) Stat() (fi FileInfo, err error) { 109 var stat syscall.Stat_t 110 err = syscall.Fstat(f.fd, &stat) 111 if err != nil { 112 return nil, &PathError{"stat", f.name, err} 113 } 114 return fileInfoFromStat(&stat, f.name), nil 115 } 116 117 // Stat returns a FileInfo describing the named file. 118 // If there is an error, it will be of type *PathError. 119 func Stat(name string) (fi FileInfo, err error) { 120 var stat syscall.Stat_t 121 err = syscall.Stat(name, &stat) 122 if err != nil { 123 return nil, &PathError{"stat", name, err} 124 } 125 return fileInfoFromStat(&stat, name), nil 126 } 127 128 // Lstat returns a FileInfo describing the named file. 129 // If the file is a symbolic link, the returned FileInfo 130 // describes the symbolic link. Lstat makes no attempt to follow the link. 131 // If there is an error, it will be of type *PathError. 132 func Lstat(name string) (fi FileInfo, err error) { 133 var stat syscall.Stat_t 134 err = syscall.Lstat(name, &stat) 135 if err != nil { 136 return nil, &PathError{"lstat", name, err} 137 } 138 return fileInfoFromStat(&stat, name), nil 139 } 140 141 func (f *File) readdir(n int) (fi []FileInfo, err error) { 142 dirname := f.name 143 if dirname == "" { 144 dirname = "." 145 } 146 dirname += "/" 147 names, err := f.Readdirnames(n) 148 fi = make([]FileInfo, len(names)) 149 for i, filename := range names { 150 fip, err := Lstat(dirname + filename) 151 if err == nil { 152 fi[i] = fip 153 } else { 154 fi[i] = &fileStat{name: filename} 155 } 156 } 157 return fi, err 158 } 159 160 // read reads up to len(b) bytes from the File. 161 // It returns the number of bytes read and an error, if any. 162 func (f *File) read(b []byte) (n int, err error) { 163 return syscall.Read(f.fd, b) 164 } 165 166 // pread reads len(b) bytes from the File starting at byte offset off. 167 // It returns the number of bytes read and the error, if any. 168 // EOF is signaled by a zero count with err set to 0. 169 func (f *File) pread(b []byte, off int64) (n int, err error) { 170 return syscall.Pread(f.fd, b, off) 171 } 172 173 // write writes len(b) bytes to the File. 174 // It returns the number of bytes written and an error, if any. 175 func (f *File) write(b []byte) (n int, err error) { 176 for { 177 m, err := syscall.Write(f.fd, b) 178 n += m 179 180 // If the syscall wrote some data but not all (short write) 181 // or it returned EINTR, then assume it stopped early for 182 // reasons that are uninteresting to the caller, and try again. 183 if 0 < m && m < len(b) || err == syscall.EINTR { 184 b = b[m:] 185 continue 186 } 187 188 return n, err 189 } 190 panic("not reached") 191 } 192 193 // pwrite writes len(b) bytes to the File starting at byte offset off. 194 // It returns the number of bytes written and an error, if any. 195 func (f *File) pwrite(b []byte, off int64) (n int, err error) { 196 return syscall.Pwrite(f.fd, b, off) 197 } 198 199 // seek sets the offset for the next Read or Write on file to offset, interpreted 200 // according to whence: 0 means relative to the origin of the file, 1 means 201 // relative to the current offset, and 2 means relative to the end. 202 // It returns the new offset and an error, if any. 203 func (f *File) seek(offset int64, whence int) (ret int64, err error) { 204 return syscall.Seek(f.fd, offset, whence) 205 } 206 207 // Truncate changes the size of the named file. 208 // If the file is a symbolic link, it changes the size of the link's target. 209 // If there is an error, it will be of type *PathError. 210 func Truncate(name string, size int64) error { 211 if e := syscall.Truncate(name, size); e != nil { 212 return &PathError{"truncate", name, e} 213 } 214 return nil 215 } 216 217 // Remove removes the named file or directory. 218 // If there is an error, it will be of type *PathError. 219 func Remove(name string) error { 220 // System call interface forces us to know 221 // whether name is a file or directory. 222 // Try both: it is cheaper on average than 223 // doing a Stat plus the right one. 224 e := syscall.Unlink(name) 225 if e == nil { 226 return nil 227 } 228 e1 := syscall.Rmdir(name) 229 if e1 == nil { 230 return nil 231 } 232 233 // Both failed: figure out which error to return. 234 // OS X and Linux differ on whether unlink(dir) 235 // returns EISDIR, so can't use that. However, 236 // both agree that rmdir(file) returns ENOTDIR, 237 // so we can use that to decide which error is real. 238 // Rmdir might also return ENOTDIR if given a bad 239 // file path, like /etc/passwd/foo, but in that case, 240 // both errors will be ENOTDIR, so it's okay to 241 // use the error from unlink. 242 if e1 != syscall.ENOTDIR { 243 e = e1 244 } 245 return &PathError{"remove", name, e} 246 } 247 248 // basename removes trailing slashes and the leading directory name from path name 249 func basename(name string) string { 250 i := len(name) - 1 251 // Remove trailing slashes 252 for ; i > 0 && name[i] == '/'; i-- { 253 name = name[:i] 254 } 255 // Remove leading directory name 256 for i--; i >= 0; i-- { 257 if name[i] == '/' { 258 name = name[i+1:] 259 break 260 } 261 } 262 263 return name 264 } 265 266 // Pipe returns a connected pair of Files; reads from r return bytes written to w. 267 // It returns the files and an error, if any. 268 func Pipe() (r *File, w *File, err error) { 269 var p [2]int 270 271 // See ../syscall/exec.go for description of lock. 272 syscall.ForkLock.RLock() 273 e := syscall.Pipe(p[0:]) 274 if e != nil { 275 syscall.ForkLock.RUnlock() 276 return nil, nil, NewSyscallError("pipe", e) 277 } 278 syscall.CloseOnExec(p[0]) 279 syscall.CloseOnExec(p[1]) 280 syscall.ForkLock.RUnlock() 281 282 return NewFile(uintptr(p[0]), "|0"), NewFile(uintptr(p[1]), "|1"), nil 283 } 284 285 // TempDir returns the default directory to use for temporary files. 286 func TempDir() string { 287 dir := Getenv("TMPDIR") 288 if dir == "" { 289 dir = "/tmp" 290 } 291 return dir 292 }