Merge branch '16723-kill-vs-requeue'
[arvados.git] / services / fuse / arvados_fuse / unmount.py
1 # Copyright (C) The Arvados Authors. All rights reserved.
2 #
3 # SPDX-License-Identifier: AGPL-3.0
4
5 import collections
6 import errno
7 import os
8 import subprocess
9 import sys
10 import time
11
12
13 MountInfo = collections.namedtuple(
14     'MountInfo', ['is_fuse', 'major', 'minor', 'mnttype', 'path'])
15
16
17 def mountinfo():
18     mi = []
19     with open('/proc/self/mountinfo') as f:
20         for m in f.readlines():
21             mntid, pmntid, dev, root, path, extra = m.split(" ", 5)
22             mnttype = extra.split(" - ")[1].split(" ", 1)[0]
23             major, minor = dev.split(":")
24             mi.append(MountInfo(
25                 is_fuse=(mnttype == "fuse" or mnttype.startswith("fuse.")),
26                 major=major,
27                 minor=minor,
28                 mnttype=mnttype,
29                 path=path,
30             ))
31     return mi
32
33
34 def paths_to_unmount(path, mnttype):
35     paths = []
36     for m in mountinfo():
37         if m.path == path or m.path.startswith(path+"/"):
38             paths.append(m.path)
39             if not (m.is_fuse and (mnttype is None or
40                                    mnttype == m.mnttype)):
41                 raise Exception(
42                     "cannot unmount {}: mount type is {}".format(
43                         path, m.mnttype))
44     return paths
45
46
47 def safer_realpath(path, loop=True):
48     """Similar to os.path.realpath(), but avoids calling lstat().
49
50     Leaves some symlinks unresolved."""
51     if path == '/':
52         return path, True
53     elif not path.startswith('/'):
54         path = os.path.abspath(path)
55     while True:
56         path = path.rstrip('/')
57         dirname, basename = os.path.split(path)
58         try:
59             path, resolved = safer_realpath(os.path.join(dirname, os.readlink(path)), loop=False)
60         except OSError as e:
61             # Path is not a symlink (EINVAL), or is unreadable, or
62             # doesn't exist. If the error was EINVAL and dirname can
63             # be resolved, we will have eliminated all symlinks and it
64             # will be safe to call normpath().
65             dirname, resolved = safer_realpath(dirname, loop=loop)
66             path = os.path.join(dirname, basename)
67             if resolved and e.errno == errno.EINVAL:
68                 return os.path.normpath(path), True
69             else:
70                 return path, False
71         except RuntimeError:
72             if not loop:
73                 # Unwind to the point where we first started following
74                 # symlinks.
75                 raise
76             # Resolving the whole path landed in a symlink cycle, but
77             # we might still be able to resolve dirname.
78             dirname, _ = safer_realpath(dirname, loop=loop)
79             return os.path.join(dirname, basename), False
80
81
82 def unmount(path, subtype=None, timeout=10, recursive=False):
83     """Unmount the fuse mount at path.
84
85     Unmounting is done by writing 1 to the "abort" control file in
86     sysfs to kill the fuse driver process, then executing "fusermount
87     -u -z" to detach the mount point, and repeating these steps until
88     the mount is no longer listed in /proc/self/mountinfo.
89
90     This procedure should enable a non-root user to reliably unmount
91     their own fuse filesystem without risk of deadlock.
92
93     Returns True if unmounting was successful, False if it wasn't a
94     fuse mount at all. Raises an exception if it cannot be unmounted.
95     """
96
97     path, _ = safer_realpath(path)
98
99     if subtype is None:
100         mnttype = None
101     elif subtype == '':
102         mnttype = 'fuse'
103     else:
104         mnttype = 'fuse.' + subtype
105
106     if recursive:
107         paths = paths_to_unmount(path, mnttype)
108         if not paths:
109             # We might not have found any mounts merely because path
110             # contains symlinks, so we should resolve them and try
111             # again. We didn't do this from the outset because
112             # realpath() can hang (see explanation below).
113             paths = paths_to_unmount(os.path.realpath(path), mnttype)
114         for path in sorted(paths, key=len, reverse=True):
115             unmount(path, timeout=timeout, recursive=False)
116         return len(paths) > 0
117
118     was_mounted = False
119     attempted = False
120     fusermount_output = b''
121     if timeout is None:
122         deadline = None
123     else:
124         deadline = time.time() + timeout
125
126     while True:
127         mounted = False
128         for m in mountinfo():
129             if m.is_fuse and (mnttype is None or mnttype == m.mnttype):
130                 try:
131                     if m.path == path:
132                         was_mounted = True
133                         mounted = True
134                         break
135                 except OSError:
136                     continue
137         if not was_mounted and path != os.path.realpath(path):
138             # If the specified path contains symlinks, it won't appear
139             # verbatim in mountinfo.
140             #
141             # It might seem like we should have called realpath() from
142             # the outset. But we can't: realpath() hangs (in lstat())
143             # if we call it on an unresponsive mount point, and this
144             # is an important and common scenario.
145             #
146             # By waiting until now to try realpath(), we avoid this
147             # problem in the most common cases, which are: (1) the
148             # specified path has no symlinks and is a mount point, in
149             # which case was_mounted==True and we can proceed without
150             # calling realpath(); and (2) the specified path is not a
151             # mount point (e.g., it was already unmounted by someone
152             # else, or it's a typo), and realpath() can determine that
153             # without hitting any other unresponsive mounts.
154             path = os.path.realpath(path)
155             continue
156         elif not mounted:
157             return was_mounted
158
159         if attempted:
160             # Report buffered stderr from previous call to fusermount,
161             # now that we know it didn't succeed.
162             sys.stderr.write(fusermount_output)
163
164             delay = 1
165             if deadline:
166                 delay = min(delay, deadline - time.time())
167                 if delay <= 0:
168                     raise Exception("timed out")
169             time.sleep(delay)
170
171         try:
172             with open('/sys/fs/fuse/connections/{}/abort'.format(m.minor),
173                       'w') as f:
174                 f.write("1")
175         except IOError as e:
176             if e.errno != errno.ENOENT:
177                 raise
178
179         attempted = True
180         try:
181             subprocess.check_output(
182                 ["fusermount", "-u", "-z", path],
183                 stderr=subprocess.STDOUT)
184         except subprocess.CalledProcessError as e:
185             fusermount_output = e.output
186         else:
187             fusermount_output = b''