removeall_at.go

     1  // Copyright 2018 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  //go:build unix || wasip1 || windows
     6  
     7  package os
     8  
     9  import (
    10  	"io"
    11  	"syscall"
    12  )
    13  
    14  func removeAll(path string) error {
    15  	if path == "" {
    16  		// fail silently to retain compatibility with previous behavior
    17  		// of RemoveAll. See issue 28830.
    18  		return nil
    19  	}
    20  
    21  	// The rmdir system call does not permit removing ".",
    22  	// so we don't permit it either.
    23  	if endsWithDot(path) {
    24  		return &PathError{Op: "RemoveAll", Path: path, Err: syscall.EINVAL}
    25  	}
    26  
    27  	// Simple case: if Remove works, we're done.
    28  	err := Remove(path)
    29  	if err == nil || IsNotExist(err) {
    30  		return nil
    31  	}
    32  
    33  	// RemoveAll recurses by deleting the path base from
    34  	// its parent directory
    35  	parentDir, base := splitPath(path)
    36  
    37  	parent, err := Open(parentDir)
    38  	if IsNotExist(err) {
    39  		// If parent does not exist, base cannot exist. Fail silently
    40  		return nil
    41  	}
    42  	if err != nil {
    43  		return err
    44  	}
    45  	defer parent.Close()
    46  
    47  	if err := removeAllFrom(parent, base); err != nil {
    48  		if pathErr, ok := err.(*PathError); ok {
    49  			pathErr.Path = parentDir + string(PathSeparator) + pathErr.Path
    50  			err = pathErr
    51  		}
    52  		return err
    53  	}
    54  	return nil
    55  }
    56  
    57  func removeAllFrom(parent *File, base string) error {
    58  	parentFd := sysfdType(parent.Fd())
    59  
    60  	// Simple case: if Unlink (aka remove) works, we're done.
    61  	err := removefileat(parentFd, base)
    62  	if err == nil || IsNotExist(err) {
    63  		return nil
    64  	}
    65  
    66  	// EISDIR means that we have a directory, and we need to
    67  	// remove its contents.
    68  	// EPERM or EACCES means that we don't have write permission on
    69  	// the parent directory, but this entry might still be a directory
    70  	// whose contents need to be removed.
    71  	// Otherwise just return the error.
    72  	if err != syscall.EISDIR && err != syscall.EPERM && err != syscall.EACCES {
    73  		return &PathError{Op: "unlinkat", Path: base, Err: err}
    74  	}
    75  	uErr := err
    76  
    77  	// Remove the directory's entries.
    78  	var recurseErr error
    79  	for {
    80  		const reqSize = 1024
    81  		var respSize int
    82  
    83  		// Open the directory to recurse into.
    84  		file, err := openDirAt(parentFd, base)
    85  		if err != nil {
    86  			if IsNotExist(err) {
    87  				return nil
    88  			}
    89  			if err == syscall.ENOTDIR || isErrNoFollow(err) {
    90  				// Not a directory; return the error from the unix.Unlinkat.
    91  				return &PathError{Op: "unlinkat", Path: base, Err: uErr}
    92  			}
    93  			recurseErr = &PathError{Op: "openfdat", Path: base, Err: err}
    94  			break
    95  		}
    96  
    97  		for {
    98  			numErr := 0
    99  
   100  			names, readErr := file.Readdirnames(reqSize)
   101  			// Errors other than EOF should stop us from continuing.
   102  			if readErr != nil && readErr != io.EOF {
   103  				file.Close()
   104  				if IsNotExist(readErr) {
   105  					return nil
   106  				}
   107  				return &PathError{Op: "readdirnames", Path: base, Err: readErr}
   108  			}
   109  
   110  			respSize = len(names)
   111  			for _, name := range names {
   112  				err := removeAllFrom(file, name)
   113  				if err != nil {
   114  					if pathErr, ok := err.(*PathError); ok {
   115  						pathErr.Path = base + string(PathSeparator) + pathErr.Path
   116  					}
   117  					numErr++
   118  					if recurseErr == nil {
   119  						recurseErr = err
   120  					}
   121  				}
   122  			}
   123  
   124  			// If we can delete any entry, break to start new iteration.
   125  			// Otherwise, we discard current names, get next entries and try deleting them.
   126  			if numErr != reqSize {
   127  				break
   128  			}
   129  		}
   130  
   131  		// Removing files from the directory may have caused
   132  		// the OS to reshuffle it. Simply calling Readdirnames
   133  		// again may skip some entries. The only reliable way
   134  		// to avoid this is to close and re-open the
   135  		// directory. See issue 20841.
   136  		file.Close()
   137  
   138  		// Finish when the end of the directory is reached
   139  		if respSize < reqSize {
   140  			break
   141  		}
   142  	}
   143  
   144  	// Remove the directory itself.
   145  	unlinkError := removedirat(parentFd, base)
   146  	if unlinkError == nil || IsNotExist(unlinkError) {
   147  		return nil
   148  	}
   149  
   150  	if recurseErr != nil {
   151  		return recurseErr
   152  	}
   153  	return &PathError{Op: "unlinkat", Path: base, Err: unlinkError}
   154  }
   155  
   156  // openDirAt opens a directory name relative to the directory referred to by
   157  // the file descriptor dirfd. If name is anything but a directory (this
   158  // includes a symlink to one), it should return an error. Other than that this
   159  // should act like openFileNolog.
   160  //
   161  // This acts like openFileNolog rather than OpenFile because
   162  // we are going to (try to) remove the file.
   163  // The contents of this file are not relevant for test caching.
   164  func openDirAt(dirfd sysfdType, name string) (*File, error) {
   165  	fd, err := rootOpenDir(dirfd, name)
   166  	if err != nil {
   167  		return nil, err
   168  	}
   169  	return newDirFile(fd, name)
   170  }
   171
View as plain text