Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

#!/usr/bin/env python 

# 

# Copyright (C) 2024  Vates SAS - damien.thenot@vates.tech 

# 

# This program is free software: you can redistribute it and/or modify 

# it under the terms of the GNU General Public License as published by 

# the Free Software Foundation, either version 3 of the License, or 

# (at your option) any later version. 

# This program is distributed in the hope that it will be useful, 

# but WITHOUT ANY WARRANTY; without even the implied warranty of 

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 

# GNU General Public License for more details. 

# 

# You should have received a copy of the GNU General Public License 

# along with this program.  If not, see <https://www.gnu.org/licenses/>. 

 

import SR 

from SR import deviceCheck 

import SRCommand 

import EXTSR 

import util 

import xs_errors 

import os 

import re 

import lvutil 

 

CAPABILITIES = ["SR_PROBE", "SR_UPDATE", "SR_SUPPORTS_LOCAL_CACHING", 

                "VDI_CREATE", "VDI_DELETE", "VDI_ATTACH", "VDI_DETACH", 

                "VDI_UPDATE", "VDI_CLONE", "VDI_SNAPSHOT", "VDI_RESIZE", "VDI_MIRROR", 

                "VDI_GENERATE_CONFIG", 

                "VDI_RESET_ON_BOOT/2", "ATOMIC_PAUSE", "VDI_CONFIG_CBT", 

                "VDI_ACTIVATE", "VDI_DEACTIVATE", "THIN_PROVISIONING", "VDI_READ_CACHING"] 

 

CONFIGURATION = [['device', 'local device path (required) (e.g. /dev/sda3)']] 

 

DRIVER_INFO = { 

    'name': 'Large Block SR', 

    'description': 'SR plugin which emulates a 512 bytes disk on top of a 4KiB device then create a EXT SR', 

    'vendor': 'Vates', 

    'copyright': '(C) 2024 Vates', 

    'driver_version': '1.0', 

    'required_api_version': '1.0', 

    'capabilities': CAPABILITIES, 

    'configuration': CONFIGURATION 

} 

 

LARGEBLOCK_PREFIX = "XSLocalLargeBlock-" 

 

class LargeBlockSR(EXTSR.EXTSR): 

    """Emulating 512b drives for EXT storage repository""" 

 

    DRIVER_TYPE = "largeblock" 

    LOOP_SECTOR_SIZE = 512 

 

    @staticmethod 

    def handles(srtype): 

        return srtype == LargeBlockSR.DRIVER_TYPE 

 

    def load(self, sr_uuid): 

        super(LargeBlockSR, self).load(sr_uuid) 

        self.is_deleting = False 

        self.vgname = LARGEBLOCK_PREFIX + sr_uuid 

        self.remotepath = os.path.join("/dev", self.vgname, sr_uuid) 

 

    def attach(self, sr_uuid): 

        if not self.is_deleting: 

            vg_device = self._get_device() 

            self.dconf["device"] = ",".join(vg_device) 

            self._create_emulated_device() 

            if not self._is_vg_connection_correct(): # Check if we need to redo the connection by parsing `vgs -o vg_name,devices self.vgname` 

                self._redo_vg_connection() # Call redo VG connection to connect it correctly to the loop device instead of the real 4KiB block device 

        super(LargeBlockSR, self).attach(sr_uuid) 

 

    def detach(self, sr_uuid): 

        if not self.is_deleting: 

            vg_device = self._get_device() 

            self.dconf["device"] = ",".join(vg_device) 

        super(LargeBlockSR, self).detach(sr_uuid) 

        if not self.is_deleting: 

            self._destroy_emulated_device() 

 

    @deviceCheck 

    def create(self, sr_uuid, size): 

        base_devices = self.dconf["device"].split(",") 

        if len(base_devices) > 1: 

            raise xs_errors.XenError("ConfigDeviceInvalid", opterr="Multiple devices configuration is not supported") 

 

        for dev in base_devices: 

            logical_blocksize = util.pread2(["blockdev", "--getss", dev]).strip() 

            if logical_blocksize == "512": 

                raise xs_errors.XenError("LargeBlockIncorrectBlocksize", opterr="The logical blocksize of the device {} is compatible with normal SR types".format(dev)) 

 

        try: 

            self._create_emulated_device() 

            super(LargeBlockSR, self).create(sr_uuid, size) 

        finally: 

            self._destroy_emulated_device(base_devices) 

 

    def delete(self, sr_uuid): 

        base_devices = self._get_device() 

        self.dconf["device"] = ",".join(self._get_loopdev_from_device(base_devices)) 

 

        self.is_deleting = True 

        try: 

            super(LargeBlockSR, self).delete(sr_uuid) 

        except SR.SROSError: 

            # In case, the lvremove doesn't like the loop device, it will throw an error. 

            # We need to remove the device ourselves using the real device in this case. 

            for dev in base_devices: 

                util.pread2(["pvremove", dev]) 

        finally: 

            self._destroy_emulated_device(base_devices) 

            self.is_deleting = False 

 

    @deviceCheck 

    def probe(self): 

        # We override EXTSR.probe because it uses EXT_PREFIX in this call 

        return lvutil.srlist_toxml( 

            lvutil.scan_srlist(LARGEBLOCK_PREFIX, self.dconf['device']), 

            LARGEBLOCK_PREFIX 

        ) 

 

    def _create_loopdev(self, dev, emulated_path): 

        cmd = ["losetup", "-f", "-v", "--show", "--sector-size", str(self.LOOP_SECTOR_SIZE), dev] 

        loopdev = util.pread2(cmd).rstrip() 

 

        if os.path.exists(emulated_path) and os.path.islink(emulated_path): 

            os.unlink(emulated_path) 

 

        try: 

            os.symlink(loopdev, emulated_path) 

        except OSError: 

            raise xs_errors.XenError("LargeBlockSymlinkExist", opterr="Symlink {} couldn't be created".format(emulated_path)) 

 

    def _delete_loopdev(self, dev, emulated_path): 

            if os.path.exists(emulated_path) and os.path.islink(emulated_path): 

                os.unlink(emulated_path) 

 

            # The backing file isn't a symlink if given by ID in device-config but the real device 

            dev = os.path.realpath(dev) 

            loopdevs = self._get_loopdev_from_device(dev) 

 

            if loopdevs != None: 

                try: 

                    for lp in loopdevs: 

                        cmd = ["losetup", "-d", lp] # Remove the loop device 

                        util.pread2(cmd) 

                except SR.SROSError: 

                    util.SMlog("Couldn't removed losetup devices: {}".format(loopdevs)) 

            else: 

                xs_errors.XenError("LargeBlockNoLosetup", opterr="Couldn't find loop device for {}".format(dev)) 

 

    @staticmethod 

    def _get_loopdev_from_device(device): 

        lpdevs = [] 

        output = util.pread2(["losetup", "--list"]).rstrip() 

        if output: 

            for line in output.split("\n"): 

                line = line.split() 

                loopdev = line[0] 

                dev = line[5].strip() 

                if dev in device: 

                    lpdevs.append(loopdev) 

        return lpdevs 

 

    @staticmethod 

    def _get_device_from_loopdev(loopdevs): 

        devices = [] 

        output = util.pread2(["losetup", "--list"]).rstrip() 

        if output: 

            for line in output.split("\n"): 

                line = line.split() 

                lpdev = line[0] 

                dev = line[5] 

                if lpdev in loopdevs: 

                    devices.append(dev) 

        return devices 

 

    def _get_device_from_vg(self): 

        devices = [] 

        output = util.pread2(["vgs", "--noheadings", "-o", "vg_name,devices", self.vgname]).splitlines() 

        for line in output: 

            line = line.split() 

            dev = line[1].split("(")[0] 

            if os.path.islink(dev): 

                dev = os.path.realpath(dev) 

            devices.append(dev) 

        return devices 

 

    def _get_device(self): 

        vg_device = self._get_device_from_vg() 

        for dev in vg_device: 

            if re.match(r"(.*\.512)|(/dev/loop[0-9]+)", dev): 

                lpdev = os.path.realpath(dev) 

                realdev = self._get_device_from_loopdev(lpdev)[0] 

                vg_device.remove(dev) 

                vg_device.append(realdev) 

 

        return vg_device 

 

    def _is_vg_connection_correct(self): 

        output = util.pread2(["vgs", "--noheadings", "-o", "vg_name,devices", self.vgname]).split() 

        output[1] = output[1].split("(")[0] 

        return bool(re.match(r"(.*\.512)|(/dev/loop[0-9]+)", output[1])) 

 

    def _redo_vg_connection(self): 

        """ 

        In case of using a LargeBlockSR, the LVM scan at boot will find the LogicalVolume on the real block device. 

        And when the PBD is connecting, it will mount from the original device instead of the loop device since LVM prefers real devices it has seen first. 

        The PBD plug will succeed but then the SR will be accessed through the 4KiB device, returning to the erroneous behaviour on 4KiB device. 

        VM won't be able to run because vhd-util will fail to scan the VDI. 

        This function force the LogicalVolume to be mounted on top of our emulation layer by disabling the VolumeGroup and re-enabling while applying a filter. 

        """ 

 

        util.SMlog("Reconnecting VG {} to use emulated device".format(self.vgname)) 

        try: 

            lvutil.setActiveVG(self.vgname, False) 

            lvutil.setActiveVG(self.vgname, True, config="devices{ global_filter = [ \"r|^/dev/nvme.*|\", \"a|/dev/loop.*|\" ] }") 

        except util.CommandException as e: 

            xs_errors.XenError("LargeBlockVGReconnectFailed", opterr="Failed to reconnect the VolumeGroup {}, error: {}".format(self.vgname, e)) 

 

 

    @classmethod 

    def _get_emulated_device_path(cls, dev): 

        return "{dev}.{bs}".format(dev=dev, bs=cls.LOOP_SECTOR_SIZE) 

 

    def _create_emulated_device(self): 

        base_devices = self.dconf["device"].split(",") 

        emulated_devices = [] 

        for dev in base_devices: 

            emulated_path = self._get_emulated_device_path(dev) 

            self._create_loopdev(dev, emulated_path) 

            emulated_devices.append(emulated_path) 

 

        emulated_devices = ",".join(emulated_devices) 

        self.dconf["device"] = emulated_devices 

 

    def _destroy_emulated_device(self, devices=None): 

        if devices is None: 

            devices = self.dconf["device"].split(",") 

 

        for dev in devices: 

            emulated_path = self._get_emulated_device_path(dev) 

            self._delete_loopdev(dev, emulated_path) 

 

247if __name__ == '__main__': 

    SRCommand.run(LargeBlockSR, DRIVER_INFO) 

else: 

    SR.registerSR(LargeBlockSR)