84d6af7de8
Sometimes umount doesn't have much time to finish and failed with error 'target is busy', but this is not an actual error in some cases and the operation should be repeated again with some timeout. This solves the issue and raise actual exception only after several tries with timeout. Closes-Bug: #2004492 Change-Id: I069af85b52e20e9fd688f9ae07e66beb2179f3e1 Signed-off-by: Maksim Malchuk <maksim.malchuk@gmail.com>
188 lines
7.1 KiB
Python
188 lines
7.1 KiB
Python
# Copyright 2017 Andreas Florath (andreas@florath.net)
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
import functools
|
|
import logging
|
|
import os
|
|
import time
|
|
|
|
from diskimage_builder.block_device.exception \
|
|
import BlockDeviceSetupException
|
|
from diskimage_builder.block_device.plugin import NodeBase
|
|
from diskimage_builder.block_device.plugin import PluginBase
|
|
from diskimage_builder.block_device.utils import exec_sudo
|
|
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class MountPointNode(NodeBase):
|
|
|
|
def __init__(self, mount_base, config, state):
|
|
super(MountPointNode, self).__init__(config['name'], state)
|
|
|
|
# Parameter check
|
|
self.mount_base = mount_base
|
|
for pname in ['base', 'mount_point']:
|
|
if pname not in config:
|
|
raise BlockDeviceSetupException(
|
|
"MountPoint config needs [%s]" % pname)
|
|
setattr(self, pname, config[pname])
|
|
logger.debug("MountPoint created [%s]", self)
|
|
|
|
def get_edges(self):
|
|
"""Insert all edges
|
|
|
|
The dependency edge is created in all cases from the base
|
|
element (typically a mkfs) and, if this is not the 'first'
|
|
mount-point, an edge is created from the mount-point before in
|
|
"sorted order" (see :func:`sort_mount_points`). This ensures
|
|
that during mounting (and umounting) the globally correct
|
|
order is used.
|
|
"""
|
|
edge_from = []
|
|
edge_to = []
|
|
|
|
# should have been added by __init__...
|
|
assert 'sorted_mount_points' in self.state
|
|
sorted_mount_points = self.state['sorted_mount_points']
|
|
|
|
# If we are not first, add our parent in the global dependency
|
|
# list. sorted_mount_points is tuples (mount_point, node_name).
|
|
# find ourselves in the mount_points, and our parent node
|
|
# is one before us in node_name list.
|
|
mount_points = [x[0] for x in sorted_mount_points]
|
|
node_name = [x[1] for x in sorted_mount_points]
|
|
mpi = mount_points.index(self.mount_point)
|
|
if mpi > 0:
|
|
dep = node_name[mpi - 1]
|
|
edge_from.append(dep)
|
|
|
|
edge_from.append(self.base)
|
|
return (edge_from, edge_to)
|
|
|
|
def create(self):
|
|
logger.debug("mount called [%s]", self.mount_point)
|
|
rel_mp = self.mount_point if self.mount_point[0] != '/' \
|
|
else self.mount_point[1:]
|
|
mount_point = os.path.join(self.mount_base, rel_mp)
|
|
if not os.path.exists(mount_point):
|
|
# Need to sudo this because of permissions in the new
|
|
# file system tree.
|
|
exec_sudo(['mkdir', '-p', mount_point])
|
|
logger.info("Mounting [%s] to [%s]", self.name, mount_point)
|
|
exec_sudo(["mount", self.state['filesys'][self.base]['device'],
|
|
mount_point])
|
|
|
|
if 'mount' not in self.state:
|
|
self.state['mount'] = {}
|
|
self.state['mount'][self.mount_point] \
|
|
= {'name': self.name, 'base': self.base, 'path': mount_point}
|
|
|
|
if 'mount_order' not in self.state:
|
|
self.state['mount_order'] = []
|
|
self.state['mount_order'].append(self.mount_point)
|
|
|
|
def umount(self):
|
|
logger.info("Called for [%s]", self.name)
|
|
# Before calling umount, call 'fstrim' on suitable mounted
|
|
# file systems. This discards unused blocks from the mounted
|
|
# file system and therefore decreases the resulting image
|
|
# size.
|
|
#
|
|
# A race condition can occur when trying to fstrim immediately
|
|
# after deleting a file resulting in that free space not being
|
|
# reclaimed. Calling sync before fstrim is a workaround for
|
|
# this behaviour.
|
|
# https://lists.gnu.org/archive/html/qemu-devel/2014-03/msg02978.html
|
|
exec_sudo(["sync"])
|
|
if self.state['filesys'][self.base]['fstype'] != 'vfat':
|
|
exec_sudo(["fstrim", "--verbose",
|
|
self.state['mount'][self.mount_point]['path']])
|
|
# Even 'fstrim' call sometimes don't solve the issue with 'busy'
|
|
# filesystem, so we need to catch the exception and repeat unount.
|
|
mount_point = self.state['mount'][self.mount_point]['path']
|
|
catch = None
|
|
for try_cnt in range(10, 1, -1):
|
|
try:
|
|
exec_sudo(["umount", mount_point])
|
|
return
|
|
except BlockDeviceSetupException as e:
|
|
catch = e
|
|
logger.error("umount failed (%s)", e.output.strip())
|
|
time.sleep(3)
|
|
|
|
logger.debug("Gave up trying to umount [%s]", mount_point)
|
|
raise catch
|
|
|
|
def delete(self):
|
|
self.umount()
|
|
|
|
|
|
def cmp_mount_order(this, other):
|
|
"""Sort comparision function for mount-point sorting
|
|
|
|
See if ``this`` comes before ``other`` in mount-order list. In
|
|
words: if the other mount-point has us as it's parent, we come
|
|
before it (are less than it). e.g. ``/var < /var/log <
|
|
/var/log/foo``
|
|
|
|
:param this: tuple of mount_point, node name
|
|
:param other: tuple of mount_point, node name
|
|
:returns int: cmp value
|
|
|
|
"""
|
|
# sort is only based on the mount_point.
|
|
this, _ = this
|
|
other, _ = other
|
|
if this == other:
|
|
return 0
|
|
if other.startswith(this):
|
|
return -1
|
|
else:
|
|
return 1
|
|
|
|
|
|
class Mount(PluginBase):
|
|
def __init__(self, config, defaults, state):
|
|
super(Mount, self).__init__()
|
|
|
|
if 'mount-base' not in defaults:
|
|
raise BlockDeviceSetupException(
|
|
"Mount default config needs 'mount-base'")
|
|
self.node = MountPointNode(defaults['mount-base'], config, state)
|
|
|
|
# save this new node to the global mount-point list and
|
|
# re-order it to keep it in mount-order. Used in get_edges()
|
|
# to ensure we build the mount graph in order
|
|
#
|
|
# note we can't just put the MountPointNode into the state,
|
|
# because it's not json serialisable and we still dump the
|
|
# state to json. that's why we have this (mount_point, name)
|
|
# tuples and sorting trickery
|
|
sorted_mount_points = state.get('sorted_mount_points', [])
|
|
mount_points = [mp for mp, name in sorted_mount_points]
|
|
if self.node.mount_point in mount_points:
|
|
raise BlockDeviceSetupException(
|
|
"Mount point [%s] specified more than once"
|
|
% self.node.mount_point)
|
|
sorted_mount_points.append((self.node.mount_point, self.node.name))
|
|
sorted_mount_points.sort(key=functools.cmp_to_key(cmp_mount_order))
|
|
# Save the state if it's new (otherwise this is idempotent update)
|
|
state['sorted_mount_points'] = sorted_mount_points
|
|
logger.debug("Ordered mounts now: %s", sorted_mount_points)
|
|
|
|
def get_nodes(self):
|
|
return [self.node]
|