Coverage for drivers/blktap2.py: 41%

289 if stdout_line == "blktap kernel module not installed\n": 289 ↛ 292line 289 didn't jump to line 292, because the condition on line 289 was never true

290 # This isn't pretty but (a) neither is confusing stdout/stderr

291 # and at least causes the error to describe the fix

292 raise Exception("blktap kernel module not installed: try 'modprobe blktap'")

293 row = {}

294

295 for field in stdout_line.rstrip().split(' ', 3):

296 bits = field.split('=')

297 if len(bits) == 2: 297 ↛ 309line 297 didn't jump to line 309, because the condition on line 297 was never false

298 key, val = field.split('=')

299

300 if key in ('pid', 'minor'):

301 row[key] = int(val, 10)

302

303 elif key in ('state'):

304 row[key] = int(val, 0x10)

305

306 else:

307 row[key] = val

308 else:

309 util.SMlog("Ignoring unexpected tap-ctl output: %s" % repr(field))

310 yield row

311

312 tapctl._wait(True)

313

314 @classmethod

315 @retried(backoff=.5, limit=10)

316 def list(cls, **args):

317

318 # FIXME. We typically get an EPROTO when uevents interleave

319 # with SM ops and a tapdisk shuts down under our feet. Should

320 # be fixed in SM.

321

322 try:

323 return list(cls.__list( ** args))

324

325 except cls.CommandFailure as e:

326 transient = [errno.EPROTO, errno.ENOENT]

327 if e.has_status and e.status in transient:

328 raise RetryLoop.TransientFailure(e)

329 raise

330

331 @classmethod

332 def allocate(cls, devpath=None):

333 args = ["allocate"]

334 args += cls._maybe("-d", devpath)

335 return cls._pread(args)

336

337 @classmethod

338 def free(cls, minor):

339 args = ["free", "-m", minor]

340 cls._pread(args)

341

342 @classmethod

343 @retried(backoff=.5, limit=10)

344 def spawn(cls):

345 args = ["spawn"]

346 try:

347 pid = cls._pread(args)

348 return int(pid)

349 except cls.CommandFailure as ce:

350 # intermittent failures to spawn. CA-292268

351 if ce.status == 1:

352 raise RetryLoop.TransientFailure(ce)

353 raise

354

355 @classmethod

356 def attach(cls, pid, minor):

357 args = ["attach", "-p", pid, "-m", minor]

358 cls._pread(args)

359

360 @classmethod

361 def detach(cls, pid, minor):

362 args = ["detach", "-p", pid, "-m", minor]

363 cls._pread(args)

364

365 @classmethod

366 def _load_key(cls, key_hash, vdi_uuid):

367 import plugins

368

369 return plugins.load_key(key_hash, vdi_uuid)

370

371 @classmethod

372 def open(cls, pid, minor, _type, _file, options):

373 params = Tapdisk.Arg(_type, _file)

374 args = ["open", "-p", pid, "-m", minor, '-a', str(params)]

375 text_mode = True

376 input = None

377 if options.get("rdonly"):

378 args.append('-R')

379 if options.get("lcache"):

380 args.append("-r")

381 if options.get("existing_prt") is not None:

382 args.append("-e")

383 args.append(str(options["existing_prt"]))

384 if options.get("secondary"):

385 args.append("-2")

386 args.append(options["secondary"])

387 if options.get("standby"):

388 args.append("-s")

389 if options.get("timeout"):

390 args.append("-t")

391 args.append(str(options["timeout"]))

392 if not options.get("o_direct", True):

393 args.append("-D")

394 if options.get('cbtlog'):

395 args.extend(['-C', options['cbtlog']])

396 if options.get('key_hash'):

397 key_hash = options['key_hash']

398 vdi_uuid = options['vdi_uuid']

399 key = cls._load_key(key_hash, vdi_uuid)

400

401 if not key:

402 raise util.SMException("No key found with key hash {}".format(key_hash))

403 input = key

404 text_mode = False

405 args.append('-E')

406

407 cls._pread(args=args, input=input, text_mode=text_mode)

408

409 @classmethod

410 def close(cls, pid, minor, force=False):

411 args = ["close", "-p", pid, "-m", minor, "-t", "120"]

412 if force:

413 args += ["-f"]

414 cls._pread(args)

415

416 @classmethod

417 def pause(cls, pid, minor):

418 args = ["pause", "-p", pid, "-m", minor]

419 cls._pread(args)

420

421 @classmethod

422 def unpause(cls, pid, minor, _type=None, _file=None, mirror=None,

423 cbtlog=None):

424 args = ["unpause", "-p", pid, "-m", minor]

425 if mirror:

426 args.extend(["-2", mirror])

427 if _type and _file:

428 params = Tapdisk.Arg(_type, _file)

429 args += ["-a", str(params)]

430 if cbtlog:

431 args.extend(["-c", cbtlog])

432 cls._pread(args)

433

434 @classmethod

435 def shutdown(cls, pid):

436 # TODO: This should be a real tap-ctl command

437 os.kill(pid, signal.SIGTERM)

438 os.waitpid(pid, 0)

439

440 @classmethod

441 def stats(cls, pid, minor):

442 args = ["stats", "-p", pid, "-m", minor]

443 return cls._pread(args, quiet=True)

444

445 @classmethod

446 def major(cls):

447 args = ["major"]

448 major = cls._pread(args)

449 return int(major)

450

451 @classmethod

452 def commit(cls, pid, minor, vdi_type, path):

453 args = ["commit", "-p", pid, "-m", minor, "-a", path]

454 cls._pread(args)

455

456 @classmethod

457 def query(cls, pid, minor, quiet=False):

458 args = ["query", "-p", pid, "-m", minor]

459 output = cls._pread(args, quiet=quiet)

460 m = re.match(r"Commit status '(.+)' $(\d+)\/(\d+)$", output)

461 status = m.group(1)

462 coalesced = int(m.group(2))

463 total_coalesce = int(m.group(3))

464 return (status, coalesced, total_coalesce)

465

466 @classmethod

467 def cancel_commit(cls, pid, minor, wait=True):

468 args = ["cancel", "-p", pid, "-m", minor]

469 if wait:

470 args.append("-w")

471 cls._pread(args)

472

473class TapdiskExists(Exception):

474 """Tapdisk already running."""

475

476 def __init__(self, tapdisk):

477 self.tapdisk = tapdisk

478

479 @override

480 def __str__(self) -> str:

481 return "%s already running" % self.tapdisk

482

483

484class TapdiskNotRunning(Exception):

485 """No such Tapdisk."""

486

487 def __init__(self, **attrs):

488 self.attrs = attrs

489

490 @override

491 def __str__(self) -> str:

492 items = iter(self.attrs.items())

493 attrs = ", ".join("%s=%s" % attr

494 for attr in items)

495 return "No such Tapdisk(%s)" % attrs

496

497

498class TapdiskNotUnique(Exception):

499 """More than one tapdisk on one path."""

500

501 def __init__(self, tapdisks):

502 self.tapdisks = tapdisks

503

504 @override

505 def __str__(self) -> str:

506 tapdisks = map(str, self.tapdisks)

507 return "Found multiple tapdisks: %s" % tapdisks

508

509

510class TapdiskFailed(Exception):

511 """Tapdisk launch failure."""

512

513 def __init__(self, arg, err):

514 self.arg = arg

515 self.err = err

516

517 @override

518 def __str__(self) -> str:

519 return "Tapdisk(%s): %s" % (self.arg, self.err)

520

521 def get_error(self):

522 return self.err

523

524

525class TapdiskInvalidState(Exception):

526 """Tapdisk pause/unpause failure"""

527

528 def __init__(self, tapdisk):

529 self.tapdisk = tapdisk

530

531 @override

532 def __str__(self) -> str:

533 return str(self.tapdisk)

534

535

536def mkdirs(path, mode=0o777):

537 if not os.path.exists(path):

538 parent, subdir = os.path.split(path)

539 assert parent != path

540 try:

541 if parent:

542 mkdirs(parent, mode)

543 if subdir:

544 os.mkdir(path, mode)

545 except OSError as e:

546 if e.errno != errno.EEXIST:

547 raise

548

549

550class KObject(object):

551

552 SYSFS_CLASSTYPE: ClassVar[str] = ""

553

554 @abstractmethod

555 def sysfs_devname(self) -> str:

556 pass

557

558

559class Attribute(object):

560

561 SYSFS_NODENAME: ClassVar[str] = ""

562

563 def __init__(self, path):

564 self.path = path

565

566 @classmethod

567 def from_kobject(cls, kobj):

568 path = "%s/%s" % (kobj.sysfs_path(), cls.SYSFS_NODENAME)

569 return cls(path)

570

571 class NoSuchAttribute(Exception):

572 def __init__(self, name):

573 self.name = name

574

575 @override

576 def __str__(self) -> str:

577 return "No such attribute: %s" % self.name

578

579 def _open(self, mode='r'):

580 try:

581 return open(self.path, mode)

582 except IOError as e:

583 if e.errno == errno.ENOENT:

584 raise self.NoSuchAttribute(self)

585 raise

586

587 def readline(self):

588 f = self._open('r')

589 s = f.readline().rstrip()

590 f.close()

591 return s

592

593 def writeline(self, val):

594 f = self._open('w')

595 f.write(val)

596 f.close()

597

598

599class ClassDevice(KObject):

600

601 @classmethod

602 def sysfs_class_path(cls):

603 return "/sys/class/%s" % cls.SYSFS_CLASSTYPE

604

605 def sysfs_path(self):

606 return "%s/%s" % (self.sysfs_class_path(),

607 self.sysfs_devname())

608

609

610class Blktap(ClassDevice):

611

612 DEV_BASEDIR = '/dev/xen/blktap-2'

613

614 SYSFS_CLASSTYPE = "blktap2"

615

616 def __init__(self, minor):

617 self.minor = minor

618 self._pool = None

619 self._task = None

620

621 @classmethod

622 def allocate(cls):

623 # FIXME. Should rather go into init.

624 mkdirs(cls.DEV_BASEDIR)

625

626 devname = TapCtl.allocate()

627 minor = Tapdisk._parse_minor(devname)

628 return cls(minor)

629

630 def free(self):

631 TapCtl.free(self.minor)

632

633 @override

634 def __str__(self) -> str:

635 return "%s(minor=%d)" % (self.__class__.__name__, self.minor)

636

637 @override

638 def sysfs_devname(self) -> str:

639 return "blktap!blktap%d" % self.minor

640

641 class Pool(Attribute):

642 SYSFS_NODENAME = "pool"

643

644 def get_pool_attr(self):

645 if not self._pool:

646 self._pool = self.Pool.from_kobject(self)

647 return self._pool

648

649 def get_pool_name(self):

650 return self.get_pool_attr().readline()

651

652 def set_pool_name(self, name):

653 self.get_pool_attr().writeline(name)

654

655 def set_pool_size(self, pages):

656 self.get_pool().set_size(pages)

657

658 def get_pool(self):

659 return BlktapControl.get_pool(self.get_pool_name())

660

661 def set_pool(self, pool):

662 self.set_pool_name(pool.name)

663

664 class Task(Attribute):

665 SYSFS_NODENAME = "task"

666

667 def get_task_attr(self):

668 if not self._task:

669 self._task = self.Task.from_kobject(self)

670 return self._task

671

672 def get_task_pid(self):

673 pid = self.get_task_attr().readline()

674 try:

675 return int(pid)

676 except ValueError:

677 return None

678

679 def find_tapdisk(self):

680 pid = self.get_task_pid()

681 if pid is None:

682 return None

683

684 return Tapdisk.find(pid=pid, minor=self.minor)

685

686 def get_tapdisk(self):

687 tapdisk = self.find_tapdisk()

688 if not tapdisk:

689 raise TapdiskNotRunning(minor=self.minor)

690 return tapdisk

691

692

693class Tapdisk(object):

694

695 TYPES = ['aio', 'vhd', 'qcow2']

696

697 def __init__(self, pid, minor, _type, path, state):

698 self.pid = pid

699 self.minor = minor

700 self.type = _type

701 self.path = path

702 self.state = state

703 self._dirty = False

704 self._blktap = None

705

706 @override

707 def __str__(self) -> str:

708 state = self.pause_state()

709 return "Tapdisk(%s, pid=%d, minor=%s, state=%s)" % \

710 (self.get_arg(), self.pid, self.minor, state)

711

712 @classmethod

713 def list(cls, **args):

714

715 for row in TapCtl.list( ** args):

716

717 args = {'pid': None,

718 'minor': None,

719 'state': None,

720 '_type': None,

721 'path': None}

722

723 for key, val in row.items():

724 if key in args:

725 args[key] = val

726

727 if 'args' in row: 727 ↛ 732line 727 didn't jump to line 732, because the condition on line 727 was never false

728 image = Tapdisk.Arg.parse(row['args'])

729 args['_type'] = image.type

730 args['path'] = image.path

731

732 if None in args.values(): 732 ↛ 733line 732 didn't jump to line 733, because the condition on line 732 was never true

733 continue

734

735 yield Tapdisk( ** args)

736

737 @classmethod

738 def find(cls, **args):

739

740 found = list(cls.list( ** args))

741

742 if len(found) > 1: 742 ↛ 743line 742 didn't jump to line 743, because the condition on line 742 was never true

743 raise TapdiskNotUnique(found)

744

745 if found: 745 ↛ 746line 745 didn't jump to line 746, because the condition on line 745 was never true

746 return found[0]

747

748 return None

749

750 @classmethod

751 def find_by_path(cls, path):

752 return cls.find(path=path)

753

754 @classmethod

755 def find_by_minor(cls, minor):

756 return cls.find(minor=minor)

757

758 @classmethod

759 def get(cls, **attrs):

760

761 tapdisk = cls.find( ** attrs)

762

763 if not tapdisk:

764 raise TapdiskNotRunning( ** attrs)

765

766 return tapdisk

767

768 @classmethod

769 def from_path(cls, path):

770 return cls.get(path=path)

771

772 @classmethod

773 def from_minor(cls, minor):

774 return cls.get(minor=minor)

775

776 @classmethod

777 def __from_blktap(cls, blktap):

778 tapdisk = cls.from_minor(minor=blktap.minor)

779 tapdisk._blktap = blktap

780 return tapdisk

781

782 def get_blktap(self):

783 if not self._blktap:

784 self._blktap = Blktap(self.minor)

785 return self._blktap

786

787 class Arg:

788

789 def __init__(self, _type, path):

790 self.type = _type

791 self.path = path

792

793 @override

794 def __str__(self) -> str:

795 return "%s:%s" % (self.type, self.path)

796

797 @classmethod

798 def parse(cls, arg):

799

800 try:

801 _type, path = arg.split(":", 1)

802 except ValueError:

803 raise cls.InvalidArgument(arg)

804

805 if _type not in Tapdisk.TYPES: 805 ↛ 806line 805 didn't jump to line 806, because the condition on line 805 was never true

806 raise cls.InvalidType(_type)

807

808 return cls(_type, path)

809

810 class InvalidType(Exception):

811 def __init__(self, _type):

812 self.type = _type

813

814 @override

815 def __str__(self) -> str:

816 return "Not a Tapdisk type: %s" % self.type

817

818 class InvalidArgument(Exception):

819 def __init__(self, arg):

820 self.arg = arg

821

822 @override

823 def __str__(self) -> str:

824 return "Not a Tapdisk image: %s" % self.arg

825

826 def get_arg(self):

827 return self.Arg(self.type, self.path)

828

829 def get_devpath(self):

830 return "%s/tapdev%d" % (Blktap.DEV_BASEDIR, self.minor)

831

832 @classmethod

833 def launch_from_arg(cls, arg):

834 arg = cls.Arg.parse(arg)

835 return cls.launch(arg.path, arg.type, False)

836

837 @staticmethod

838 def cgclassify(pid):

839

840 # We dont provide any <controllers>:<path>

841 # so cgclassify uses /etc/cgrules.conf which

842 # we have configured in the spec file.

843 cmd = ["cgclassify", str(pid)]

844 try:

845 util.pread2(cmd)

846 except util.CommandException as e:

847 util.logException(e)

848

849 @classmethod

850 def launch_on_tap(cls, blktap, path, _type, options):

851

852 tapdisk = cls.find_by_path(path)

853 if tapdisk: 853 ↛ 854line 853 didn't jump to line 854, because the condition on line 853 was never true

854 raise TapdiskExists(tapdisk)

855

856 minor = blktap.minor

857 try:

858 pid = TapCtl.spawn()

859 cls.cgclassify(pid)

860 try:

861 TapCtl.attach(pid, minor)

862

863 try:

864 retry_open = 0

865 while True:

866 try:

867 TapCtl.open(pid, minor, _type, path, options)

868 break

869 except TapCtl.CommandFailure as e:

870 err = (

871 'status' in e.info and e.info['status']

872 ) or None

873 if err in (errno.EIO, errno.EROFS, errno.EAGAIN): 873 ↛ 874line 873 didn't jump to line 874, because the condition on line 873 was never true

874 if retry_open < 5:

875 retry_open += 1

876 time.sleep(1)

877 continue

878 if LINSTOR_AVAILABLE and err == errno.EROFS:

879 log_drbd_openers(path)

880 raise

881 try:

882 tapdisk = cls.__from_blktap(blktap)

883 node = '/sys/dev/block/%d:%d' % (tapdisk.major(), tapdisk.minor)

884 util.set_scheduler_sysfs_node(node, ['none', 'noop'])

885 return tapdisk

886 except:

887 TapCtl.close(pid, minor)

888 raise

889

890 except:

891 TapCtl.detach(pid, minor)

892 raise

893

894 except:

895 try:

896 TapCtl.shutdown(pid)

897 except:

898 # Best effort to shutdown

899 pass

900 raise

901

902 except TapCtl.CommandFailure as ctl:

903 util.logException(ctl)

904 if ((path.startswith('/dev/xapi/cd/') or path.startswith('/dev/sr')) and 904 ↛ 908line 904 didn't jump to line 908, because the condition on line 904 was never false

905 ctl.has_status and ctl.get_error_code() == 123): # ENOMEDIUM (No medium found)

906 raise xs_errors.XenError('TapdiskDriveEmpty')

907 else:

908 raise TapdiskFailed(cls.Arg(_type, path), ctl)

909

910 @classmethod

911 def launch(cls, path, _type, rdonly):

912 blktap = Blktap.allocate()

913 try:

914 return cls.launch_on_tap(blktap, path, _type, {"rdonly": rdonly})

915 except:

916 blktap.free()

917 raise

918

919 def shutdown(self, force=False):

920

921 TapCtl.close(self.pid, self.minor, force)

922

923 TapCtl.detach(self.pid, self.minor)

924

925 self.get_blktap().free()

926

927 def pause(self):

928

929 if not self.is_running():

930 raise TapdiskInvalidState(self)

931

932 TapCtl.pause(self.pid, self.minor)

933

934 self._set_dirty()

935

936 def unpause(self, _type=None, path=None, mirror=None, cbtlog=None):

937

938 if not self.is_paused():

939 raise TapdiskInvalidState(self)

940

941 # FIXME: should the arguments be optional?

942 if _type is None:

943 _type = self.type

944 if path is None:

945 path = self.path

946

947 TapCtl.unpause(self.pid, self.minor, _type, path, mirror=mirror,

948 cbtlog=cbtlog)

949

950 self._set_dirty()

951

952 def stats(self):

953 return json.loads(TapCtl.stats(self.pid, self.minor))

954 #

955 # NB. dirty/refresh: reload attributes on next access

956 #

957

958 def _set_dirty(self):

959 self._dirty = True

960

961 def _refresh(self, __get):

962 t = self.from_minor(__get('minor'))

963 self.__init__(t.pid, t.minor, t.type, t.path, t.state)

964

965 @override

966 def __getattribute__(self, name) -> Any:

967 def __get(name):

968 # NB. avoid(rec(ursion)

969 return object.__getattribute__(self, name)

970

971 if __get('_dirty') and \ 971 ↛ 973line 971 didn't jump to line 973, because the condition on line 971 was never true

972 name in ['minor', 'type', 'path', 'state']:

973 self._refresh(__get)

974 self._dirty = False

975

976 return __get(name)

977

978 class PauseState:

979 RUNNING = 'R'

980 PAUSING = 'r'

981 PAUSED = 'P'

982

983 class Flags:

984 DEAD = 0x0001

985 CLOSED = 0x0002

986 QUIESCE_REQUESTED = 0x0004

987 QUIESCED = 0x0008

988 PAUSE_REQUESTED = 0x0010

989 PAUSED = 0x0020

990 SHUTDOWN_REQUESTED = 0x0040

991 LOCKING = 0x0080

992 RETRY_NEEDED = 0x0100

993 LOG_DROPPED = 0x0200

994

995 PAUSE_MASK = PAUSE_REQUESTED | PAUSED

996

997 def is_paused(self):

998 return not not (self.state & self.Flags.PAUSED)

999

1000 def is_running(self):

1001 return not (self.state & self.Flags.PAUSE_MASK)

1002

1003 def pause_state(self):

1004 if self.state & self.Flags.PAUSED:

1005 return self.PauseState.PAUSED

1006

1007 if self.state & self.Flags.PAUSE_REQUESTED:

1008 return self.PauseState.PAUSING

1009

1010 return self.PauseState.RUNNING

1011

1012 @staticmethod

1013 def _parse_minor(devpath):

1014 regex = r'%s/(blktap|tapdev)(\d+)$' % Blktap.DEV_BASEDIR

1015 pattern = re.compile(regex)

1016 groups = pattern.search(devpath)

1017 if not groups:

1018 raise Exception("malformed tap device: '%s' (%s) " % (devpath, regex))

1019

1020 minor = groups.group(2)

1021 return int(minor)

1022

1023 _major = None

1024

1025 @classmethod

1026 def major(cls):

1027 if cls._major:

1028 return cls._major

1029

1030 devices = open("/proc/devices")

1031 for line in devices:

1032

1033 row = line.rstrip().split(' ')

1034 if len(row) != 2:

1035 continue

1036

1037 major, name = row

1038 if name != 'tapdev':

1039 continue

1040

1041 cls._major = int(major)

1042 break

1043

1044 devices.close()

1045 return cls._major

1046

1047

1048class VDI(object):

1049 """SR.vdi driver decorator for blktap2"""

1050

1051 CONF_KEY_ALLOW_CACHING = "vdi_allow_caching"

1052 CONF_KEY_MODE_ON_BOOT = "vdi_on_boot"

1053 CONF_KEY_CACHE_SR = "local_cache_sr"

1054 CONF_KEY_O_DIRECT = "o_direct"

1055 LOCK_CACHE_SETUP = "cachesetup"

1056

1057 ATTACH_DETACH_RETRY_SECS = 120

1058

1059 def __init__(self, uuid, target, driver_info):

1060 self.target = self.TargetDriver(target, driver_info)

1061 self._vdi_uuid = uuid

1062 self._session = target.session

1063 self.xenstore_data = scsiutil.update_XS_SCSIdata(uuid, scsiutil.gen_synthetic_page_data(uuid))

1064 self.__o_direct = None

1065 self.__o_direct_reason = None

1066 self.lock = Lock("vdi", uuid)

1067 self.tap = None

1068

1069 def get_o_direct_capability(self, options):

1070 """Returns True/False based on licensing and caching_params"""

1071 if self.__o_direct is not None: 1071 ↛ 1072line 1071 didn't jump to line 1072, because the condition on line 1071 was never true

1072 return self.__o_direct, self.__o_direct_reason

1073

1074 if util.read_caching_is_restricted(self._session): 1074 ↛ 1075line 1074 didn't jump to line 1075, because the condition on line 1074 was never true

1075 self.__o_direct = True

1076 self.__o_direct_reason = "LICENSE_RESTRICTION"

1077 elif not ((self.target.vdi.sr.handles("nfs") or self.target.vdi.sr.handles("ext") or self.target.vdi.sr.handles("smb"))): 1077 ↛ 1080line 1077 didn't jump to line 1080, because the condition on line 1077 was never false

1078 self.__o_direct = True

1079 self.__o_direct_reason = "SR_NOT_SUPPORTED"

1080 elif options.get("rdonly") and not self.target.vdi.parent:

1081 self.__o_direct = True

1082 self.__o_direct_reason = "RO_WITH_NO_PARENT"

1083 elif options.get(self.CONF_KEY_O_DIRECT):

1084 self.__o_direct = True

1085 self.__o_direct_reason = "SR_OVERRIDE"

1086

1087 if self.__o_direct is None: 1087 ↛ 1088line 1087 didn't jump to line 1088, because the condition on line 1087 was never true

1088 self.__o_direct = False

1089 self.__o_direct_reason = ""

1090

1091 return self.__o_direct, self.__o_direct_reason

1092

1093 @classmethod

1094 def from_cli(cls, uuid):

1095 import VDI as sm

1096

1097 session = XenAPI.xapi_local()

1098 session.xenapi.login_with_password('root', '', '', 'SM')

1099

1100 target = sm.VDI.from_uuid(session, uuid)

1101 driver_info = target.sr.srcmd.driver_info

1102

1103 session.xenapi.session.logout()

1104

1105 return cls(uuid, target, driver_info)

1106

1107 @staticmethod

1108 def _tap_type(vdi_type):

1109 """Map a VDI type (e.g. 'raw') to a tapdisk driver type (e.g. 'aio')"""

1110 return {

1111 'raw': 'aio',

1112 'vhd': 'vhd',

1113 'qcow2': 'qcow2',

1114 'iso': 'aio', # for ISO SR

1115 'aio': 'aio', # for LVHD

1116 'file': 'aio',

1117 'phy': 'aio'

1118 }[vdi_type]

1119

1120 def get_tap_type(self):

1121 vdi_type = self.target.get_vdi_type()

1122 return VDI._tap_type(vdi_type)

1123

1124 def get_phy_path(self):

1125 return self.target.get_vdi_path()

1126

1127 class UnexpectedVDIType(Exception):

1128

1129 def __init__(self, vdi_type, target):

1130 self.vdi_type = vdi_type

1131 self.target = target

1132

1133 @override

1134 def __str__(self) -> str:

1135 return \

1136 "Target %s has unexpected VDI type '%s'" % \

1137 (type(self.target), self.vdi_type)

1138

1139 VDI_PLUG_TYPE = {'phy': 'phy', # for NETAPP

1140 'raw': 'phy',

1141 'aio': 'tap', # for LVM raw nodes

1142 'iso': 'tap', # for ISOSR

1143 'file': 'tap',

1144 'vhd': 'tap',

1145 'qcow2': 'tap'}

1146

1147 def tap_wanted(self):

1148 # 1. Let the target vdi_type decide

1149

1150 vdi_type = self.target.get_vdi_type()

1151

1152 try:

1153 plug_type = self.VDI_PLUG_TYPE[vdi_type]

1154 except KeyError:

1155 raise self.UnexpectedVDIType(vdi_type,

1156 self.target.vdi)

1157

1158 if plug_type == 'tap': 1158 ↛ 1159line 1158 didn't jump to line 1159, because the condition on line 1158 was never true

1159 return True

1160 elif self.target.vdi.sr.handles('udev'): 1160 ↛ 1166line 1160 didn't jump to line 1166, because the condition on line 1160 was never false

1161 return True

1162 # 2. Otherwise, there may be more reasons

1163 #

1164 # .. TBD

1165

1166 return False

1167

1168 class TargetDriver:

1169 """Safe target driver access."""

1170 # NB. *Must* test caps for optional calls. Some targets

1171 # actually implement some slots, but do not enable them. Just

1172 # try/except would risk breaking compatibility.

1173

1174 def __init__(self, vdi, driver_info):

1175 self.vdi = vdi

1176 self._caps = driver_info['capabilities']

1177

1178 def has_cap(self, cap):

1179 """Determine if target has given capability"""

1180 return cap in self._caps

1181

1182 def attach(self, sr_uuid, vdi_uuid):

1183 #assert self.has_cap("VDI_ATTACH")

1184 return self.vdi.attach(sr_uuid, vdi_uuid)

1185

1186 def detach(self, sr_uuid, vdi_uuid):

1187 #assert self.has_cap("VDI_DETACH")

1188 self.vdi.detach(sr_uuid, vdi_uuid)

1189

1190 def activate(self, sr_uuid, vdi_uuid):

1191 if self.has_cap("VDI_ACTIVATE"):

1192 return self.vdi.activate(sr_uuid, vdi_uuid)

1193

1194 def deactivate(self, sr_uuid, vdi_uuid):

1195 if self.has_cap("VDI_DEACTIVATE"):

1196 self.vdi.deactivate(sr_uuid, vdi_uuid)

1197 #def resize(self, sr_uuid, vdi_uuid, size):

1198 # return self.vdi.resize(sr_uuid, vdi_uuid, size)

1199

1200 def get_vdi_type(self):

1201 _type = self.vdi.vdi_type

1202 if not _type:

1203 raise VDI.UnexpectedVDIType(_type, self.vdi)

1204 return _type

1205

1206 def get_vdi_path(self):

1207 return self.vdi.path

1208

1209 class Link(object):

1210 """Relink a node under a common name"""

1211 # NB. We have to provide the device node path during

1212 # VDI.attach, but currently do not allocate the tapdisk minor

1213 # before VDI.activate. Therefore those link steps where we

1214 # relink existing devices under deterministic path names.

1215

1216 BASEDIR: ClassVar[str] = ""

1217

1218 def _mklink(self, target) -> None:

1219 pass

1220

1221 @abstractmethod

1222 def _equals(self, target) -> bool:

1223 pass

1224

1225 def __init__(self, path):

1226 self._path = path

1227

1228 @classmethod

1229 def from_name(cls, name):

1230 path = "%s/%s" % (cls.BASEDIR, name)

1231 return cls(path)

1232

1233 @classmethod

1234 def from_uuid(cls, sr_uuid, vdi_uuid):

1235 name = "%s/%s" % (sr_uuid, vdi_uuid)

1236 return cls.from_name(name)

1237

1238 def path(self):

1239 return self._path

1240

1241 def stat(self):

1242 return os.stat(self.path())

1243

1244 def mklink(self, target) -> None:

1245

1246 path = self.path()

1247 util.SMlog("%s -> %s" % (self, target))

1248

1249 mkdirs(os.path.dirname(path))

1250 try:

1251 self._mklink(target)

1252 except OSError as e:

1253 # We do unlink during teardown, but have to stay

1254 # idempotent. However, a *wrong* target should never

1255 # be seen.

1256 if e.errno != errno.EEXIST:

1257 raise

1258 assert self._equals(target), "'%s' not equal to '%s'" % (path, target)

1259

1260 def unlink(self):

1261 try:

1262 os.unlink(self.path())

1263 except OSError as e:

1264 if e.errno != errno.ENOENT:

1265 raise

1266

1267 @override

1268 def __str__(self) -> str:

1269 path = self.path()

1270 return "%s(%s)" % (self.__class__.__name__, path)

1271

1272 class SymLink(Link):

1273 """Symlink some file to a common name"""

1274

1275 def readlink(self):

1276 return os.readlink(self.path())

1277

1278 def symlink(self):

1279 return self.path()

1280

1281 @override

1282 def _mklink(self, target) -> None:

1283 os.symlink(target, self.path())

1284

1285 @override

1286 def _equals(self, target) -> bool:

1287 return self.readlink() == target

1288

1289 class DeviceNode(Link):

1290 """Relink a block device node to a common name"""

1291

1292 @classmethod

1293 def _real_stat(cls, target):

1294 """stat() not on @target, but its realpath()"""

1295 _target = os.path.realpath(target)

1296 return os.stat(_target)

1297

1298 @classmethod

1299 def is_block(cls, target):

1300 """Whether @target refers to a block device."""

1301 return S_ISBLK(cls._real_stat(target).st_mode)

1302

1303 @override

1304 def _mklink(self, target) -> None:

1305

1306 st = self._real_stat(target)

1307 if not S_ISBLK(st.st_mode):

1308 raise self.NotABlockDevice(target, st)

1309

1310 # set group read for disk group as well as root

1311 os.mknod(self.path(), st.st_mode | stat.S_IRGRP, st.st_rdev)

1312 os.chown(self.path(), st.st_uid, grp.getgrnam("disk").gr_gid)

1313

1314 @override

1315 def _equals(self, target) -> bool:

1316 target_rdev = self._real_stat(target).st_rdev

1317 return self.stat().st_rdev == target_rdev

1318

1319 def rdev(self):

1320 st = self.stat()

1321 assert S_ISBLK(st.st_mode)

1322 return os.major(st.st_rdev), os.minor(st.st_rdev)

1323

1324 class NotABlockDevice(Exception):

1325

1326 def __init__(self, path, st):

1327 self.path = path

1328 self.st = st

1329

1330 @override

1331 def __str__(self) -> str:

1332 return "%s is not a block device: %s" % (self.path, self.st)

1333

1334 class Hybrid(Link):

1335

1336 def __init__(self, path):

1337 VDI.Link.__init__(self, path)

1338 self._devnode = VDI.DeviceNode(path)

1339 self._symlink = VDI.SymLink(path)

1340

1341 def rdev(self):

1342 st = self.stat()

1343 if S_ISBLK(st.st_mode):

1344 return self._devnode.rdev()

1345 raise self._devnode.NotABlockDevice(self.path(), st)

1346

1347 @override

1348 def mklink(self, target) -> None:

1349 if self._devnode.is_block(target):

1350 self._obj = self._devnode

1351 else:

1352 self._obj = self._symlink

1353 self._obj.mklink(target)

1354

1355 @override

1356 def _equals(self, target) -> bool:

1357 return self._obj._equals(target)

1358

1359 class PhyLink(SymLink):

1360 BASEDIR = "/dev/sm/phy"

1361 # NB. Cannot use DeviceNodes, e.g. FileVDIs aren't bdevs.

1362

1363 class NBDLink(SymLink):

1364

1365 BASEDIR = "/run/blktap-control/nbd"

1366

1367 class BackendLink(Hybrid):

1368 BASEDIR = "/dev/sm/backend"

1369 # NB. Could be SymLinks as well, but saving major,minor pairs in

1370 # Links enables neat state capturing when managing Tapdisks. Note

1371 # that we essentially have a tap-ctl list replacement here. For

1372 # now make it a 'Hybrid'. Likely to collapse into a DeviceNode as

1373 # soon as ISOs are tapdisks.

1374

1375 @staticmethod

1376 def _tap_activate(phy_path, vdi_type, sr_uuid, options, pool_size=None):

1377

1378 tapdisk = Tapdisk.find_by_path(phy_path)

1379 if not tapdisk: 1379 ↛ 1380line 1379 didn't jump to line 1380, because the condition on line 1379 was never true

1380 blktap = Blktap.allocate()

1381 blktap.set_pool_name(sr_uuid)

1382 if pool_size:

1383 blktap.set_pool_size(pool_size)

1384

1385 try:

1386 tapdisk = \

1387 Tapdisk.launch_on_tap(blktap,

1388 phy_path,

1389 VDI._tap_type(vdi_type),

1390 options)

1391 except:

1392 blktap.free()

1393 raise

1394 util.SMlog("tap.activate: Launched %s" % tapdisk)

1395

1396 else:

1397 util.SMlog("tap.activate: Found %s" % tapdisk)

1398

1399 return tapdisk.get_devpath(), tapdisk

1400

1401 @staticmethod

1402 def _tap_deactivate(minor):

1403

1404 try:

1405 tapdisk = Tapdisk.from_minor(minor)

1406 except TapdiskNotRunning as e:

1407 util.SMlog("tap.deactivate: Warning, %s" % e)

1408 # NB. Should not be here unless the agent refcount

1409 # broke. Also, a clean shutdown should not have leaked

1410 # the recorded minor.

1411 else:

1412 tapdisk.shutdown()

1413 util.SMlog("tap.deactivate: Shut down %s" % tapdisk)

1414

1415 @classmethod

1416 def tap_pause(cls, session, sr_uuid, vdi_uuid, failfast=False):

1417 """

1418 Pauses the tapdisk.

1419

1420 session: a XAPI session

1421 sr_uuid: the UUID of the SR on which VDI lives

1422 vdi_uuid: the UUID of the VDI to pause

1423 failfast: controls whether the VDI lock should be acquired in a

1424 non-blocking manner

1425 """

1426 util.SMlog("Pause request for %s" % vdi_uuid)

1427 vdi_ref = session.xenapi.VDI.get_by_uuid(vdi_uuid)

1428 session.xenapi.VDI.add_to_sm_config(vdi_ref, 'paused', 'true')

1429 sm_config = session.xenapi.VDI.get_sm_config(vdi_ref)

1430 for key in [x for x in sm_config.keys() if x.startswith('host_')]: 1430 ↛ 1431line 1430 didn't jump to line 1431, because the loop on line 1430 never started

1431 host_ref = key[len('host_'):]

1432 util.SMlog("Calling tap-pause on host %s" % host_ref)

1433 if not cls.call_pluginhandler(session, host_ref,

1434 sr_uuid, vdi_uuid, "pause", failfast=failfast):

1435 # Failed to pause node

1436 session.xenapi.VDI.remove_from_sm_config(vdi_ref, 'paused')

1437 return False

1438 return True

1439

1440 @classmethod

1441 def tap_unpause(cls, session, sr_uuid, vdi_uuid, secondary=None,

1442 activate_parents=False):

1443 util.SMlog("Unpause request for %s secondary=%s" % (vdi_uuid, secondary))

1444 vdi_ref = session.xenapi.VDI.get_by_uuid(vdi_uuid)

1445 sm_config = session.xenapi.VDI.get_sm_config(vdi_ref)

1446 for key in [x for x in sm_config.keys() if x.startswith('host_')]: 1446 ↛ 1447line 1446 didn't jump to line 1447, because the loop on line 1446 never started

1447 host_ref = key[len('host_'):]

1448 util.SMlog("Calling tap-unpause on host %s" % host_ref)

1449 if not cls.call_pluginhandler(session, host_ref,

1450 sr_uuid, vdi_uuid, "unpause", secondary, activate_parents):

1451 # Failed to unpause node

1452 return False

1453 session.xenapi.VDI.remove_from_sm_config(vdi_ref, 'paused')

1454 return True

1455

1456 @classmethod

1457 def tap_refresh(cls, session, sr_uuid, vdi_uuid, activate_parents=False):

1458 util.SMlog("Refresh request for %s" % vdi_uuid)

1459 vdi_ref = session.xenapi.VDI.get_by_uuid(vdi_uuid)

1460 sm_config = session.xenapi.VDI.get_sm_config(vdi_ref)

1461 for key in [x for x in sm_config.keys() if x.startswith('host_')]:

1462 host_ref = key[len('host_'):]

1463 util.SMlog("Calling tap-refresh on host %s" % host_ref)

1464 if not cls.call_pluginhandler(session, host_ref,

1465 sr_uuid, vdi_uuid, "refresh", None,

1466 activate_parents=activate_parents):

1467 # Failed to refresh node

1468 return False

1469 return True

1470

1471 @classmethod

1472 def tap_status(cls, session, vdi_uuid):

1473 """Return True if disk is attached, false if it isn't"""

1474 util.SMlog("Disk status request for %s" % vdi_uuid)

1475 vdi_ref = session.xenapi.VDI.get_by_uuid(vdi_uuid)

1476 sm_config = session.xenapi.VDI.get_sm_config(vdi_ref)

1477 for key in [x for x in sm_config.keys() if x.startswith('host_')]: 1477 ↛ 1478line 1477 didn't jump to line 1478, because the loop on line 1477 never started

1478 return True

1479 return False

1480

1481 @classmethod

1482 def call_pluginhandler(cls, session, host_ref, sr_uuid, vdi_uuid, action,

1483 secondary=None, activate_parents=False, failfast=False):

1484 """Optionally, activate the parent LV before unpausing"""

1485 try:

1486 args = {"sr_uuid": sr_uuid, "vdi_uuid": vdi_uuid,

1487 "failfast": str(failfast)}

1488 if secondary:

1489 args["secondary"] = secondary

1490 if activate_parents:

1491 args["activate_parents"] = "true"

1492 ret = session.xenapi.host.call_plugin(

1493 host_ref, PLUGIN_TAP_PAUSE, action,

1494 args)

1495 return ret == "True"

1496 except Exception as e:

1497 util.logException("BLKTAP2:call_pluginhandler %s" % e)

1498 return False

1499

1500 def _add_tag(self, vdi_uuid, writable):

1501 util.SMlog("Adding tag to: %s" % vdi_uuid)

1502 attach_mode = "RO"

1503 if writable:

1504 attach_mode = "RW"

1505 vdi_ref = self._session.xenapi.VDI.get_by_uuid(vdi_uuid)

1506 host_ref = self._session.xenapi.host.get_by_uuid(util.get_this_host())

1507 sm_config = self._session.xenapi.VDI.get_sm_config(vdi_ref)

1508 attached_as = util.attached_as(sm_config)

1509 if NO_MULTIPLE_ATTACH and (attached_as == "RW" or \ 1509 ↛ 1511line 1509 didn't jump to line 1511, because the condition on line 1509 was never true

1510 (attached_as == "RO" and attach_mode == "RW")):

1511 util.SMlog("need to reset VDI %s" % vdi_uuid)

1512 if not resetvdis.reset_vdi(self._session, vdi_uuid, force=False,

1513 term_output=False, writable=writable):

1514 raise util.SMException("VDI %s not detached cleanly" % vdi_uuid)

1515 sm_config = self._session.xenapi.VDI.get_sm_config(vdi_ref)

1516 if 'relinking' in sm_config:

1517 util.SMlog("Relinking key found, back-off and retry" % sm_config)

1518 return False

1519 if 'paused' in sm_config:

1520 util.SMlog("Paused or host_ref key found [%s]" % sm_config)

1521 return False

1522 try:

1523 self._session.xenapi.VDI.add_to_sm_config(

1524 vdi_ref, 'activating', 'True')

1525 except XenAPI.Failure as e:

1526 if e.details[0] == 'MAP_DUPLICATE_KEY' and not writable:

1527 # Someone else is activating - a retry might succeed

1528 return False

1529 raise

1530 host_key = "host_%s" % host_ref

1531 assert host_key not in sm_config

1532 self._session.xenapi.VDI.add_to_sm_config(vdi_ref, host_key,

1533 attach_mode)

1534 sm_config = self._session.xenapi.VDI.get_sm_config(vdi_ref)

1535 if 'paused' in sm_config or 'relinking' in sm_config:

1536 util.SMlog("Found %s key, aborting" % (

1537 'paused' if 'paused' in sm_config else 'relinking'))

1538 self._session.xenapi.VDI.remove_from_sm_config(vdi_ref, host_key)

1539 self._session.xenapi.VDI.remove_from_sm_config(

1540 vdi_ref, 'activating')

1541 return False

1542 util.SMlog("Activate lock succeeded")

1543 return True

1544

1545 def _check_tag(self, vdi_uuid):

1546 vdi_ref = self._session.xenapi.VDI.get_by_uuid(vdi_uuid)

1547 sm_config = self._session.xenapi.VDI.get_sm_config(vdi_ref)

1548 if 'paused' in sm_config:

1549 util.SMlog("Paused key found [%s]" % sm_config)

1550 return False

1551 return True

1552

1553 def _remove_tag(self, vdi_uuid):

1554 vdi_ref = self._session.xenapi.VDI.get_by_uuid(vdi_uuid)

1555 host_ref = self._session.xenapi.host.get_by_uuid(util.get_this_host())

1556 sm_config = self._session.xenapi.VDI.get_sm_config(vdi_ref)

1557 host_key = "host_%s" % host_ref

1558 if host_key in sm_config:

1559 self._session.xenapi.VDI.remove_from_sm_config(vdi_ref, host_key)

1560 util.SMlog("Removed host key %s for %s" % (host_key, vdi_uuid))

1561 else:

1562 util.SMlog("_remove_tag: host key %s not found, ignore" % host_key)

1563

1564 def _get_pool_config(self, pool_name):

1565 pool_info = dict()

1566 vdi_ref = self.target.vdi.sr.srcmd.params.get('vdi_ref')

1567 if not vdi_ref: 1567 ↛ 1570line 1567 didn't jump to line 1570, because the condition on line 1567 was never true

1568 # attach_from_config context: HA disks don't need to be in any

1569 # special pool

1570 return pool_info

1571

1572 sr_ref = self.target.vdi.sr.srcmd.params.get('sr_ref')

1573 sr_config = self._session.xenapi.SR.get_other_config(sr_ref)

1574 vdi_config = self._session.xenapi.VDI.get_other_config(vdi_ref)

1575 pool_size_str = sr_config.get(POOL_SIZE_KEY)

1576 pool_name_override = vdi_config.get(POOL_NAME_KEY)

1577 if pool_name_override: 1577 ↛ 1582line 1577 didn't jump to line 1582, because the condition on line 1577 was never false

1578 pool_name = pool_name_override

1579 pool_size_override = vdi_config.get(POOL_SIZE_KEY)

1580 if pool_size_override: 1580 ↛ 1582line 1580 didn't jump to line 1582, because the condition on line 1580 was never false

1581 pool_size_str = pool_size_override

1582 pool_size = 0

1583 if pool_size_str: 1583 ↛ 1593line 1583 didn't jump to line 1593, because the condition on line 1583 was never false

1584 try:

1585 pool_size = int(pool_size_str)

1586 if pool_size < 1 or pool_size > MAX_FULL_RINGS: 1586 ↛ 1587line 1586 didn't jump to line 1587, because the condition on line 1586 was never true

1587 raise ValueError("outside of range")

1588 pool_size = NUM_PAGES_PER_RING * pool_size

1589 except ValueError:

1590 util.SMlog("Error: invalid mem-pool-size %s" % pool_size_str)

1591 pool_size = 0

1592

1593 pool_info["mem-pool"] = pool_name

1594 if pool_size: 1594 ↛ 1597line 1594 didn't jump to line 1597, because the condition on line 1594 was never false

1595 pool_info["mem-pool-size"] = str(pool_size)

1596

1597 return pool_info

1598

1599 def linkNBD(self, sr_uuid, vdi_uuid):

1600 if self.tap:

1601 nbd_path = '/run/blktap-control/nbd%d.%d' % (int(self.tap.pid),

1602 int(self.tap.minor))

1603 VDI.NBDLink.from_uuid(sr_uuid, vdi_uuid).mklink(nbd_path)

1604

1605 def attach(self, sr_uuid, vdi_uuid, writable, activate=False, caching_params={}):

1606 """Return/dev/sm/backend symlink path"""

1607 self.xenstore_data.update(self._get_pool_config(sr_uuid))

1608 if not self.target.has_cap("ATOMIC_PAUSE") or activate:

1609 util.SMlog("Attach & activate")

1610 self._attach(sr_uuid, vdi_uuid)

1611 dev_path = self._activate(sr_uuid, vdi_uuid,

1612 {"rdonly": not writable})

1613 self.BackendLink.from_uuid(sr_uuid, vdi_uuid).mklink(dev_path)

1614 self.linkNBD(sr_uuid, vdi_uuid)

1615

1616 # Return backend/ link

1617 back_path = self.BackendLink.from_uuid(sr_uuid, vdi_uuid).path()

1618 if self.tap_wanted():

1619 # Only have NBD if we also have a tap

1620 nbd_path = "nbd:unix:{}:exportname={}".format(

1621 VDI.NBDLink.from_uuid(sr_uuid, vdi_uuid).path(),

1622 vdi_uuid)

1623 else:

1624 nbd_path = ""

1625

1626 options = {"rdonly": not writable}

1627 options.update(caching_params)

1628 o_direct, o_direct_reason = self.get_o_direct_capability(options)

1629 struct = {'params': back_path,

1630 'params_nbd': nbd_path,

1631 'o_direct': o_direct,

1632 'o_direct_reason': o_direct_reason,

1633 'xenstore_data': self.xenstore_data}

1634 util.SMlog('result: %s' % struct)

1635

1636 try:

1637 f = open("%s.attach_info" % back_path, 'a')

1638 f.write(xmlrpc.client.dumps((struct, ), "", True))

1639 f.close()

1640 except:

1641 pass

1642

1643 return xmlrpc.client.dumps((struct, ), "", True)

1644

1645 def activate(self, sr_uuid, vdi_uuid, writable, caching_params):

1646 util.SMlog("blktap2.activate")

1647 options = {"rdonly": not writable}

1648 options.update(caching_params)

1649

1650 sr_ref = self.target.vdi.sr.srcmd.params.get('sr_ref')

1651 sr_other_config = self._session.xenapi.SR.get_other_config(sr_ref)

1652 for i in range(self.ATTACH_DETACH_RETRY_SECS): 1652 ↛ 1659line 1652 didn't jump to line 1659, because the loop on line 1652 didn't complete

1653 try:

1654 if self._activate_locked(sr_uuid, vdi_uuid, options):

1655 return

1656 except util.SRBusyException:

1657 util.SMlog("SR locked, retrying")

1658 time.sleep(1)

1659 raise util.SMException("VDI %s locked" % vdi_uuid)

1660

1661 def _get_sr_master_host_ref(self) -> str:

1662 """

1663 Give the host ref of the one responsible for Garbage Collection for a SR.

1664 Meaning this host for a local SR, the master for a shared SR.

1665 """

1666 sr = self.target.vdi.sr

1667 if sr.is_shared():

1668 host_ref = util.get_master_ref(self._session)

1669 else:

1670 host_ref = sr.host_ref

1671 return host_ref

1672

1673 def _get_vdi_chain(self, cowutil, extractUuid) -> List[str]:

1674 vdi_chain = []

1675 path = self.target.get_vdi_path()

1676

1677 #TODO: Need to add handling of error for getParentNoCheck, e.g. corrupted VDI where we can't read parent

1678 vdi_chain.append(extractUuid(path))

1679 parent = cowutil.getParentNoCheck(path)

1680 while parent:

1681 vdi_chain.append(extractUuid(parent))

1682 parent = cowutil.getParentNoCheck(parent)

1683 vdi_chain.reverse()

1684 return vdi_chain

1685

1686 def _check_journal_coalesce_chain(self, sr_uuid: str, vdi_uuid: str) -> bool:

1687 vdi_type = self.target.get_vdi_type()

1688 cowutil = getCowUtil(vdi_type)

1689

1690 if not cowutil.isCoalesceableOnRemote(): #We only need to stop the coalesce in case of QCOW2 1690 ↛ 1693line 1690 didn't jump to line 1693, because the condition on line 1690 was never false

1691 return True

1692

1693 path = self.target.get_vdi_path()

1694

1695 import fjournaler

1696 import journaler

1697 from lvmcowutil import LvmCowUtil

1698 from FileSR import FileVDI

1699 import lvmcache

1700

1701 journal: Union[journaler.Journaler, fjournaler.Journaler]

1702 # Different extractUUID & journaler function for LVMSR and FileSR

1703 if path.startswith("/dev/"): #TODO: How to identify SR type easily, we could ask XAPI since we have the sruuid (and even ref)

1704 vgName = "VG_XenStorage-{}".format(sr_uuid)

1705 lvmCache = lvmcache.LVMCache(vgName)

1706 journal = journaler.Journaler(lvmCache)

1707

1708 extractUuid = LvmCowUtil.extractUuid

1709 else:

1710 journal = fjournaler.Journaler(os.getcwd())

1711 extractUuid = FileVDI.extractUuid

1712

1713 # Get the VDI chain

1714 vdi_chain = self._get_vdi_chain(cowutil, extractUuid)

1715

1716 if len(vdi_chain) == 1:

1717 # We only have a leaf, do nothing

1718 util.SMlog("VDI {} is only a leaf, continuing...".format(vdi_uuid))

1719 return True

1720

1721 # Log the chain of active VDI

1722 level = 0

1723 util.SMlog("VDI chain:")

1724 for vdi in vdi_chain:

1725 prefix = " " * level

1726 level += 1

1727 util.SMlog("{}{}".format(prefix, vdi))

1728

1729 vdi_to_cancel = []

1730 for entry in journal.getAll("coalesce").keys():

1731 if entry in vdi_chain:

1732 vdi_to_cancel.append(entry)

1733 util.SMlog("Coalescing VDI {} in chain".format(entry))

1734

1735 # Get the host_ref from the host doing the GC work

1736 host_ref = self._get_sr_master_host_ref()

1737 for vdi in vdi_to_cancel:

1738 args = {"sr_uuid": sr_uuid, "vdi_uuid": vdi}

1739 util.SMlog("Calling cancel_coalesce_master with args: {}".format(args))

1740 self._session.xenapi.host.call_plugin(\

1741 host_ref, PLUGIN_ON_SLAVE, "cancel_coalesce_master", args)

1742

1743 return True

1744

1745 @locking("VDIUnavailable")

1746 def _activate_locked(self, sr_uuid, vdi_uuid, options):

1747 """Wraps target.activate and adds a tapdisk"""

1748

1749 #util.SMlog("VDI.activate %s" % vdi_uuid)

1750 refresh = False

1751 if self.tap_wanted(): 1751 ↛ 1756line 1751 didn't jump to line 1756, because the condition on line 1751 was never false

1752 if not self._add_tag(vdi_uuid, not options["rdonly"]):

1753 return False

1754 refresh = True

1755

1756 try:

1757 if refresh: 1757 ↛ 1768line 1757 didn't jump to line 1768, because the condition on line 1757 was never false

1758 # it is possible that while the VDI was paused some of its

1759 # attributes have changed (e.g. its size if it was inflated; or its

1760 # path if it was leaf-coalesced onto a raw LV), so refresh the

1761 # object completely

1762 params = self.target.vdi.sr.srcmd.params

1763 target = sm.VDI.from_uuid(self.target.vdi.session, vdi_uuid)

1764 target.sr.srcmd.params = params

1765 driver_info = target.sr.srcmd.driver_info

1766 self.target = self.TargetDriver(target, driver_info)

1767

1768 util.fistpoint.activate_custom_fn( 1768 ↛ exitline 1768 didn't jump to the function exit

1769 "blktap_activate_inject_failure",

1770 lambda: util.inject_failure())

1771

1772 # Attach the physical node

1773 if self.target.has_cap("ATOMIC_PAUSE"): 1773 ↛ 1776line 1773 didn't jump to line 1776, because the condition on line 1773 was never false

1774 self._attach(sr_uuid, vdi_uuid)

1775

1776 vdi_type = self.target.get_vdi_type()

1777

1778

1779 # Take lvchange-p Lock before running

1780 # tap-ctl open

1781 # Needed to avoid race with lvchange -p which is

1782 # now taking the same lock

1783 # This is a fix for CA-155766

1784 if hasattr(self.target.vdi.sr, 'DRIVER_TYPE') and \ 1784 ↛ 1787line 1784 didn't jump to line 1787, because the condition on line 1784 was never true

1785 self.target.vdi.sr.DRIVER_TYPE == 'lvhd' and \

1786 VdiType.isCowImage(vdi_type):

1787 lock = Lock("lvchange-p", NS_PREFIX_LVM + sr_uuid)

1788 lock.acquire()

1789

1790 if not self._check_journal_coalesce_chain(sr_uuid, vdi_uuid): 1790 ↛ 1791line 1790 didn't jump to line 1791, because the condition on line 1790 was never true

1791 return False

1792 # we could return false from here if we need to retry after relink

1793 # #TODO: handling error here

1794

1795 # When we attach a static VDI for HA, we cannot communicate with

1796 # xapi, because has not started yet. These VDIs are raw.

1797 if VdiType.isCowImage(vdi_type): 1797 ↛ 1798line 1797 didn't jump to line 1798, because the condition on line 1797 was never true

1798 session = self.target.vdi.session

1799 vdi_ref = session.xenapi.VDI.get_by_uuid(vdi_uuid)

1800 # pylint: disable=used-before-assignment

1801 sm_config = session.xenapi.VDI.get_sm_config(vdi_ref)

1802 if 'key_hash' in sm_config:

1803 key_hash = sm_config['key_hash']

1804 options['key_hash'] = key_hash

1805 options['vdi_uuid'] = vdi_uuid

1806 util.SMlog('Using key with hash {} for VDI {}'.format(key_hash, vdi_uuid))

1807 # Activate the physical node

1808 dev_path = self._activate(sr_uuid, vdi_uuid, options)

1809

1810 if hasattr(self.target.vdi.sr, 'DRIVER_TYPE') and \ 1810 ↛ 1813line 1810 didn't jump to line 1813, because the condition on line 1810 was never true

1811 self.target.vdi.sr.DRIVER_TYPE == 'lvhd' and \

1812 VdiType.isCowImage(self.target.get_vdi_type()):

1813 lock.release()

1814 except:

1815 util.SMlog("Exception in activate/attach")

1816 if self.tap_wanted():

1817 util.fistpoint.activate_custom_fn(

1818 "blktap_activate_error_handling",

1819 lambda: time.sleep(30))

1820 while True:

1821 try:

1822 self._remove_tag(vdi_uuid)

1823 break

1824 except xmlrpc.client.ProtocolError as e:

1825 # If there's a connection error, keep trying forever.

1826 if e.errcode == http.HTTPStatus.INTERNAL_SERVER_ERROR.value:

1827 continue

1828 else:

1829 util.SMlog('failed to remove tag: %s' % e)

1830 break

1831 except Exception as e:

1832 util.SMlog('failed to remove tag: %s' % e)

1833 break

1834 raise

1835 finally:

1836 vdi_ref = self._session.xenapi.VDI.get_by_uuid(vdi_uuid)

1837 self._session.xenapi.VDI.remove_from_sm_config(

1838 vdi_ref, 'activating')

1839 util.SMlog("Removed activating flag from %s" % vdi_uuid) 1839 ↛ exitline 1839 didn't except from function '_activate_locked', because the raise on line 1834 wasn't executed or line 1839 didn't return from function '_activate_locked', because the return on line 1791 wasn't executed

1840

1841 # Link result to backend/

1842 self.BackendLink.from_uuid(sr_uuid, vdi_uuid).mklink(dev_path)

1843 self.linkNBD(sr_uuid, vdi_uuid)

1844 return True

1845

1846 def _activate(self, sr_uuid, vdi_uuid, options):

1847 vdi_options = self.target.activate(sr_uuid, vdi_uuid)

1848

1849 dev_path = self.setup_cache(sr_uuid, vdi_uuid, options)

1850 if not dev_path: 1850 ↛ 1864line 1850 didn't jump to line 1864, because the condition on line 1850 was never false

1851 phy_path = self.PhyLink.from_uuid(sr_uuid, vdi_uuid).readlink()

1852 # Maybe launch a tapdisk on the physical link

1853 if self.tap_wanted(): 1853 ↛ 1862line 1853 didn't jump to line 1862, because the condition on line 1853 was never false

1854 vdi_type = self.target.get_vdi_type()

1855 options["o_direct"] = self.get_o_direct_capability(options)[0]

1856 if vdi_options: 1856 ↛ 1858line 1856 didn't jump to line 1858, because the condition on line 1856 was never false

1857 options.update(vdi_options)

1858 dev_path, self.tap = self._tap_activate(phy_path, vdi_type,

1859 sr_uuid, options,

1860 self._get_pool_config(sr_uuid).get("mem-pool-size"))

1861 else:

1862 dev_path = phy_path # Just reuse phy

1863

1864 return dev_path

1865

1866 def _attach(self, sr_uuid, vdi_uuid):

1867 attach_info = xmlrpc.client.loads(self.target.attach(sr_uuid, vdi_uuid))[0][0]

1868 params = attach_info['params']

1869 xenstore_data = attach_info['xenstore_data']

1870 phy_path = util.to_plain_string(params)

1871 self.xenstore_data.update(xenstore_data)

1872 # Save it to phy/

1873 self.PhyLink.from_uuid(sr_uuid, vdi_uuid).mklink(phy_path)

1874

1875 def deactivate(self, sr_uuid, vdi_uuid, caching_params):

1876 util.SMlog("blktap2.deactivate")

1877 for i in range(self.ATTACH_DETACH_RETRY_SECS):

1878 try:

1879 if self._deactivate_locked(sr_uuid, vdi_uuid, caching_params):

1880 return

1881 except util.SRBusyException as e:

1882 util.SMlog("SR locked, retrying")

1883 time.sleep(1)

1884 raise util.SMException("VDI %s locked" % vdi_uuid)

1885

1886 @locking("VDIUnavailable")

1887 def _deactivate_locked(self, sr_uuid, vdi_uuid, caching_params):

1888 """Wraps target.deactivate and removes a tapdisk"""

1889

1890 #util.SMlog("VDI.deactivate %s" % vdi_uuid)

1891 if self.tap_wanted() and not self._check_tag(vdi_uuid):

1892 return False

1893

1894 self._deactivate(sr_uuid, vdi_uuid, caching_params)

1895 if self.target.has_cap("ATOMIC_PAUSE"):

1896 self._detach(sr_uuid, vdi_uuid)

1897 if self.tap_wanted():

1898 self._remove_tag(vdi_uuid)

1899

1900 return True

1901

1902 def _resetPhylink(self, sr_uuid, vdi_uuid, path):

1903 self.PhyLink.from_uuid(sr_uuid, vdi_uuid).mklink(path)

1904

1905 def detach(self, sr_uuid, vdi_uuid, deactivate=False, caching_params={}):

1906 if not self.target.has_cap("ATOMIC_PAUSE") or deactivate:

1907 util.SMlog("Deactivate & detach")

1908 self._deactivate(sr_uuid, vdi_uuid, caching_params)

1909 self._detach(sr_uuid, vdi_uuid)

1910 else:

1911 pass # nothing to do

1912

1913 def _deactivate(self, sr_uuid, vdi_uuid, caching_params):

1914 import VDI as sm

1915

1916 # Shutdown tapdisk

1917 back_link = self.BackendLink.from_uuid(sr_uuid, vdi_uuid)

1918

1919 if not util.pathexists(back_link.path()):

1920 util.SMlog("Backend path %s does not exist" % back_link.path())

1921 return

1922

1923 try:

1924 attach_info_path = "%s.attach_info" % (back_link.path())

1925 os.unlink(attach_info_path)

1926 except:

1927 util.SMlog("unlink of attach_info failed")

1928

1929 try:

1930 major, minor = back_link.rdev()

1931 except self.DeviceNode.NotABlockDevice:

1932 pass

1933 else:

1934 if major == Tapdisk.major():

1935 self._tap_deactivate(minor)

1936 self.remove_cache(sr_uuid, vdi_uuid, caching_params)

1937

1938 # Remove the backend link

1939 back_link.unlink()

1940 VDI.NBDLink.from_uuid(sr_uuid, vdi_uuid).unlink()

1941

1942 # Deactivate & detach the physical node

1943 if self.tap_wanted() and self.target.vdi.session is not None:

1944 # it is possible that while the VDI was paused some of its

1945 # attributes have changed (e.g. its size if it was inflated; or its

1946 # path if it was leaf-coalesced onto a raw LV), so refresh the

1947 # object completely

1948 target = sm.VDI.from_uuid(self.target.vdi.session, vdi_uuid)

1949 driver_info = target.sr.srcmd.driver_info

1950 self.target = self.TargetDriver(target, driver_info)

1951

1952 self.target.deactivate(sr_uuid, vdi_uuid)

1953

1954 def _detach(self, sr_uuid, vdi_uuid):

1955 self.target.detach(sr_uuid, vdi_uuid)

1956

1957 # Remove phy/

1958 self.PhyLink.from_uuid(sr_uuid, vdi_uuid).unlink()

1959

1960 def _updateCacheRecord(self, session, vdi_uuid, on_boot, caching):

1961 # Remove existing VDI.sm_config fields

1962 vdi_ref = session.xenapi.VDI.get_by_uuid(vdi_uuid)

1963 for key in ["on_boot", "caching"]:

1964 session.xenapi.VDI.remove_from_sm_config(vdi_ref, key)

1965 if not on_boot is None:

1966 session.xenapi.VDI.add_to_sm_config(vdi_ref, 'on_boot', on_boot)

1967 if not caching is None:

1968 session.xenapi.VDI.add_to_sm_config(vdi_ref, 'caching', caching)

1969

1970 def setup_cache(self, sr_uuid, vdi_uuid, params):

1971 if params.get(self.CONF_KEY_ALLOW_CACHING) != "true": 1971 ↛ 1974line 1971 didn't jump to line 1974, because the condition on line 1971 was never false