@xen-orchestra/backups 0.73.2 → 0.73.4

package/RemoteAdapter.mjs

@@ -1,34 +1,23 @@
 import { asyncEach } from '@vates/async-each'
 import { asyncMap, asyncMapSettled } from '@xen-orchestra/async-map'
-import { compose } from '@vates/compose'
 import { createLogger } from '@xen-orchestra/log'
 import { VhdDirectory, VhdSynthetic } from 'vhd-lib'
 import { decorateMethodsWith } from '@vates/decorate-with'
-import { deduped } from '@vates/disposable/deduped.js'
 import { dirname, join, resolve } from 'node:path'
-import { execFile } from 'child_process'
-import { mount } from '@vates/fuse-vhd'
-import { readdir, lstat } from 'node:fs/promises'
 import { synchronized } from 'decorator-synchronized'
-import { ZipFile } from 'yazl'
 import Disposable from 'promise-toolbox/Disposable'
 import fromCallback from 'promise-toolbox/fromCallback'
-import fromEvent from 'promise-toolbox/fromEvent'
 import groupBy from 'lodash/groupBy.js'
-import pDefer from 'promise-toolbox/defer'
 import pickBy from 'lodash/pickBy.js'
 import reduce from 'lodash/reduce.js'
-import * as tar from 'tar'
 import zlib from 'zlib'
 
 import { BACKUP_DIR } from './_getVmBackupDir.mjs'
 import { VmBackupDirectory } from '@xen-orchestra/backup-archive'
+import { fileRestoreDecorators, fileRestoreMethods } from './_fileRestore.mjs'
 import { formatFilenameDate } from './_filenameDate.mjs'
-import { getTmpDir } from './_getTmpDir.mjs'
 import { isMetadataFile } from './_backupType.mjs'
 import { isValidXva } from './_isValidXva.mjs'
-import { listPartitions, LVM_PARTITION_TYPE_MBR, LVM_PARTITION_TYPE_GPT } from './_listPartitions.mjs'
-import { lvs, pvs } from './_lvm.mjs'
 import { watchStreamSize } from './_watchStreamSize.mjs'
 
 import { RemoteVhdDisk, openDiskChain } from '@xen-orchestra/backup-archive/disks'
@@ -48,25 +37,6 @@ export const compareTimestamp = (a, b) => a.timestamp - b.timestamp
 const noop = Function.prototype
 
 const resolveRelativeFromFile = (file, path) => resolve('/', dirname(file), path).slice(1)
-const makeRelative = path => resolve('/', path).slice(1)
-const resolveSubpath = (root, path) => resolve(root, makeRelative(path))
-
-async function addZipEntries(zip, realBasePath, virtualBasePath, relativePaths) {
-  for (const relativePath of relativePaths) {
-    const realPath = join(realBasePath, relativePath)
-    const virtualPath = join(virtualBasePath, relativePath)
-
-    const stats = await lstat(realPath)
-    const { mode, mtime } = stats
-    const opts = { mode, mtime }
-    if (stats.isDirectory()) {
-      zip.addEmptyDirectory(virtualPath, opts)
-      await addZipEntries(zip, realPath, virtualPath, await readdir(realPath))
-    } else if (stats.isFile()) {
-      zip.addFile(realPath, virtualPath, opts)
-    }
-  }
-}
 
 const createSafeReaddir = (handler, methodName) => (path, options) =>
   handler.list(path, options).catch(error => {
@@ -76,11 +46,6 @@ const createSafeReaddir = (handler, methodName) => (path, options) =>
     return []
   })
 
-const debounceResourceFactory = factory =>
-  function () {
-    return this._debounceResource(factory.apply(this, arguments))
-  }
-
 export class RemoteAdapter {
   constructor(
     handler,
@@ -98,112 +63,6 @@ export class RemoteAdapter {
     return this._handler
   }
 
-  async _findPartition(devicePath, partitionId) {
-    const partitions = await listPartitions(devicePath)
-    const partition = partitions.find(_ => _.id === partitionId)
-    if (partition === undefined) {
-      throw new Error(`partition ${partitionId} not found`)
-    }
-    return partition
-  }
-
-  async *_getLvmLogicalVolumes(devicePath, pvId, vgName) {
-    yield this._getLvmPhysicalVolume(devicePath, pvId && (await this._findPartition(devicePath, pvId)))
-
-    debug('activate LVM volume group', { vgName })
-    await fromCallback(execFile, 'vgchange', ['-ay', vgName])
-    try {
-      debug('get LVM volume group name and path', { vgName })
-      yield lvs(['lv_name', 'lv_path'], vgName)
-    } finally {
-      debug('deactivate LVM volume group', { vgName })
-      await fromCallback(execFile, 'vgchange', ['-an', vgName])
-    }
-  }
-
-  async *_getLvmPhysicalVolume(devicePath, partition) {
-    const args = []
-    if (partition !== undefined) {
-      args.push('-o', partition.start * 512, '--sizelimit', partition.size)
-    }
-    args.push('--show', '-f', devicePath)
-
-    debug('attach loop device', { devicePath, partition })
-    const path = (await fromCallback(execFile, 'losetup', args)).trim()
-    try {
-      debug('list LVM physical volume', { path })
-      await fromCallback(execFile, 'pvscan', ['--cache', path])
-
-      yield path
-    } finally {
-      try {
-        const vgNames = await pvs('vg_name', path)
-
-        debug('deactivate LVM volume groups', { vgNames })
-        await fromCallback(execFile, 'vgchange', ['-an', ...vgNames])
-      } finally {
-        debug('detach loop device', { path })
-        await fromCallback(execFile, 'losetup', ['-d', path])
-      }
-    }
-  }
-
-  async *_getPartition(devicePath, partition) {
-    // the norecovery option is necessary because if the partition is dirty,
-    // mount will try to fix it which is impossible if because the device is read-only
-    const options = ['loop', 'ro', 'norecovery']
-
-    if (partition !== undefined) {
-      const { size, start } = partition
-      options.push(`sizelimit=${size}`)
-      if (start !== undefined) {
-        options.push(`offset=${start * 512}`)
-      }
-    }
-
-    const path = yield getTmpDir()
-    const mount = options => {
-      debug('mount device', { devicePath, mountPath: path })
-      return fromCallback(execFile, 'mount', [
-        `--options=${options.join(',')}`,
-        `--source=${devicePath}`,
-        `--target=${path}`,
-      ])
-    }
-
-    // `norecovery` option is used for ext3/ext4/xfs, if it fails it might be
-    // another fs, try without
-    try {
-      await mount([...options, 'norecovery'])
-    } catch (error) {
-      await mount(options)
-    }
-    try {
-      yield path
-    } finally {
-      debug('umount device', { devicePath, mountPath: path })
-      await fromCallback(execFile, 'umount', ['--lazy', path])
-    }
-  }
-
-  _listLvmLogicalVolumes(devicePath, partition, results = []) {
-    return Disposable.use(this._getLvmPhysicalVolume(devicePath, partition), async path => {
-      const lvs = await pvs(['lv_name', 'lv_path', 'lv_size', 'vg_name'], path)
-      const partitionId = partition !== undefined ? partition.id : ''
-      lvs.forEach((lv, i) => {
-        const name = lv.lv_name
-        if (name !== '') {
-          results.push({
-            id: `${partitionId}/${lv.vg_name}/${name}`,
-            name,
-            size: lv.lv_size,
-          })
-        }
-      })
-      return results
-    })
-  }
-
   // check if we will be allowed to merge a vhd created in this adapter
   // with the vhd at path `path`
   async isMergeableParent(packedParentUid, path) {
@@ -221,34 +80,6 @@ export class RemoteAdapter {
     })
   }
 
-  fetchPartitionFiles(diskId, partitionId, paths, format) {
-    const { promise, reject, resolve } = pDefer()
-    Disposable.use(
-      async function* () {
-        const path = yield this.getPartition(diskId, partitionId)
-        let outputStream
-
-        if (format === 'tgz') {
-          outputStream = tar.c({ cwd: path, gzip: true }, paths.map(makeRelative))
-        } else if (format === 'zip') {
-          const zip = new ZipFile()
-          await addZipEntries(zip, path, '', paths.map(makeRelative))
-          zip.end()
-          ;({ outputStream } = zip)
-        } else {
-          throw new Error('unsupported format ' + format)
-        }
-
-        resolve(outputStream)
-        await fromEvent(outputStream, 'end')
-      }.bind(this)
-    ).catch(error => {
-      warn(error)
-      reject(error)
-    })
-    return promise
-  }
-
   async #removeVmBackupsFromCache(backups) {
     await asyncEach(
       Object.entries(
@@ -386,76 +217,6 @@ export class RemoteAdapter {
     return this.useVhdDirectory()
   }
 
-  async *#getDiskLegacy(diskId) {
-    const RE_VHDI = /^vhdi(\d+)$/
-    const handler = this._handler
-
-    const diskPath = handler.getFilePath('/' + diskId)
-    const mountDir = yield getTmpDir()
-
-    debug('mount VHD (vhdimount)', { diskPath, mountPath: mountDir })
-    await fromCallback(execFile, 'vhdimount', [diskPath, mountDir])
-    try {
-      let max = 0
-      let maxEntry
-      const entries = await readdir(mountDir)
-      entries.forEach(entry => {
-        const matches = RE_VHDI.exec(entry)
-        if (matches !== null) {
-          const value = +matches[1]
-          if (value > max) {
-            max = value
-            maxEntry = entry
-          }
-        }
-      })
-      if (max === 0) {
-        throw new Error('no disks found')
-      }
-
-      yield `${mountDir}/${maxEntry}`
-    } finally {
-      debug('umount VHD (fusermount)', { diskPath, mountPath: mountDir })
-      await fromCallback(execFile, 'fusermount', ['-uz', mountDir])
-    }
-  }
-
-  async *getDisk(diskId) {
-    if (this._useGetDiskLegacy) {
-      yield* this.#getDiskLegacy(diskId)
-      return
-    }
-    const handler = this._handler
-    // this is a disposable
-    const mountDir = yield getTmpDir()
-    // this is also a disposable
-    yield mount(handler, diskId, mountDir)
-    // this will yield disk path to caller
-    yield `${mountDir}/vhd0`
-  }
-
-  // partitionId values:
-  //
-  // - undefined: raw disk
-  // - `<partitionId>`: partitioned disk
-  // - `<pvId>/<vgName>/<lvName>`: LVM on a partitioned disk
-  // - `/<vgName>/lvName>`: LVM on a raw disk
-  async *getPartition(diskId, partitionId) {
-    const devicePath = yield this.getDisk(diskId)
-    if (partitionId === undefined) {
-      return yield this._getPartition(devicePath)
-    }
-
-    const isLvmPartition = partitionId.includes('/')
-    if (isLvmPartition) {
-      const [pvId, vgName, lvName] = partitionId.split('/')
-      const lvs = yield this._getLvmLogicalVolumes(devicePath, pvId !== '' ? pvId : undefined, vgName)
-      return yield this._getPartition(lvs.find(_ => _.lv_name === lvName).lv_path)
-    }
-
-    return yield this._getPartition(devicePath, await this._findPartition(devicePath, partitionId))
-  }
-
   // if we use alias on this remote, we have to name the file alias.vhd
   getVhdFileName(baseName) {
     if (this.#useAlias()) {
@@ -496,56 +257,6 @@ export class RemoteAdapter {
     return backups
   }
 
-  listPartitionFiles(diskId, partitionId, path) {
-    return Disposable.use(this.getPartition(diskId, partitionId), async rootPath => {
-      path = resolveSubpath(rootPath, path)
-      const entriesMap = {}
-      await asyncEach(
-        await readdir(path),
-        async name => {
-          try {
-            const stats = await lstat(`${path}/${name}`)
-            if (stats.isDirectory()) {
-              entriesMap[name + '/'] = {}
-            } else if (stats.isFile()) {
-              entriesMap[name] = {}
-            }
-          } catch (error) {
-            if (error == null || error.code !== 'ENOENT') {
-              throw error
-            }
-          }
-        },
-        { concurrency: 1 }
-      )
-
-      return entriesMap
-    })
-  }
-
-  listPartitions(diskId) {
-    return Disposable.use(this.getDisk(diskId), async devicePath => {
-      const partitions = await listPartitions(devicePath)
-
-      if (partitions.length === 0) {
-        try {
-          // handle potential raw LVM physical volume
-          return await this._listLvmLogicalVolumes(devicePath, undefined, partitions)
-        } catch (error) {
-          return []
-        }
-      }
-
-      const results = []
-      await asyncMapSettled(partitions, partition =>
-        partition.type === LVM_PARTITION_TYPE_MBR || partition.type === LVM_PARTITION_TYPE_GPT
-          ? this._listLvmLogicalVolumes(devicePath, partition, results)
-          : results.push(partition)
-      )
-      return results
-    })
-  }
-
   async listPoolMetadataBackups() {
     const handler = this._handler
     const safeReaddir = createSafeReaddir(handler, 'listPoolMetadataBackups')
@@ -932,26 +643,8 @@ Object.assign(RemoteAdapter.prototype, {
   isValidXva,
 })
 
-decorateMethodsWith(RemoteAdapter, {
-  _getLvmLogicalVolumes: compose([
-    Disposable.factory,
-    [deduped, (devicePath, pvId, vgName) => [devicePath, pvId, vgName]],
-    debounceResourceFactory,
-  ]),
-
-  _getLvmPhysicalVolume: compose([
-    Disposable.factory,
-    [deduped, (devicePath, partition) => [devicePath, partition?.id]],
-    debounceResourceFactory,
-  ]),
-
-  _getPartition: compose([
-    Disposable.factory,
-    [deduped, (devicePath, partition) => [devicePath, partition?.id]],
-    debounceResourceFactory,
-  ]),
+// File-level-restore methods live in ./_fileRestore.mjs; mix them onto the prototype
+// before decorating so decorateMethodsWith can wrap them.
+Object.assign(RemoteAdapter.prototype, fileRestoreMethods)
 
-  getDisk: compose([Disposable.factory, [deduped, diskId => [diskId]], debounceResourceFactory]),
-
-  getPartition: Disposable.factory,
-})
+decorateMethodsWith(RemoteAdapter, fileRestoreDecorators)

package/_fileRestore.mjs

@@ -0,0 +1,476 @@
+// File-level-restore (FLR) methods for RemoteAdapter.
+//
+// These were extracted from RemoteAdapter.mjs to keep that file focused on backup
+// CRUD/cache/metadata. They are mixed back onto `RemoteAdapter.prototype` via
+// `Object.assign` and decorated via `decorateMethodsWith` in RemoteAdapter.mjs, so `this`
+// is the RemoteAdapter instance at call time (`this._handler`, `this._debounceResource`,
+// `this._useGetDiskLegacy` keep working unchanged). The logger keeps the original
+// `xo:backups:RemoteAdapter` namespace so existing debug filters are unaffected.
+import { asyncEach } from '@vates/async-each'
+import { asyncMapSettled } from '@xen-orchestra/async-map'
+import { compose } from '@vates/compose'
+import { createLogger } from '@xen-orchestra/log'
+import { deduped } from '@vates/disposable/deduped.js'
+import { randomBytes } from 'node:crypto'
+import { join, resolve } from 'node:path'
+import { execFile } from 'child_process'
+import { finished } from 'node:stream/promises'
+import { lstat, open, readdir, unlink } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { mount } from '@vates/fuse-vhd'
+import { ZipFile } from 'yazl'
+import Disposable from 'promise-toolbox/Disposable'
+import fromCallback from 'promise-toolbox/fromCallback'
+import pDefer from 'promise-toolbox/defer'
+import * as tar from 'tar'
+
+import { getTmpDir } from './_getTmpDir.mjs'
+import {
+  listPartitions,
+  LINUX_DATA_PARTITION_TYPE_GPT,
+  LINUX_DATA_PARTITION_TYPE_MBR,
+  LVM_PARTITION_TYPE_GPT,
+  LVM_PARTITION_TYPE_MBR,
+} from './_listPartitions.mjs'
+import { lvs, pvs } from './_lvm.mjs'
+
+const { debug, warn } = createLogger('xo:backups:RemoteAdapter')
+
+const noop = Function.prototype
+
+// Restrict LVM scanning to a single device. Backup PVs are clones: the very same PVID
+// appears at once on the raw loop device, the dm-snapshot overlaid on it, and every
+// other restored copy of the same VM. An unscoped pvs/pvscan/vgimportclone/vgchange then
+// aborts with "duplicate PV ... for PVID ..." and the VG can neither be renamed nor
+// activated. Accepting only the device in hand removes every duplicate from LVM's view.
+export const lvmOnlyDevice = devicePath => `devices { global_filter=[ "a|^${devicePath}$|", "r|.*|" ] }`
+
+// Partition-type predicates (exported for unit tests).
+export const isLvmPartitionType = type => type === LVM_PARTITION_TYPE_MBR || type === LVM_PARTITION_TYPE_GPT
+
+// Some installers (e.g. Ubuntu subiquity) place an LVM PV on a generic Linux-data partition
+// instead of the LVM type, so those are the only non-LVM types worth the (expensive) probe.
+export const isProbeableForLvm = type =>
+  type === LINUX_DATA_PARTITION_TYPE_MBR || type === LINUX_DATA_PARTITION_TYPE_GPT
+
+// Build the partition entries for a PV's logical volumes (exported for unit tests).
+// Shows "ubuntu-vg/ubuntu-lv" for readability; skips unnamed LVs.
+export const toLvPartitions = (partitionId, originalVgName, lvItems) =>
+  lvItems
+    .filter(lv => lv.lv_name !== '')
+    .map(lv => ({
+      id: `${partitionId}/${lv.vg_name}/${lv.lv_name}`,
+      name: originalVgName !== undefined ? `${originalVgName}/${lv.lv_name}` : lv.lv_name,
+      size: lv.lv_size,
+    }))
+
+const makeRelative = path => resolve('/', path).slice(1)
+const resolveSubpath = (root, path) => resolve(root, makeRelative(path))
+
+async function addZipEntries(zip, realBasePath, virtualBasePath, relativePaths) {
+  for (const relativePath of relativePaths) {
+    const realPath = join(realBasePath, relativePath)
+    const virtualPath = join(virtualBasePath, relativePath)
+
+    const stats = await lstat(realPath)
+    const { mode, mtime } = stats
+    const opts = { mode, mtime }
+    if (stats.isDirectory()) {
+      zip.addEmptyDirectory(virtualPath, opts)
+      await addZipEntries(zip, realPath, virtualPath, await readdir(realPath))
+    } else if (stats.isFile()) {
+      zip.addFile(realPath, virtualPath, opts)
+    }
+  }
+}
+
+const debounceResourceFactory = factory =>
+  function () {
+    return this._debounceResource(factory.apply(this, arguments))
+  }
+
+// legacy disk mount via vhdimount; extracted from a private method so it can live in this
+// module (mixin methods cannot reference class-private members).
+async function* getDiskLegacy(handler, diskId) {
+  const RE_VHDI = /^vhdi(\d+)$/
+
+  const diskPath = handler.getFilePath('/' + diskId)
+  const mountDir = yield getTmpDir()
+
+  debug('mount VHD (vhdimount)', { diskPath, mountPath: mountDir })
+  await fromCallback(execFile, 'vhdimount', [diskPath, mountDir])
+  try {
+    let max = 0
+    let maxEntry
+    const entries = await readdir(mountDir)
+    entries.forEach(entry => {
+      const matches = RE_VHDI.exec(entry)
+      if (matches !== null) {
+        const value = +matches[1]
+        if (value > max) {
+          max = value
+          maxEntry = entry
+        }
+      }
+    })
+    if (max === 0) {
+      throw new Error('no disks found')
+    }
+
+    yield `${mountDir}/${maxEntry}`
+  } finally {
+    debug('umount VHD (fusermount)', { diskPath, mountPath: mountDir })
+    await fromCallback(execFile, 'fusermount', ['-uz', mountDir])
+  }
+}
+
+// Mixed onto RemoteAdapter.prototype — `this` is the RemoteAdapter instance.
+export const fileRestoreMethods = {
+  async _findPartition(devicePath, partitionId) {
+    const partitions = await listPartitions(devicePath)
+    const partition = partitions.find(_ => _.id === partitionId)
+    if (partition === undefined) {
+      throw new Error(`partition ${partitionId} not found`)
+    }
+    return partition
+  },
+
+  async *_getLvmLogicalVolumes(devicePath, pvId, requestedVgName) {
+    const { vgName, lvmConfig } = yield this._getLvmPhysicalVolume(
+      devicePath,
+      pvId && (await this._findPartition(devicePath, pvId))
+    )
+
+    // vgName is the unique name vgimportclone just assigned to this PV; prefer it over the
+    // (possibly stale) name embedded in the partitionId. lvmConfig scopes every command to
+    // this device so a colliding/duplicate VG on the host or another copy can't shadow it.
+    const effectiveVgName = vgName ?? requestedVgName
+
+    debug('activate LVM volume group', { effectiveVgName, requestedVgName })
+    await fromCallback(execFile, 'vgchange', ['--config', lvmConfig, '-ay', effectiveVgName])
+    try {
+      debug('get LVM logical volumes', { effectiveVgName })
+      yield lvs(['lv_name', 'lv_path'], '--config', lvmConfig, effectiveVgName)
+    } finally {
+      debug('deactivate LVM volume group', { effectiveVgName })
+      await fromCallback(execFile, 'vgchange', ['--config', lvmConfig, '-an', effectiveVgName])
+    }
+  },
+
+  async *_getLvmPhysicalVolume(devicePath, partition) {
+    const loopArgs = []
+    if (partition !== undefined) {
+      loopArgs.push('-o', partition.start * 512, '--sizelimit', partition.size)
+    }
+    loopArgs.push('--show', '-f', devicePath)
+
+    debug('attach loop device', { devicePath, partition })
+    const loopDevice = (await fromCallback(execFile, 'losetup', loopArgs)).trim()
+
+    let cowPath, cowLoop, mapperName, vgName, lvmConfig
+    try {
+      // Cheap pre-check, scoped to this loop so a duplicate PVID (another copy of the same
+      // VM restored concurrently) can't make it fail: is there an LVM PV here at all?
+      // Non-PV partitions (/boot, EFI, raw disks) skip the whole dm-snapshot machinery.
+      const [originalVgName] = (
+        await pvs('vg_name', '--config', lvmOnlyDevice(loopDevice), loopDevice).catch(() => [])
+      ).filter(Boolean)
+      if (originalVgName === undefined) {
+        const where = partition !== undefined ? ` partition ${partition.id}` : ''
+        throw new Error(`no LVM physical volume on ${devicePath}${where}`)
+      }
+
+      // The backup is read-only, so overlay a writable dm-snapshot to let vgimportclone
+      // rewrite metadata, and rename the VG to a unique name so concurrent clones (identical
+      // PVID and VG name) don't collide on device-mapper node names. Every LVM command is
+      // scoped to the snapshot device (lvmConfig) to keep duplicate PVIDs out of LVM's view.
+      mapperName = `xo-pv-${randomBytes(4).toString('hex')}`
+      const mapperPath = `/dev/mapper/${mapperName}`
+      lvmConfig = lvmOnlyDevice(mapperPath)
+
+      // ~4 MB sparse COW is enough to hold the LVM metadata rewrites
+      cowPath = join(tmpdir(), `${mapperName}.cow`)
+      const fh = await open(cowPath, 'w')
+      await fh.truncate(4 * 1024 * 1024)
+      await fh.close()
+      cowLoop = (await fromCallback(execFile, 'losetup', ['--show', '-f', cowPath])).trim()
+
+      const sectors = (await fromCallback(execFile, 'blockdev', ['--getsz', loopDevice])).trim()
+      await fromCallback(execFile, 'dmsetup', [
+        'create',
+        mapperName,
+        '--table',
+        `0 ${sectors} snapshot ${loopDevice} ${cowLoop} P 8`,
+      ])
+
+      // Unique random VG name: list and mount each query/yield the name from the device, so
+      // it need not be deterministic — only collision-free across concurrent clones.
+      vgName = `xo${randomBytes(8).toString('hex')}`
+      debug('import LVM volume group with unique name via dm-snapshot', { vgName, originalVgName })
+      await fromCallback(execFile, 'vgimportclone', ['--config', lvmConfig, '--basevgname', vgName, mapperPath])
+
+      yield { path: mapperPath, originalVgName, vgName, lvmConfig }
+    } finally {
+      if (mapperName !== undefined) {
+        // best-effort deactivate (a no-op if it was never activated) before removing the snapshot
+        await fromCallback(execFile, 'vgchange', ['--config', lvmConfig, '-an', vgName]).catch(noop)
+        debug('remove dm-snapshot', { mapperName })
+        await fromCallback(execFile, 'dmsetup', ['remove', mapperName]).catch(err =>
+          warn('failed to remove dm-snapshot', { mapperName, error: err })
+        )
+      }
+      if (cowLoop !== undefined) {
+        await fromCallback(execFile, 'losetup', ['-d', cowLoop]).catch(noop)
+      }
+      if (cowPath !== undefined) {
+        await unlink(cowPath).catch(noop)
+      }
+      debug('detach loop device', { loopDevice })
+      await fromCallback(execFile, 'losetup', ['-d', loopDevice])
+    }
+  },
+
+  async *_getPartition(devicePath, partition) {
+    const options = ['loop', 'ro']
+
+    if (partition !== undefined) {
+      const { size, start } = partition
+      options.push(`sizelimit=${size}`)
+      if (start !== undefined) {
+        options.push(`offset=${start * 512}`)
+      }
+    }
+
+    const path = yield getTmpDir()
+    const mount = options => {
+      debug('mount device', { devicePath, mountPath: path })
+      return fromCallback(execFile, 'mount', [
+        `--options=${options.join(',')}`,
+        `--source=${devicePath}`,
+        `--target=${path}`,
+      ]).catch(error => {
+        if (error.stderr) {
+          error.message = `${error.message}: ${error.stderr.trim()}`
+        }
+        throw error
+      })
+    }
+
+    // norecovery prevents mount from attempting journal replay on a read-only device (ext3/ext4/xfs).
+    // Other filesystems don't support it, so fall back without it on failure.
+    try {
+      await mount([...options, 'norecovery'])
+    } catch (error) {
+      await mount(options)
+    }
+
+    try {
+      yield path
+    } finally {
+      debug('umount device', { devicePath, mountPath: path })
+      await fromCallback(execFile, 'umount', ['--lazy', path])
+    }
+  },
+
+  _listLvmLogicalVolumes(devicePath, partition, results = []) {
+    return Disposable.use(
+      this._getLvmPhysicalVolume(devicePath, partition),
+      async ({ path, originalVgName, lvmConfig }) => {
+        const lvItems = await pvs(['lv_name', 'lv_path', 'lv_size', 'vg_name'], '--config', lvmConfig, path)
+        const partitionId = partition !== undefined ? partition.id : ''
+        results.push(...toLvPartitions(partitionId, originalVgName, lvItems))
+        return results
+      }
+    )
+  },
+
+  fetchPartitionFiles(diskId, partitionId, paths, format) {
+    const { promise, reject, resolve } = pDefer()
+    const self = this
+    Disposable.use(async function* () {
+      const path = yield self.getPartition(diskId, partitionId)
+      let outputStream
+
+      if (format === 'tgz') {
+        // process one entry at a time with { job: 1}. node-tar defaults to 4
+        // concurrent jobs, which on a FUSE-backed restore mount means up to 4
+        // simultaneous reads. Those saturate the libuv threadpool and starve
+        // the underlying vhd/CIFS reads NTFS-3g depends on (FUSE-on-FUSE
+        // threadpool deadlock). Serializing keeps a worker free for them.
+        outputStream = tar.c({ cwd: path, gzip: true, jobs: 1 }, paths.map(makeRelative))
+        resolve(outputStream)
+      } else if (format === 'zip') {
+        const zip = new ZipFile()
+        // Resolve with the stream before enumeration so the client can start
+        // receiving data immediately — addZipEntries over FUSE/S3 can take
+        // minutes for large trees (e.g. node_modules) and would otherwise
+        // appear as a freeze with no response sent.
+        outputStream = zip.outputStream
+        resolve(zip.outputStream)
+        await addZipEntries(zip, path, '', paths.map(makeRelative))
+        zip.end()
+      } else {
+        throw new Error('unsupported format ' + format)
+      }
+
+      await finished(outputStream).catch(noop)
+    }).catch(error => {
+      warn(error)
+      reject(error)
+    })
+    return promise
+  },
+
+  async *getDisk(diskId) {
+    if (this._useGetDiskLegacy) {
+      yield* getDiskLegacy(this._handler, diskId)
+      return
+    }
+    const handler = this._handler
+    // this is a disposable
+    const mountDir = yield getTmpDir()
+    // this is also a disposable
+    yield mount(handler, diskId, mountDir)
+    // this will yield disk path to caller
+    yield `${mountDir}/vhd0`
+  },
+
+  // partitionId values:
+  //
+  // - undefined: raw disk
+  // - `<partitionId>`: partitioned disk
+  // - `<pvId>/<vgName>/<lvName>`: LVM on a partitioned disk
+  // - `/<vgName>/lvName>`: LVM on a raw disk
+  async *getPartition(diskId, partitionId) {
+    const devicePath = yield this.getDisk(diskId)
+    if (partitionId === undefined) {
+      debug(
+        'no partition specified, attempting raw disk mount — call listPartitions first if disk has partitions or LVM'
+      )
+      return yield this._getPartition(devicePath)
+    }
+
+    const isLvmPartition = partitionId.includes('/')
+    if (isLvmPartition) {
+      const [pvId, vgName, lvName] = partitionId.split('/')
+      const lvs = yield this._getLvmLogicalVolumes(devicePath, pvId !== '' ? pvId : undefined, vgName)
+      return yield this._getPartition(lvs.find(_ => _.lv_name === lvName).lv_path)
+    }
+
+    return yield this._getPartition(devicePath, await this._findPartition(devicePath, partitionId))
+  },
+
+  listPartitionFiles(diskId, partitionId, path) {
+    return Disposable.use(this.getPartition(diskId, partitionId), async rootPath => {
+      path = resolveSubpath(rootPath, path)
+      const entriesMap = {}
+      await asyncEach(
+        await readdir(path),
+        async name => {
+          try {
+            const stats = await lstat(`${path}/${name}`)
+            if (stats.isDirectory()) {
+              entriesMap[name + '/'] = {}
+            } else if (stats.isFile()) {
+              entriesMap[name] = {}
+            }
+          } catch (error) {
+            if (error == null || error.code !== 'ENOENT') {
+              throw error
+            }
+          }
+        },
+        { concurrency: 1 }
+      )
+
+      return entriesMap
+    })
+  },
+
+  listPartitions(diskId) {
+    return Disposable.use(this.getDisk(diskId), async devicePath => {
+      // partx may return empty on FUSE-backed files (vhd0); a loop device
+      // presents proper block-device semantics that partx reads reliably.
+      // losetup may itself fail if the FUSE mount isn't fully ready yet —
+      // fall back to the direct path so listPartitions returns [] instead of throwing.
+      let loopForParts, partitions
+      try {
+        loopForParts = (await fromCallback(execFile, 'losetup', ['--show', '-f', devicePath])).trim()
+        partitions = await listPartitions(loopForParts)
+      } catch (error) {
+        debug('partition probe via loop device failed, falling back to direct path', { error })
+        partitions = await listPartitions(devicePath)
+      } finally {
+        if (loopForParts !== undefined) {
+          await fromCallback(execFile, 'losetup', ['-d', loopForParts]).catch(noop)
+        }
+      }
+
+      if (partitions.length === 0) {
+        try {
+          // handle potential raw LVM physical volume
+          return await this._listLvmLogicalVolumes(devicePath, undefined, partitions)
+        } catch (error) {
+          return []
+        }
+      }
+
+      const results = []
+      await asyncMapSettled(partitions, async partition => {
+        if (isLvmPartitionType(partition.type)) {
+          return this._listLvmLogicalVolumes(devicePath, partition, results)
+        }
+
+        // Only generic Linux-data partitions can hide an LVM PV (subiquity-style); other
+        // types — BIOS boot, EFI, swap, … — are never PVs, so list them directly without
+        // the (expensive) loop + dm-snapshot + vgimportclone probe.
+        if (!isProbeableForLvm(partition.type)) {
+          results.push(partition)
+          return
+        }
+
+        const lvResults = []
+        try {
+          await this._listLvmLogicalVolumes(devicePath, partition, lvResults)
+        } catch (error) {
+          debug('LVM probe failed for Linux-data partition, treating as regular partition', {
+            partition,
+            error,
+          })
+        }
+        if (lvResults.length > 0) {
+          results.push(...lvResults)
+        } else {
+          results.push(partition)
+        }
+      })
+      return results
+    })
+  },
+}
+
+// Applied by RemoteAdapter.mjs via decorateMethodsWith(RemoteAdapter, fileRestoreDecorators).
+// debounceResourceFactory/deduped reference `this._debounceResource` at call time.
+export const fileRestoreDecorators = {
+  _getLvmLogicalVolumes: compose([
+    Disposable.factory,
+    [deduped, (devicePath, pvId, vgName) => [devicePath, pvId, vgName]],
+    debounceResourceFactory,
+  ]),
+
+  _getLvmPhysicalVolume: compose([
+    Disposable.factory,
+    [deduped, (devicePath, partition) => [devicePath, partition?.id]],
+    debounceResourceFactory,
+  ]),
+
+  _getPartition: compose([
+    Disposable.factory,
+    [deduped, (devicePath, partition) => [devicePath, partition?.id]],
+    debounceResourceFactory,
+  ]),
+
+  getDisk: compose([Disposable.factory, [deduped, diskId => [diskId]], debounceResourceFactory]),
+
+  getPartition: Disposable.factory,
+}

package/_listPartitions.mjs

@@ -29,6 +29,15 @@ export const LVM_PARTITION_TYPE_MBR = 0x8e
 // GPT LVM type
 export const LVM_PARTITION_TYPE_GPT = 'e6d6d379-f507-44c2-a23c-238f2a3df928'
 
+// Generic "Linux filesystem data" types. These are the only non-LVM-typed
+// partitions worth probing for a hidden LVM PV, because some installers (e.g.
+// Ubuntu subiquity) place a PV on a partition left with this generic type.
+// Other types (BIOS boot, EFI, swap, …) are never LVM PVs.
+// MBR Linux native
+export const LINUX_DATA_PARTITION_TYPE_MBR = 0x83
+// GPT Linux filesystem data
+export const LINUX_DATA_PARTITION_TYPE_GPT = '0fc63daf-8483-4772-8e79-3d69d8477de4'
+
 const parsePartxLine = createParser({
   keyTransform: key => (key === 'UUID' ? 'id' : key.toLowerCase()),
   valueTransform: (value, key) => {

package/_runners/Metadata.mjs

@@ -1,4 +1,4 @@
-import { asyncMap } from '@xen-orchestra/async-map'
+import { asyncEach } from '@vates/async-each'
 import { Task } from '@vates/task'
 import Disposable from 'promise-toolbox/Disposable'
 import ignoreErrors from 'promise-toolbox/ignoreErrors'
@@ -82,10 +82,11 @@ export const Metadata = class MetadataBackupRunner extends Abstract {
         // remove pools that failed (already handled)
         pools = pools.filter(_ => _ !== undefined)
 
-        const promises = []
-        if (pools.length !== 0 && settings.retentionPoolMetadata !== 0) {
-          promises.push(
-            asyncMap(pools, async pool =>
+        const tasks = []
+
+        if (settings.retentionPoolMetadata !== 0) {
+          for (const pool of pools) {
+            tasks.push(async () =>
               Task.run(
                 {
                   properties: {
@@ -107,11 +108,11 @@ export const Metadata = class MetadataBackupRunner extends Abstract {
                   }).run()
               ).catch(noop)
             )
-          )
+          }
         }
 
         if (job.xoMetadata !== undefined && settings.retentionXoMetadata !== 0) {
-          promises.push(
+          tasks.push(() =>
             Task.run(
               {
                 properties: {
@@ -130,7 +131,16 @@ export const Metadata = class MetadataBackupRunner extends Abstract {
             ).catch(noop)
           )
         }
-        await Promise.all(promises)
+
+        const total = tasks.length
+        let transferred = 0
+
+        await asyncEach(tasks, async task => {
+          await task()
+          transferred++
+          Task.set('progress', Math.round(transferred / total))
+        })
+        Task.set('progress', 1)
       }
     )
   }

package/_runners/VmsRemote.mjs

@@ -63,6 +63,8 @@ export const VmsRemote = class RemoteVmsBackupRunner extends Abstract {
         const vmsUuids = await sourceRemoteAdapter.listAllVms()
 
         Task.info('vms', { vms: vmsUuids })
+        const nbVms = vmsUuids.length
+        let nbVmsDone = 0
 
         remoteAdapters = getAdaptersByRemote(remoteAdapters)
         const allSettings = this._job.settings
@@ -123,11 +125,14 @@ export const VmsRemote = class RemoteVmsBackupRunner extends Abstract {
                   )
                   .then(result => {
                     if (taskError === undefined) {
+                      nbVmsDone++
                       return task.success(result)
                     }
                     if (isLastRun) {
+                      nbVmsDone++
                       return task.failure(taskError)
                     }
+                    Task.set('progress', Math.round((nbVmsDone * 100) / nbVms))
                     // don't end the task
                     task.warning(`Retry the VM mirror backup due to an error`, {
                       attempt: nTriesByVmId[vmUuid],
@@ -148,6 +153,7 @@ export const VmsRemote = class RemoteVmsBackupRunner extends Abstract {
 
           await asyncMapSettled(vmIds, _handleVm)
         }
+        Task.set('progress', 100)
       }
     )
   }

package/_runners/VmsXapi.mjs

@@ -101,10 +101,14 @@ export const VmsXapi = class VmsXapiBackupRunner extends Abstract {
 
         const handleVm = vmUuid => {
           const getVmTask = () => {
-            if (taskByVmId[vmUuid] === undefined) {
+            const started = taskByVmId[vmUuid] !== undefined
+            if (!started) {
               taskByVmId[vmUuid] = new Task(taskStart)
             }
-            return taskByVmId[vmUuid]
+            return {
+              task: taskByVmId[vmUuid],
+              started,
+            }
           }
           const vmBackupFailed = async (error, task) => {
             if (isLastRun) {
@@ -135,7 +139,7 @@ export const VmsXapi = class VmsXapiBackupRunner extends Abstract {
                   taskStart.properties.name_label = vm.name_label
                 }
 
-                const task = getVmTask()
+                const { task } = getVmTask()
                 // error has to be caught in the task to prevent its failure, but handled outside the task to execute another task.run()
                 let taskError
                 return task
@@ -174,12 +178,19 @@ export const VmsXapi = class VmsXapiBackupRunner extends Abstract {
                       task.success(result)
                     } else {
                       // ending the task with error or not ending the task
-                      vmBackupFailed(taskError, task)
+                      return vmBackupFailed(taskError, task)
                     }
                   })
                   .catch(noop) // errors are handled by logs
               }),
-            error => vmBackupFailed(error, getVmTask())
+            error => {
+              const { task: vmTask, started } = getVmTask()
+              if (!started) {
+                // the task is not started (except if it's a retry), and an unstarted task can't be failed
+                vmTask.start()
+              }
+              return vmBackupFailed(error, vmTask)
+            }
           )
         }
         const { concurrency } = settings

package/_runners/_vmRunners/FullRemote.mjs

@@ -3,6 +3,7 @@ import { FullRemoteWriter } from '../_writers/FullRemoteWriter.mjs'
 import { forkStreamUnpipe } from '../_forkStreamUnpipe.mjs'
 import { watchStreamSize } from '../../_watchStreamSize.mjs'
 import { AggregatedFullRemoteWriter } from '../_writers/AggregatedFullRemoteWriter.mjs'
+import { Task } from '@vates/task'
 
 export const FullRemote = class FullRemoteVmBackupRunner extends AbstractRemote {
   _getRemoteWriters() {
@@ -15,7 +16,8 @@ export const FullRemote = class FullRemoteVmBackupRunner extends AbstractRemote
 
   async _run() {
     const transferList = await this._computeTransferList(({ mode }) => mode === 'full')
-
+    const nbTransferrableVms = transferList.length
+    let nbTransferredVms = 0
     for (const metadata of transferList) {
       const stream = this._throttleStream(await this._sourceRemoteAdapter.readFullVmBackup(metadata))
       const sizeContainer = watchStreamSize(stream)
@@ -27,7 +29,7 @@ export const FullRemote = class FullRemoteVmBackupRunner extends AbstractRemote
             stream: forkStreamUnpipe(stream),
             // stream will be forked and transformed, it's not safe to attach additional properties to it
             streamLength: stream.length,
-            maxStreamLength: stream.maxStreamLength, // on encrypted source
+            maxStreamLength: stream.maxStreamLength, // for encrypted destination/source without length
             timestamp: metadata.timestamp,
             vm: metadata.vm,
             vmSnapshot: metadata.vmSnapshot,
@@ -37,7 +39,10 @@ export const FullRemote = class FullRemoteVmBackupRunner extends AbstractRemote
       )
       // for healthcheck
       this._tags = metadata.vm.tags
+      nbTransferredVms++
+      Task.set('progress', Math.round((nbTransferredVms * 100) / nbTransferrableVms))
     }
+    Task.set('progress', 100)
     this._hasTransferredData = transferList.length > 0
   }
 }

package/_runners/_vmRunners/IncrementalRemote.mjs

@@ -12,6 +12,8 @@ import { openVhd } from 'vhd-lib'
 import { getVmBackupDir } from '../../_getVmBackupDir.mjs'
 import { SynchronizedDisk, ThrottledDisk } from '@xen-orchestra/disk-transform'
 import { AggregatedIncrementalRemoteWriter } from '../_writers/AggregatedIncrementalRemoteWriter.mjs'
+import { Task } from '@vates/task'
+import { TaskProgressHandler } from './_TaskProgressHandler.mjs'
 
 const { warn } = createLogger('xo:backups:Incrementalremote')
 class IncrementalRemoteVmBackupRunner extends AbstractRemote {
@@ -60,7 +62,8 @@ class IncrementalRemoteVmBackupRunner extends AbstractRemote {
   }
   async _run() {
     const transferList = await this._computeTransferList(({ mode }) => mode === 'delta')
-
+    const nbTransferrableVms = transferList.length
+    let nbTransferredVms = 0
     for (const metadata of transferList) {
       assert.strictEqual(metadata.mode, 'delta')
       const incrementalExport = await this._sourceRemoteAdapter.readIncrementalVmBackup(metadata, undefined, {
@@ -74,6 +77,7 @@ class IncrementalRemoteVmBackupRunner extends AbstractRemote {
       for (const key in incrementalExport.disks) {
         let disk = incrementalExport.disks[key]
         isVhdDifferencing[key] = disk.isDifferencing()
+        disk.addProgressHandler(new TaskProgressHandler())
         disk = new ThrottledDisk(disk, this._throttleGenerator)
         incrementalExport.disks[key] = new SynchronizedDisk(disk)
       }
@@ -116,7 +120,10 @@ class IncrementalRemoteVmBackupRunner extends AbstractRemote {
       await this._callWriters(writer => writer.cleanup(), 'writer.cleanup()')
       // for healthcheck
       this._tags = metadata.vm.tags
+      nbTransferredVms++
+      Task.set('progress', Math.round((nbTransferredVms * 100) / nbTransferrableVms))
     }
+    Task.set('progress', 100)
     this._hasTransferredData = transferList.length > 0
   }
 }

package/_runners/_vmRunners/IncrementalXapi.mjs

@@ -18,6 +18,7 @@ import {
 import { ThrottledDisk, SynchronizedDisk } from '@xen-orchestra/disk-transform'
 import { AggregatedIncrementalRemoteWriter } from '../_writers/AggregatedIncrementalRemoteWriter.mjs'
 import { AggregatedIncrementalXapiWriter } from '../_writers/AggregatedIncrementalXapiWriter.mjs'
+import { TaskProgressHandler } from './_TaskProgressHandler.mjs'
 
 const { debug } = createLogger('xo:backups:IncrementalXapiVmBackup')
 
@@ -52,6 +53,7 @@ export const IncrementalXapi = class IncrementalXapiVmBackupRunner extends Abstr
     let useNbd = false
     for (const key in deltaExport.disks) {
       let disk = deltaExport.disks[key]
+      disk.addProgressHandler(new TaskProgressHandler())
       isVhdDifferencing[key] = disk.isDifferencing()
       if (!isFull && !isVhdDifferencing[key] && key !== exportedVm.$suspend_VDI?.$ref) {
         Task.warning('Backup fell back to a full')

package/_runners/_vmRunners/_TaskProgressHandler.mjs

@@ -0,0 +1,29 @@
+import { Task } from '@vates/task'
+
+const MAX_DURATION_BETWEEN_PROGRESS_EMIT = 5e3
+const MIN_THRESHOLD_PERCENT_BETWEEN_PROGRESS_EMIT = 0.01
+
+export class TaskProgressHandler {
+  #lastProgressDate
+  #lastProgressValue
+  constructor() {
+    Task.set('progress', 0)
+  }
+  async setProgress(progress) {
+    if (progress < 0 || progress > 1) {
+      return
+    }
+    if (
+      this.#lastProgressDate !== undefined &&
+      this.#lastProgressValue !== undefined &&
+      Date.now() - this.#lastProgressDate < MAX_DURATION_BETWEEN_PROGRESS_EMIT &&
+      progress - this.#lastProgressValue < MIN_THRESHOLD_PERCENT_BETWEEN_PROGRESS_EMIT
+    ) {
+      return
+    }
+    this.#lastProgressDate = Date.now()
+    this.#lastProgressValue = progress
+    Task.set('progress', Math.round(progress * 100))
+  }
+  done() {}
+}

package/_watchStreamSize.mjs

@@ -1,6 +1,16 @@
+import { TaskProgressHandler } from './_runners/_vmRunners/_TaskProgressHandler.mjs'
 export function watchStreamSize(stream, container = { size: 0 }) {
+  const progressHandler = container.progressHandler ?? new TaskProgressHandler()
   stream.on('data', data => {
     container.size += data.length
+    if (stream.length) {
+      // empty for xva exported by xapi
+      progressHandler.setProgress(container.size / stream.length)
+    }
+  })
+
+  stream.on('finish', () => {
+    progressHandler.setProgress(1)
   })
   stream.pause()
   return container

package/package.json

@@ -8,7 +8,7 @@
     "type": "git",
     "url": "https://github.com/vatesfr/xen-orchestra.git"
   },
-  "version": "0.73.2",
+  "version": "0.73.4",
   "engines": {
     "node": ">=14.18"
   },
@@ -25,19 +25,19 @@
     "@vates/compose": "^2.1.0",
     "@vates/decorate-with": "^2.1.0",
     "@vates/disposable": "^0.1.6",
-    "@vates/fuse-vhd": "^2.1.2",
-    "@vates/generator-toolbox": "^1.1.2",
+    "@vates/fuse-vhd": "^2.1.3",
+    "@vates/generator-toolbox": "^1.1.3",
     "@vates/nbd-client": "^3.4.0",
     "@vates/parse-duration": "^0.1.1",
     "@vates/task": "^0.7.0",
-    "@vates/types": "^1.26.0",
+    "@vates/types": "^1.27.0",
     "@xen-orchestra/async-map": "^0.1.3",
-    "@xen-orchestra/disk-transform": "^1.3.0",
-    "@xen-orchestra/fs": "^4.9.0",
+    "@xen-orchestra/disk-transform": "^1.3.1",
+    "@xen-orchestra/fs": "^4.9.1",
     "@xen-orchestra/log": "^0.7.2",
-    "@xen-orchestra/qcow2": "^1.3.0",
+    "@xen-orchestra/qcow2": "^1.3.1",
     "@xen-orchestra/template": "^0.1.1",
-    "@xen-orchestra/backup-archive": "^1.0.1",
+    "@xen-orchestra/backup-archive": "^1.0.2",
     "app-conf": "^3.0.0",
     "compare-versions": "^6.0.0",
     "d3-time-format": "^4.1.0",
@@ -56,7 +56,7 @@
     "uuid": "^9.0.0",
     "value-matcher": "^0.2.0",
     "vhd-lib": "^4.16.0",
-    "xen-api": "^4.7.7",
+    "xen-api": "^4.7.8",
     "yazl": "^2.5.1"
   },
   "devDependencies": {
@@ -67,7 +67,7 @@
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@xen-orchestra/xapi": "^8.8.0"
+    "@xen-orchestra/xapi": "^8.9.0"
   },
   "license": "AGPL-3.0-or-later",
   "author": {

package/runBackupWorker.mjs

@@ -4,22 +4,10 @@ import { fork } from 'child_process'
 const { warn } = createLogger('xo:backups:backupWorker')
 
 const PATH = new URL('_backupWorker.mjs', import.meta.url).pathname
-const DEFAULT_INSPECTOR_PORT = 9229
 
 export function runBackupWorker(params, onLog) {
   return new Promise((resolve, reject) => {
-    // run Node inspector on port+1 if --inspect or --inspect-brk
-    const inspectArg = process.execArgv.find(arg => arg.startsWith('--inspect') || arg.startsWith('--inspect-brk'))
-    const execArgv = inspectArg
-      ? [
-          inspectArg.replace(/^(--inspect(-brk)?)(=([^:]+:)?(\d+))?$/, (_, prefix, brk, _fullMatch, host, port) => {
-            const basePort = port ? parseInt(port) : DEFAULT_INSPECTOR_PORT
-            return `${prefix}=${host || ''}${basePort + 1}`
-          }),
-        ]
-      : []
-
-    const worker = fork(PATH, [], { execArgv })
+    const worker = fork(PATH, [])
 
     worker.on('exit', (code, signal) => reject(new Error(`worker exited with code ${code} and signal ${signal}`)))
     worker.on('error', reject)