github.com/april1989/origin-go-tools@v0.0.32/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  }