def waitForBackend(self, devid): frontpath = self.frontendPath(devid) # lookup a phantom phantomPath = xstransact.Read(frontpath, 'phantom_vbd') if phantomPath is not None: log.debug("Waiting for %s's phantom %s.", devid, phantomPath) statusPath = phantomPath + '/' + HOTPLUG_STATUS_NODE ev = Event() result = {'status': Timeout} xswatch(statusPath, hotplugStatusCallback, ev, result) ev.wait(DEVICE_CREATE_TIMEOUT) err = xstransact.Read(statusPath, HOTPLUG_ERROR_NODE) if result['status'] != Connected: return (result['status'], err) backpath = self.readVm(devid, "backend") if backpath: statusPath = backpath + '/' + HOTPLUG_STATUS_NODE ev = Event() result = {'status': Timeout} xswatch(statusPath, hotplugStatusCallback, ev, result) ev.wait(DEVICE_CREATE_TIMEOUT) err = xstransact.Read(backpath, HOTPLUG_ERROR_NODE) return (result['status'], err) else: return (Missing, None)
def waitForBackend(self, devid): frontpath = self.frontendPath(devid) # lookup a phantom phantomPath = xstransact.Read(frontpath, 'phantom_vbd') if phantomPath is not None: log.debug("Waiting for %s's phantom %s.", devid, phantomPath) statusPath = phantomPath + '/' + HOTPLUG_STATUS_NODE ev = Event() result = { 'status': Timeout } xswatch(statusPath, hotplugStatusCallback, ev, result) ev.wait(DEVICE_CREATE_TIMEOUT) err = xstransact.Read(statusPath, HOTPLUG_ERROR_NODE) if result['status'] != 'Connected': return (result['status'], err) backpath = xstransact.Read(frontpath, "backend") if backpath: statusPath = backpath + '/' + HOTPLUG_STATUS_NODE ev = Event() result = { 'status': Timeout } xswatch(statusPath, hotplugStatusCallback, ev, result) ev.wait(DEVICE_CREATE_TIMEOUT) err = xstransact.Read(backpath, HOTPLUG_ERROR_NODE) return (result['status'], err) else: return (Missing, None)
def waitForBackend_destroy(self, backpath): statusPath = backpath + '/' + HOTPLUG_STATUS_NODE ev = Event() result = {'status': Timeout} xswatch(statusPath, deviceDestroyCallback, ev, result) ev.wait(DEVICE_DESTROY_TIMEOUT) return result['status']
def waitForBackend_destroy(self, backpath): statusPath = backpath + '/' + HOTPLUG_STATUS_NODE ev = Event() result = { 'status': Timeout } xswatch(statusPath, deviceDestroyCallback, ev, result) ev.wait(DEVICE_DESTROY_TIMEOUT) return result['status']
def waitForBackend_reconfigure(self, devid): frontpath = self.frontendPath(devid) backpath = xstransact.Read(frontpath, "backend") if backpath: statusPath = backpath + '/' + "state" ev = Event() result = { 'status': Timeout } xswatch(statusPath, xenbusStatusCallback, ev, result) ev.wait(DEVICE_CREATE_TIMEOUT) return (result['status'], None) else: return (Missing, None)
def waitForBackend_reconfigure(self, devid): frontpath = self.frontendPath(devid) backpath = xstransact.Read(frontpath, "backend") if backpath: statusPath = backpath + '/' + "state" ev = Event() result = {'status': Timeout} xswatch(statusPath, xenbusStatusCallback, ev, result) ev.wait(DEVICE_CREATE_TIMEOUT) return (result['status'], None) else: return (Missing, None)
def waitForBackend_destroy(self, backpath): statusPath = backpath + '/' + HOTPLUG_STATUS_NODE ev = Event() result = {'status': Timeout} xswatch(statusPath, deviceDestroyCallback, ev, result) for i in range(1, 50): ev.wait(DEVICE_DESTROY_TIMEOUT / 50) status = xstransact.Read(statusPath) if status is None: result['status'] = Disconnected break return result['status']
def waitForBackend_destroy(self, backpath): statusPath = backpath + '/' + HOTPLUG_STATUS_NODE ev = Event() result = { 'status': Timeout } xswatch(statusPath, deviceDestroyCallback, ev, result) for i in range(1, 50): ev.wait(DEVICE_DESTROY_TIMEOUT/50) status = xstransact.Read(statusPath) if status is None: result['status'] = Disconnected break return result['status']
def stress(): xstransact.Remove(PATH) xstransact.Mkdir(PATH) xswatch(PATH, watch_callback) def do(f): t = threading.Thread(target=stress_write) t.setDaemon(True) t.start() do(stress_write) do(stress_get_domain_path) do(stress_get_domain_path_xsutil) do(stress_open_close) while True: # Wait for Ctrl-C. time.sleep(100000000)
def setupDevice(self, config): """Setup devices from config """ pci_dev_list = config.get('devs', []) for d in pci_dev_list: self.setupOneDevice(d) wPath = '/local/domain/0/backend/pci/%u/0/aerState' % (self.getDomid()) self.aerStateWatch = xswatch(wPath, self._handleAerStateWatch) log.debug('pci: register aer watch %s', wPath) return
def waitForBackend(self, devid): # FIXME!!! We haven't udev daemon... #result = { 'status': Connected } #return result['status'] frontpath = self.frontendPath(devid) backpath = xstransact.Read(frontpath, "backend") if backpath: statusPath = backpath + '/' + HOTPLUG_STATUS_NODE ev = Event() result = { 'status': Timeout } xswatch(statusPath, hotplugStatusCallback, ev, result) ev.wait(DEVICE_CREATE_TIMEOUT) return result['status'] else: return Missing
def __init__(self, receive_prefix = "data/host", send_prefix = "data/guest", data_prefix = "vm-data", *args, **kwargs): # pylint: disable=C0301 """Initialize a communication "bus" with the Xen Hypervisor. ### Description Sets up watches on paths we'll be receiving data on in xenstore and initializes pathing information used elsewhere. """ super(XenCommunicator, self).__init__(*args, **kwargs) self._receive_prefix = receive_prefix self._send_prefix = send_prefix self._network_prefix = data_prefix + "/networking" self._hostname_prefix = data_prefix + "/hostname" self._queue = Queue.Queue() self.xs = xs.xshandle() # pylint: disable=C0103 def xs_watch(path): logger.info("Received a watch even on %s", path) if path in [ self._receive_prefix, data_prefix ]: return True transaction = self.xs.transaction_start() message = self.xs.read(transaction, path) self.xs.transaction_end(transaction) logger.info("Received message, %s", message) self._queue.put((path, message)) transaction = self.xs.transaction_start() message = self.xs.rm(transaction, path) self.xs.transaction_end(transaction) return True self.watches = [] self.watches.append(xswatch(self._receive_prefix, xs_watch)) transaction = self.xs.transaction_start() entries = self.xs.ls(transaction, self._receive_prefix) self.xs.transaction_end(transaction) logger.debug("Missed messages: %s", entries) if entries is not None: for path in [ self._receive_prefix + "/" + entry for entry in entries ]: # pylint: disable=C0301 xs_watch(path)
def init(self): xstransact.Mkdir(VMROOT) xstransact.SetPermissions(VMROOT, { 'dom' : PRIV_DOMAIN }) self.domains_lock.acquire() try: self._add_domain( XendDomainInfo.recreate(self.xen_domains()[PRIV_DOMAIN], True)) self.dom0_setup() # This watch registration needs to be before the refresh call, so # that we're sure that we haven't missed any releases, but inside # the domains_lock, as we don't want the watch to fire until after # the refresh call has completed. xswatch("@introduceDomain", self.onChangeDomain) xswatch("@releaseDomain", self.onChangeDomain) self.refresh(True) finally: self.domains_lock.release()
def waitForFrontend(self, devid): def frontendStatusCallback(statusPath, ev, result): status = xstransact.Read(statusPath) log.debug("frontendStatusCallback %s = %s" % (statusPath, status)) try: status = int(status) if status == xenbusState['Connected']: result['status'] = Connected elif status == xenbusState['Closed']: result['status'] = Error else: raise except: return 1 ev.set() return 0 frontpath = self.frontendPath(devid) statusPath = frontpath + '/state' ev = Event() result = { 'status': Timeout } xswatch(statusPath, frontendStatusCallback, ev, result) ev.wait(5) return result['status']
def waitForFrontend(self, devid): def frontendStatusCallback(statusPath, ev, result): status = xstransact.Read(statusPath) log.debug("frontendStatusCallback %s = %s" % (statusPath, status)) try: status = int(status) if status == xenbusState['Connected']: result['status'] = Connected elif status == xenbusState['Closed']: result['status'] = Error else: raise except: return 1 ev.set() return 0 frontpath = self.frontendPath(devid) statusPath = frontpath + '/state' ev = Event() result = {'status': Timeout} xswatch(statusPath, frontendStatusCallback, ev, result) ev.wait(5) return result['status']
def register_shutdown_watch(self): """ add xen store watch on control/shutdown """ self.shutdownWatch = xswatch(self.vm.dompath + "/control/shutdown", \ self.hvm_shutdown) log.debug("hvm shutdown watch registered")
devs_str = dev.find_coassigned_pci_devices(True) # Remove the element 0 which is a bridge del devs_str[0] dev.devs_check_driver(devs_str) for s in devs_str: if not s in pci_str_list: s_pci_str = pci_dict_to_bdf_str(parse_pci_name(s)) # s has been assigned to other guest? if xc.test_assign_device(0, s_pci_str) != 0: err_msg = 'pci: %s must be co-assigned to the'+\ ' same guest with %s' raise VmError(err_msg % (s, dev.name)) wPath = '/local/domain/0/backend/pci/%u/0/aerState' % (self.getDomid()) self.aerStateWatch = xswatch(wPath, self._handleAerStateWatch) log.debug('pci: register aer watch %s', wPath) return def _handleAerStateWatch(self, _): log.debug('XendDomainInfo.handleAerStateWatch') if self.getDomid() == 0: raise XendError('Domain 0 cannot be shutdown') readPath = '/local/domain/0/backend/pci/%u/0/aerState' % (self.getDomid()) action = xstransact.Read(readPath) if action and action=='aerfail': log.debug('shutdown domain because of aer handle error') self.vm.shutdown('poweroff') return True