mountinfo: Mounted: normalize path, return ENOENT

kolyshkin · kolyshkin · commit dbd468bb51eb · 2021-10-28T09:37:33.000-07:00
1. In case the argument does not exist, Mounted now returns an
   appropriate error. Previously, this condition was treated as
   "not a mount point", with no error returned, but in fact such
   path could be a mount point, overshadowed by another mount.
   Since the mount is still unreachable, it can not be unmounted
   anyway, so we do not fall back to mountedByMountinfo, returning
   an error instead.

   In case callers are not interested in ENOENT, they should filter it
   out. Amend the function doc accordingly.

2. There are some corner cases in which mountedByOpenat2 or mountedByStat
   do not work properly. In particular,

    - neither work if there's an ending slash;
    - neither work for a symlink to a mounted directory;
    - mountedByStat do not work a parent of path is a symlink residing on
      different filesystem.

   To solve these cases, we have to call normalizePath() before path is used
   for any of mountedBy* functions, not just before mountedByMountinfo
   like it was done earlier.

   More tests are to be added by the next commit.

Signed-off-by: Kir Kolyshkin &lt;kolyshkin@gmail.com&gt;
diff --git a/mountinfo/mounted_linux.go b/mountinfo/mounted_linux.go
@@ -16,9 +16,6 @@ func mountedByOpenat2(path string) (bool, error) {
 		Flags: unix.O_PATH | unix.O_CLOEXEC,
 	})
 	if err != nil {
-		if err == unix.ENOENT { // not a mount
-			return false, nil
-		}
 		return false, &os.PathError{Op: "openat2", Path: dir, Err: err}
 	}
 	fd, err := unix.Openat2(dirfd, last, &unix.OpenHow{
@@ -32,14 +29,16 @@ func mountedByOpenat2(path string) (bool, error) {
 		return false, nil
 	case unix.EXDEV: // definitely a mount
 		return true, nil
-	case unix.ENOENT: // not a mount
-		return false, nil
 	}
 	// not sure
 	return false, &os.PathError{Op: "openat2", Path: path, Err: err}
 }
 
 func mounted(path string) (bool, error) {
+	path, err := normalizePath(path)
+	if err != nil {
+		return false, err
+	}
 	// Try a fast path, using openat2() with RESOLVE_NO_XDEV.
 	mounted, err := mountedByOpenat2(path)
 	if err == nil {
diff --git a/mountinfo/mounted_unix.go b/mountinfo/mounted_unix.go
@@ -4,7 +4,6 @@
 package mountinfo
 
 import (
-	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -16,10 +15,6 @@ func mountedByStat(path string) (bool, error) {
 	var st unix.Stat_t
 
 	if err := unix.Lstat(path, &st); err != nil {
-		if err == unix.ENOENT {
-			// Treat ENOENT as "not mounted".
-			return false, nil
-		}
 		return false, &os.PathError{Op: "stat", Path: path, Err: err}
 	}
 	dev := st.Dev
@@ -50,14 +45,6 @@ func normalizePath(path string) (realPath string, err error) {
 }
 
 func mountedByMountinfo(path string) (bool, error) {
-	path, err := normalizePath(path)
-	if err != nil {
-		if errors.Is(err, unix.ENOENT) {
-			// treat ENOENT as "not mounted"
-			return false, nil
-		}
-		return false, err
-	}
 	entries, err := GetMounts(SingleEntryFilter(path))
 	if err != nil {
 		return false, err
diff --git a/mountinfo/mountinfo.go b/mountinfo/mountinfo.go
@@ -11,6 +11,10 @@ func GetMounts(f FilterFunc) ([]*Info, error) {
 }
 
 // Mounted determines if a specified path is a mount point.
+//
+// The non-existent path returns an error. If a caller is not interested
+// in this particular error, it should handle it separately using e.g.
+// errors.Is(err, os.ErrNotExist).
 func Mounted(path string) (bool, error) {
 	// root is always mounted
 	if path == string(os.PathSeparator) {
diff --git a/mountinfo/mountinfo_bsd.go b/mountinfo/mountinfo_bsd.go
@@ -56,6 +56,10 @@ func parseMountTable(filter FilterFunc) ([]*Info, error) {
 }
 
 func mounted(path string) (bool, error) {
+	path, err := normalizePath(path)
+	if err != nil {
+		return false, err
+	}
 	// Fast path: compare st.st_dev fields.
 	// This should always work for FreeBSD and OpenBSD.
 	mounted, err := mountedByStat(path)
