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