def _mount_devicemapper(self, identifier):
        """
        Devicemapper mount backend.
        """

        info = self.client.info()

        # cid is the contaienr_id of the temp container
        cid = self._identifier_as_cid(identifier)

        cinfo = self.client.inspect_container(cid)

        dm_dev_name, dm_dev_id, dm_dev_size = '', '', ''
        dm_pool = info['DriverStatus'][0][1]

        try:
            dm_dev_name = cinfo['GraphDriver']['Data']['DeviceName']
            dm_dev_id = cinfo['GraphDriver']['Data']['DeviceId']
            dm_dev_size = cinfo['GraphDriver']['Data']['DeviceSize']
        except:
            # TODO: deprecated when GraphDriver patch makes it upstream
            dm_dev_id, dm_dev_size = DockerMount._no_gd_api_dm(cid)
            dm_dev_name = dm_pool.replace('pool', cid)

        # grab list of devces
        dmsetupLs = dmsetupWrap.getDmsetupLs()
        if dmsetupLs == -1:
            raise MountError('Error: dmsetup returned non zero error ')

        # ENSURE device exists!
        if dm_dev_name not in dmsetupLs:
            # IF device doesn't exist yet we create it!
            Mount._activate_thin_device(dm_dev_name, dm_dev_id, dm_dev_size,
                                        dm_pool)

        # check that device is shown in /dev/mapper, if not we can use the
        # major minor numbers in /dev/block
        mapperDir = os.path.join('/dev/mapper', dm_dev_name)
        if os.path.exists(mapperDir):
            dm_dev_path = mapperDir
        else:
            # get new dmsetupLs after device has been created!
            dmsetupLs = dmsetupWrap.getDmsetupLs()
            # test if device exists in dmsetupls, if so, get its majorminor found in /dev/block
            majorMinor = dmsetupWrap.getMajorMinor(dm_dev_name, dmsetupLs)
            blockDir = os.path.join('/dev/block', majorMinor)

            # FIXME, coudl be due to Virtual box, but occasionally the block device
            # will not be created by the time we check it exists below, so we
            # can wait a half a second to let it be created up
            import time
            time.sleep(0.1)

            if os.path.exists(blockDir):
                dm_dev_path = blockDir
            else:
                raise MountError('Error: Block device found in dmsetup ls '
                                 'but not in /dev/mapper/ or /dev/block')

        options = ['ro', 'nosuid', 'nodev']
        # XFS should get nouuid
        fstype = Mount._get_fs(dm_dev_path).decode(sys.getdefaultencoding())
        if fstype.upper() == 'XFS' and 'nouuid' not in options:
            if 'nouuid' not in options:
                options.append('nouuid')
        try:
            Mount.mount_path(dm_dev_path, self.mountpoint)
        except MountError as de:
            self._cleanup_container(cinfo)
            Mount.remove_thin_device(dm_dev_name)
            raise de

        # return the temp container ID so we can unmount later
        return cid
Devicemapper mount backend.