github.com/jd-ly/tools@v0.5.7/internal/fastwalk/fastwalk_unix.go (about) 1 // Copyright 2016 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 linux darwin freebsd openbsd netbsd 6 // +build !appengine 7 8 package fastwalk 9 10 import ( 11 "fmt" 12 "os" 13 "syscall" 14 "unsafe" 15 ) 16 17 const blockSize = 8 << 10 18 19 // unknownFileMode is a sentinel (and bogus) os.FileMode 20 // value used to represent a syscall.DT_UNKNOWN Dirent.Type. 21 const unknownFileMode os.FileMode = os.ModeNamedPipe | os.ModeSocket | os.ModeDevice 22 23 func readDir(dirName string, fn func(dirName, entName string, typ os.FileMode) error) error { 24 fd, err := syscall.Open(dirName, 0, 0) 25 if err != nil { 26 return &os.PathError{Op: "open", Path: dirName, Err: err} 27 } 28 defer syscall.Close(fd) 29 30 // The buffer must be at least a block long. 31 buf := make([]byte, blockSize) // stack-allocated; doesn't escape 32 bufp := 0 // starting read position in buf 33 nbuf := 0 // end valid data in buf 34 skipFiles := false 35 for { 36 if bufp >= nbuf { 37 bufp = 0 38 nbuf, err = syscall.ReadDirent(fd, buf) 39 if err != nil { 40 return os.NewSyscallError("readdirent", err) 41 } 42 if nbuf <= 0 { 43 return nil 44 } 45 } 46 consumed, name, typ := parseDirEnt(buf[bufp:nbuf]) 47 bufp += consumed 48 if name == "" || name == "." || name == ".." { 49 continue 50 } 51 // Fallback for filesystems (like old XFS) that don't 52 // support Dirent.Type and have DT_UNKNOWN (0) there 53 // instead. 54 if typ == unknownFileMode { 55 fi, err := os.Lstat(dirName + "/" + name) 56 if err != nil { 57 // It got deleted in the meantime. 58 if os.IsNotExist(err) { 59 continue 60 } 61 return err 62 } 63 typ = fi.Mode() & os.ModeType 64 } 65 if skipFiles && typ.IsRegular() { 66 continue 67 } 68 if err := fn(dirName, name, typ); err != nil { 69 if err == ErrSkipFiles { 70 skipFiles = true 71 continue 72 } 73 return err 74 } 75 } 76 } 77 78 func parseDirEnt(buf []byte) (consumed int, name string, typ os.FileMode) { 79 // golang.org/issue/37269 80 dirent := &syscall.Dirent{} 81 copy((*[unsafe.Sizeof(syscall.Dirent{})]byte)(unsafe.Pointer(dirent))[:], buf) 82 if v := unsafe.Offsetof(dirent.Reclen) + unsafe.Sizeof(dirent.Reclen); uintptr(len(buf)) < v { 83 panic(fmt.Sprintf("buf size of %d smaller than dirent header size %d", len(buf), v)) 84 } 85 if len(buf) < int(dirent.Reclen) { 86 panic(fmt.Sprintf("buf size %d < record length %d", len(buf), dirent.Reclen)) 87 } 88 consumed = int(dirent.Reclen) 89 if direntInode(dirent) == 0 { // File absent in directory. 90 return 91 } 92 switch dirent.Type { 93 case syscall.DT_REG: 94 typ = 0 95 case syscall.DT_DIR: 96 typ = os.ModeDir 97 case syscall.DT_LNK: 98 typ = os.ModeSymlink 99 case syscall.DT_BLK: 100 typ = os.ModeDevice 101 case syscall.DT_FIFO: 102 typ = os.ModeNamedPipe 103 case syscall.DT_SOCK: 104 typ = os.ModeSocket 105 case syscall.DT_UNKNOWN: 106 typ = unknownFileMode 107 default: 108 // Skip weird things. 109 // It's probably a DT_WHT (http://lwn.net/Articles/325369/) 110 // or something. Revisit if/when this package is moved outside 111 // of goimports. goimports only cares about regular files, 112 // symlinks, and directories. 113 return 114 } 115 116 nameBuf := (*[unsafe.Sizeof(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0])) 117 nameLen := direntNamlen(dirent) 118 119 // Special cases for common things: 120 if nameLen == 1 && nameBuf[0] == '.' { 121 name = "." 122 } else if nameLen == 2 && nameBuf[0] == '.' && nameBuf[1] == '.' { 123 name = ".." 124 } else { 125 name = string(nameBuf[:nameLen]) 126 } 127 return 128 }