Qubes/core-admin
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

qmemman: reformat code, especially comments

Browse Source 
Indent comments to match code indentation to make it readable. Also,
wrap long lines. Fix few typos in comments.

No functional change.
This commit is contained in:
Marek Marczykowski-Górecki 2018-01-06 15:12:48 +01:00
parent a66c9afb18
commit 8e288d9f81
No known key found for this signature in database
GPG Key ID: 063938BA42CFA724
2 changed files with 151 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
qubes/qmemman/__init__.py
View File

@ -45,7 +45,8 @@ class DomainState:
self.id = id # domain id self.id = id # domain id
self.last_target = 0 # the last memset target self.last_target = 0 # the last memset target
self.no_progress = False # no react to memset self.no_progress = False # no react to memset
self.slow_memset_react = False #slow react to memset (after few tries still above target) self.slow_memset_react = False # slow react to memset (after few
# tries still above target)
def __repr__(self): def __repr__(self):
return self.__dict__.__repr__() return self.__dict__.__repr__()
@ -61,9 +62,11 @@ class SystemState(object):
self.BALOON_DELAY = 0.1 self.BALOON_DELAY = 0.1
self.XEN_FREE_MEM_LEFT = 50*1024*1024 self.XEN_FREE_MEM_LEFT = 50*1024*1024
self.XEN_FREE_MEM_MIN = 25*1024*1024 self.XEN_FREE_MEM_MIN = 25*1024*1024
# Overhead of per-page Xen structures, taken from OpenStack nova/virt/xenapi/driver.py # Overhead of per-page Xen structures, taken from OpenStack
# nova/virt/xenapi/driver.py
# see https://wiki.openstack.org/wiki/XenServer/Overhead # see https://wiki.openstack.org/wiki/XenServer/Overhead
# we divide total and free physical memory by this to get "assignable" memory # we divide total and free physical memory by this to get
# "assignable" memory
self.MEM_OVERHEAD_FACTOR = 1.0 / 1.00781 self.MEM_OVERHEAD_FACTOR = 1.0 / 1.00781
try: try:
self.ALL_PHYS_MEM = int(self.xc.physinfo()['total_memory']*1024 * self.MEM_OVERHEAD_FACTOR) self.ALL_PHYS_MEM = int(self.xc.physinfo()['total_memory']*1024 * self.MEM_OVERHEAD_FACTOR)
@ -126,17 +129,20 @@ class SystemState(object):
else: else:
self.domdict[id].memory_maximum = self.ALL_PHYS_MEM self.domdict[id].memory_maximum = self.ALL_PHYS_MEM
# the previous line used to be # the previous line used to be
# self.domdict[id].memory_maximum = domain['maxmem_kb']*1024 # self.domdict[id].memory_maximum = domain[
# but domain['maxmem_kb'] changes in self.mem_set as well, and this results in # 'maxmem_kb']*1024
# the memory never increasing # but domain['maxmem_kb'] changes in self.mem_set as well,
# in fact, the only possible case of nonexisting memory/static-max is dom0 # and this results in the memory never increasing
# in fact, the only possible case of nonexisting
# memory/static-max is dom0
# see #307 # see #307
def clear_outdated_error_markers(self): def clear_outdated_error_markers(self):
# Clear outdated errors # Clear outdated errors
for i in self.domdict.keys(): for i in self.domdict.keys():
if self.domdict[i].slow_memset_react and \ if self.domdict[i].slow_memset_react and \
self.domdict[i].memory_actual <= self.domdict[i].last_target + self.XEN_FREE_MEM_LEFT/4: self.domdict[i].memory_actual <= \
self.domdict[i].last_target + self.XEN_FREE_MEM_LEFT/4:
dom_name = self.xs.read('', '/local/domain/%s/name' % str(i)) dom_name = self.xs.read('', '/local/domain/%s/name' % str(i))
if dom_name is not None: if dom_name is not None:
# TODO: report it somewhere, qubesd or elsewhere # TODO: report it somewhere, qubesd or elsewhere
@ -144,14 +150,16 @@ class SystemState(object):
self.domdict[i].slow_memset_react = False self.domdict[i].slow_memset_react = False
if self.domdict[i].no_progress and \ if self.domdict[i].no_progress and \
self.domdict[i].memory_actual <= self.domdict[i].last_target + self.XEN_FREE_MEM_LEFT/4: self.domdict[i].memory_actual <= \
self.domdict[i].last_target + self.XEN_FREE_MEM_LEFT/4:
dom_name = self.xs.read('', '/local/domain/%s/name' % str(i)) dom_name = self.xs.read('', '/local/domain/%s/name' % str(i))
if dom_name is not None: if dom_name is not None:
# TODO: report it somewhere, qubesd or elsewhere # TODO: report it somewhere, qubesd or elsewhere
pass pass
self.domdict[i].no_progress = False self.domdict[i].no_progress = False
#the below works (and is fast), but then 'xm list' shows unchanged memory value # the below works (and is fast), but then 'xm list' shows unchanged
# memory value
def mem_set(self, id, val): def mem_set(self, id, val):
self.log.info('mem-set domain {} to {}'.format(id, val)) self.log.info('mem-set domain {} to {}'.format(id, val))
self.domdict[id].last_target = val self.domdict[id].last_target = val
@ -175,7 +183,8 @@ class SystemState(object):
'Preventing balloon up to {}'.format(dom.last_target)) 'Preventing balloon up to {}'.format(dom.last_target))
self.mem_set(i, dom.memory_actual) self.mem_set(i, dom.memory_actual)
#perform memory ballooning, across all domains, to add "memsize" to Xen free memory # perform memory ballooning, across all domains, to add "memsize" to Xen
# free memory
def do_balloon(self, memsize): def do_balloon(self, memsize):
self.log.info('do_balloon(memsize={!r})'.format(memsize)) self.log.info('do_balloon(memsize={!r})'.format(memsize))
CHECK_PERIOD_S = 3 CHECK_PERIOD_S = 3
@ -213,7 +222,8 @@ class SystemState(object):
if prev_memory_actual is not None: if prev_memory_actual is not None:
for i in prev_memory_actual.keys(): for i in prev_memory_actual.keys():
if prev_memory_actual[i] == self.domdict[i].memory_actual: if prev_memory_actual[i] == self.domdict[i].memory_actual:
#domain not responding to memset requests, remove it from donors # domain not responding to memset requests, remove it
# from donors
self.domdict[i].no_progress = True self.domdict[i].no_progress = True
self.log.info('domain {} stuck at {}'.format(i, self.domdict[i].memory_actual)) self.log.info('domain {} stuck at {}'.format(i, self.domdict[i].memory_actual))
memset_reqs = qubes.qmemman.algo.balloon(memsize + self.XEN_FREE_MEM_LEFT - xenfree, self.domdict) memset_reqs = qubes.qmemman.algo.balloon(memsize + self.XEN_FREE_MEM_LEFT - xenfree, self.domdict)
@ -261,7 +271,8 @@ class SystemState(object):
total_memory_transfer += abs(memory_change) total_memory_transfer += abs(memory_change)
pref = qubes.qmemman.algo.prefmem(self.domdict[dom]) pref = qubes.qmemman.algo.prefmem(self.domdict[dom])
if last_target > 0 and last_target < pref and memory_change > MIN_MEM_CHANGE_WHEN_UNDER_PREF: if 0 < last_target < pref and \
memory_change > MIN_MEM_CHANGE_WHEN_UNDER_PREF:
self.log.info( self.log.info(
'dom {} is below pref, allowing balance'.format(dom)) 'dom {} is below pref, allowing balance'.format(dom))
return True return True
@ -303,7 +314,7 @@ class SystemState(object):
dom, mem = rq dom, mem = rq
# Force to always have at least 0.9*self.XEN_FREE_MEM_LEFT (some # Force to always have at least 0.9*self.XEN_FREE_MEM_LEFT (some
# margin for rounding errors). Before giving memory to # margin for rounding errors). Before giving memory to
# domain, ensure that others have gived it back. # domain, ensure that others have gave it back.
# If not - wait a little. # If not - wait a little.
ntries = 5 ntries = 5
while self.get_free_xen_memory() - (mem - self.domdict[dom].memory_actual) < 0.9*self.XEN_FREE_MEM_LEFT: while self.get_free_xen_memory() - (mem - self.domdict[dom].memory_actual) < 0.9*self.XEN_FREE_MEM_LEFT:
@ -318,11 +329,12 @@ class SystemState(object):
for rq2 in memset_reqs: for rq2 in memset_reqs:
dom2, mem2 = rq2 dom2, mem2 = rq2
if dom2 == dom: if dom2 == dom:
# All donors have been procesed # All donors have been processed
break break
# allow some small margin # allow some small margin
if self.domdict[dom2].memory_actual > self.domdict[dom2].last_target + self.XEN_FREE_MEM_LEFT/4: if self.domdict[dom2].memory_actual > self.domdict[dom2].last_target + self.XEN_FREE_MEM_LEFT/4:
# VM didn't react to memory request at all, remove from donors # VM didn't react to memory request at all,
# remove from donors
if prev_memactual[dom2] == self.domdict[dom2].memory_actual: if prev_memactual[dom2] == self.domdict[dom2].memory_actual:
self.log.warning( self.log.warning(
'dom {!r} didnt react to memory request' 'dom {!r} didnt react to memory request'
@ -333,7 +345,8 @@ class SystemState(object):
self.domdict[dom2].no_progress = True self.domdict[dom2].no_progress = True
dom_name = self.xs.read('', '/local/domain/%s/name' % str(dom2)) dom_name = self.xs.read('', '/local/domain/%s/name' % str(dom2))
if dom_name is not None: if dom_name is not None:
# TODO: report it somewhere, qubesd or elsewhere # TODO: report it somewhere, qubesd or
# elsewhere
pass pass
else: else:
self.log.warning('dom {!r} still hold more' self.log.warning('dom {!r} still hold more'
@ -344,7 +357,8 @@ class SystemState(object):
self.domdict[dom2].slow_memset_react = True self.domdict[dom2].slow_memset_react = True
dom_name = self.xs.read('', '/local/domain/%s/name' % str(dom2)) dom_name = self.xs.read('', '/local/domain/%s/name' % str(dom2))
if dom_name is not None: if dom_name is not None:
# TODO: report it somewhere, qubesd or elsewhere # TODO: report it somewhere, qubesd or
# elsewhere
pass pass
self.mem_set(dom, self.get_free_xen_memory() + self.domdict[dom].memory_actual - self.XEN_FREE_MEM_LEFT) self.mem_set(dom, self.get_free_xen_memory() + self.domdict[dom].memory_actual - self.XEN_FREE_MEM_LEFT)
return return

91
qubes/qmemman/algo.py
View File

@ -29,9 +29,9 @@ CACHE_FACTOR = 1.3
MIN_PREFMEM = 200 * 1024 * 1024 MIN_PREFMEM = 200 * 1024 * 1024
DOM0_MEM_BOOST = 350 * 1024 * 1024 DOM0_MEM_BOOST = 350 * 1024 * 1024
log = logging.getLogger('qmemman.daemon.algo') log = logging.getLogger('qmemman.daemon.algo')
# untrusted meminfo size is taken from xenstore key, thus its size is limited # untrusted meminfo size is taken from xenstore key, thus its size is limited
# so splits do not require excessive memory # so splits do not require excessive memory
def sanitize_and_parse_meminfo(untrusted_meminfo): def sanitize_and_parse_meminfo(untrusted_meminfo):
@ -65,7 +65,6 @@ def sanitize_and_parse_meminfo(untrusted_meminfo):
meminfo['MemFree'] - meminfo['Cached'] - meminfo['Buffers'] + meminfo['MemFree'] - meminfo['Cached'] - meminfo['Buffers'] +
meminfo['SwapTotal'] - meminfo['SwapFree']) * 1024 meminfo['SwapTotal'] - meminfo['SwapFree']) * 1024
return None return None
@ -89,7 +88,8 @@ def is_meminfo_suspicious(untrusted_meminfo):
ret = True ret = True
if untrusted_meminfo['MemTotal'] < \ if untrusted_meminfo['MemTotal'] < \
untrusted_meminfo['MemFree'] + \ untrusted_meminfo['MemFree'] + \
untrusted_meminfo['Cached'] + untrusted_meminfo['Buffers']: untrusted_meminfo['Cached'] + untrusted_meminfo[
'Buffers']:
ret = True ret = True
# we could also impose some limits on all the above values # we could also impose some limits on all the above values
# but it has little purpose - all the domain can gain by passing e.g. # but it has little purpose - all the domain can gain by passing e.g.
@ -97,7 +97,8 @@ def is_meminfo_suspicious(untrusted_meminfo):
# it can be achieved with legal values, too, and it will not allow to # it can be achieved with legal values, too, and it will not allow to
# starve existing domains, by design # starve existing domains, by design
if ret: if ret:
log.warning('suspicious meminfo untrusted_meminfo={!r}'.format(untrusted_meminfo)) log.warning('suspicious meminfo untrusted_meminfo={!r}'.format(
untrusted_meminfo))
return ret return ret
@ -107,17 +108,23 @@ def refresh_meminfo_for_domain(domain, untrusted_xenstore_key):
def prefmem(domain): def prefmem(domain):
#dom0 is special, as it must have large cache, for vbds. Thus, give it a special boost # dom0 is special, as it must have large cache, for vbds. Thus, give it
# a special boost
if domain.id == '0': if domain.id == '0':
return min(domain.mem_used*CACHE_FACTOR + DOM0_MEM_BOOST, domain.memory_maximum) return min(domain.mem_used * CACHE_FACTOR + DOM0_MEM_BOOST,
return max(min(domain.mem_used*CACHE_FACTOR, domain.memory_maximum), MIN_PREFMEM) domain.memory_maximum)
return max(min(domain.mem_used * CACHE_FACTOR, domain.memory_maximum),
MIN_PREFMEM)
def memory_needed(domain): def memory_needed(domain):
# do not change # do not change
#in balance(), "distribute total_available_memory proportionally to mempref" relies on this exact formula # in balance(), "distribute total_available_memory proportionally to
# mempref" relies on this exact formula
ret = prefmem(domain) - domain.memory_actual ret = prefmem(domain) - domain.memory_actual
return ret return ret
# prepare list of (domain, memory_target) pairs that need to be passed # prepare list of (domain, memory_target) pairs that need to be passed
# to "xm memset" equivalent in order to obtain "memsize" of memory # to "xm memset" equivalent in order to obtain "memsize" of memory
# return empty list when the request cannot be satisfied # return empty list when the request cannot be satisfied
@ -146,17 +153,21 @@ def balloon(memsize, domain_dictionary):
return () return ()
scale = 1.0 * memsize / available scale = 1.0 * memsize / available
for donors_iter in donors: for donors_iter in donors:
id, mem = donors_iter dom_id, mem = donors_iter
memborrowed = mem * scale * REQ_SAFETY_NET_FACTOR memborrowed = mem * scale * REQ_SAFETY_NET_FACTOR
log.info('borrow {} from {}'.format(memborrowed, id)) log.info('borrow {} from {}'.format(memborrowed, dom_id))
memtarget = int(domain_dictionary[id].memory_actual - memborrowed) memtarget = int(domain_dictionary[dom_id].memory_actual - memborrowed)
request.append((id, memtarget)) request.append((dom_id, memtarget))
return request return request
# REQ_SAFETY_NET_FACTOR is a bit greater that 1. So that if the domain yields a bit less than requested, due
# to e.g. rounding errors, we will not get stuck. The surplus will return to the VM during "balance" call.
#redistribute positive "total_available_memory" of memory between domains, proportionally to prefmem # REQ_SAFETY_NET_FACTOR is a bit greater that 1. So that if the domain
# yields a bit less than requested, due to e.g. rounding errors, we will not
# get stuck. The surplus will return to the VM during "balance" call.
# redistribute positive "total_available_memory" of memory between domains,
# proportionally to prefmem
def balance_when_enough_memory(domain_dictionary, def balance_when_enough_memory(domain_dictionary,
xen_free_memory, total_mem_pref, total_available_memory): xen_free_memory, total_mem_pref, total_available_memory):
log.info('balance_when_enough_memory(xen_free_memory={!r}, ' log.info('balance_when_enough_memory(xen_free_memory={!r}, '
@ -174,7 +185,8 @@ def balance_when_enough_memory(domain_dictionary,
continue continue
# distribute total_available_memory proportionally to mempref # distribute total_available_memory proportionally to mempref
scale = 1.0 * prefmem(domain_dictionary[i]) / total_mem_pref scale = 1.0 * prefmem(domain_dictionary[i]) / total_mem_pref
target_nonint = prefmem(domain_dictionary[i]) + scale*total_available_memory target_nonint = prefmem(
domain_dictionary[i]) + scale * total_available_memory
# prevent rounding errors # prevent rounding errors
target = int(0.999 * target_nonint) target = int(0.999 * target_nonint)
# do not try to give more memory than static max # do not try to give more memory than static max
@ -197,7 +209,8 @@ def balance_when_enough_memory(domain_dictionary,
if target < domain_dictionary[i].memory_maximum: if target < domain_dictionary[i].memory_maximum:
memory_bonus = int(0.999 * (left_memory / acceptors_count)) memory_bonus = int(0.999 * (left_memory / acceptors_count))
if target + memory_bonus >= domain_dictionary[i].memory_maximum: if target + memory_bonus >= domain_dictionary[i].memory_maximum:
new_left_memory += target+memory_bonus - domain_dictionary[i].memory_maximum new_left_memory += target + memory_bonus - \
domain_dictionary[i].memory_maximum
target = domain_dictionary[i].memory_maximum target = domain_dictionary[i].memory_maximum
new_acceptors_count -= 1 new_acceptors_count -= 1
else: else:
@ -206,22 +219,24 @@ def balance_when_enough_memory(domain_dictionary,
left_memory = new_left_memory left_memory = new_left_memory
acceptors_count = new_acceptors_count acceptors_count = new_acceptors_count
# split target_memory dictionary to donors and acceptors # split target_memory dictionary to donors and acceptors
# this is needed to first get memory from donors and only then give it to acceptors # this is needed to first get memory from donors and only then give it
# to acceptors
donors_rq = list() donors_rq = list()
acceptors_rq = list() acceptors_rq = list()
for i in target_memory.keys(): for i in target_memory.keys():
target = target_memory[i] target = target_memory[i]
if (target < domain_dictionary[i].memory_actual): if target < domain_dictionary[i].memory_actual:
donors_rq.append((i, target)) donors_rq.append((i, target))
else: else:
acceptors_rq.append((i, target)) acceptors_rq.append((i, target))
# print 'balance(enough): xen_free_memory=', xen_free_memory, 'requests:', donors_rq + acceptors_rq # print 'balance(enough): xen_free_memory=', xen_free_memory, \
# 'requests:', donors_rq + acceptors_rq
return donors_rq + acceptors_rq return donors_rq + acceptors_rq
#when not enough mem to make everyone be above prefmem, make donors be at prefmem, and # when not enough mem to make everyone be above prefmem, make donors be at
#redistribute anything left between acceptors # prefmem, and redistribute anything left between acceptors
def balance_when_low_on_memory(domain_dictionary, def balance_when_low_on_memory(domain_dictionary,
xen_free_memory, total_mem_pref_acceptors, donors, acceptors): xen_free_memory, total_mem_pref_acceptors, donors, acceptors):
log.debug('balance_when_low_on_memory(xen_free_memory={!r}, ' log.debug('balance_when_low_on_memory(xen_free_memory={!r}, '
@ -233,7 +248,8 @@ def balance_when_low_on_memory(domain_dictionary,
for i in donors: for i in donors:
avail = -memory_needed(domain_dictionary[i]) avail = -memory_needed(domain_dictionary[i])
if avail < 10 * 1024 * 1024: if avail < 10 * 1024 * 1024:
#probably we have already tried making it exactly at prefmem, give up # probably we have already tried making it exactly at prefmem,
# give up
continue continue
squeezed_mem -= avail squeezed_mem -= avail
donors_rq.append((i, prefmem(domain_dictionary[i]))) donors_rq.append((i, prefmem(domain_dictionary[i])))
@ -242,11 +258,14 @@ def balance_when_low_on_memory(domain_dictionary,
return donors_rq return donors_rq
for i in acceptors: for i in acceptors:
scale = 1.0 * prefmem(domain_dictionary[i]) / total_mem_pref_acceptors scale = 1.0 * prefmem(domain_dictionary[i]) / total_mem_pref_acceptors
target_nonint = domain_dictionary[i].memory_actual + scale*squeezed_mem target_nonint = \
domain_dictionary[i].memory_actual + scale * squeezed_mem
# do not try to give more memory than static max # do not try to give more memory than static max
target = min(int(0.999*target_nonint), domain_dictionary[i].memory_maximum) target = \
min(int(0.999 * target_nonint), domain_dictionary[i].memory_maximum)
acceptors_rq.append((i, target)) acceptors_rq.append((i, target))
# print 'balance(low): xen_free_memory=', xen_free_memory, 'requests:', donors_rq + acceptors_rq # print 'balance(low): xen_free_memory=', xen_free_memory, 'requests:',
# donors_rq + acceptors_rq
return donors_rq + acceptors_rq return donors_rq + acceptors_rq
@ -259,9 +278,10 @@ def balance(xen_free_memory, domain_dictionary):
xen_free_memory, domain_dictionary)) xen_free_memory, domain_dictionary))
# sum of all memory requirements - in other words, the difference between # sum of all memory requirements - in other words, the difference between
#memory required to be added to domains (acceptors) to make them be at their # memory required to be added to domains (acceptors) to make them be
#preferred memory, and memory that can be taken from domains (donors) that # at their preferred memory, and memory that can be taken from domains
#can provide memory. So, it can be negative when plenty of memory. # (donors) that can provide memory. So, it can be negative when plenty
# of memory.
total_memory_needed = 0 total_memory_needed = 0
# sum of memory preferences of all domains # sum of memory preferences of all domains
@ -279,8 +299,11 @@ def balance(xen_free_memory, domain_dictionary):
if domain_dictionary[i].no_progress: if domain_dictionary[i].no_progress:
continue continue
need = memory_needed(domain_dictionary[i]) need = memory_needed(domain_dictionary[i])
# print 'domain' , i, 'act/pref', domain_dictionary[i].memory_actual, prefmem(domain_dictionary[i]), 'need=', need # print 'domain' , i, 'act/pref', \
if need < 0 or domain_dictionary[i].memory_actual >= domain_dictionary[i].memory_maximum: # domain_dictionary[i].memory_actual, prefmem(domain_dictionary[i]), \
# 'need=', need
if need < 0 or domain_dictionary[i].memory_actual >= \
domain_dictionary[i].memory_maximum:
donors.append(i) donors.append(i)
else: else:
acceptors.append(i) acceptors.append(i)
@ -290,6 +313,8 @@ def balance(xen_free_memory, domain_dictionary):
total_available_memory = xen_free_memory - total_memory_needed total_available_memory = xen_free_memory - total_memory_needed
if total_available_memory > 0: if total_available_memory > 0:
return balance_when_enough_memory(domain_dictionary, xen_free_memory, total_mem_pref, total_available_memory) return balance_when_enough_memory(domain_dictionary, xen_free_memory,
total_mem_pref, total_available_memory)
else: else:
return balance_when_low_on_memory(domain_dictionary, xen_free_memory, total_mem_pref_acceptors, donors, acceptors) return balance_when_low_on_memory(domain_dictionary, xen_free_memory,
total_mem_pref_acceptors, donors, acceptors)