| # SPDX-License-Identifier: GPL-2.0 | |
| import os | |
| ksft_skip=4 | |
| sysfs_root = None | |
| with open('/proc/mounts', 'r') as f: | |
| for line in f: | |
| dev_name, mount_point, dev_fs = line.split()[:3] | |
| if dev_fs == 'sysfs': | |
| sysfs_root = '%s/kernel/mm/damon/admin' % mount_point | |
| break | |
| if sysfs_root is None: | |
| print('Seems sysfs not mounted?') | |
| exit(ksft_skip) | |
| if not os.path.exists(sysfs_root): | |
| print('Seems DAMON disabled?') | |
| exit(ksft_skip) | |
| def write_file(path, string): | |
| "Returns error string if failed, or None otherwise" | |
| string = '%s' % string | |
| try: | |
| with open(path, 'w') as f: | |
| f.write(string) | |
| except Exception as e: | |
| return '%s' % e | |
| return None | |
| def read_file(path): | |
| '''Returns the read content and error string. The read content is None if | |
| the reading failed''' | |
| try: | |
| with open(path, 'r') as f: | |
| return f.read(), None | |
| except Exception as e: | |
| return None, '%s' % e | |
| class DamosAccessPattern: | |
| size = None | |
| nr_accesses = None | |
| age = None | |
| scheme = None | |
| def __init__(self, size=None, nr_accesses=None, age=None): | |
| self.size = size | |
| self.nr_accesses = nr_accesses | |
| self.age = age | |
| if self.size is None: | |
| self.size = [0, 2**64 - 1] | |
| if self.nr_accesses is None: | |
| self.nr_accesses = [0, 2**32 - 1] | |
| if self.age is None: | |
| self.age = [0, 2**32 - 1] | |
| def sysfs_dir(self): | |
| return os.path.join(self.scheme.sysfs_dir(), 'access_pattern') | |
| def stage(self): | |
| err = write_file( | |
| os.path.join(self.sysfs_dir(), 'sz', 'min'), self.size[0]) | |
| if err is not None: | |
| return err | |
| err = write_file( | |
| os.path.join(self.sysfs_dir(), 'sz', 'max'), self.size[1]) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'nr_accesses', 'min'), | |
| self.nr_accesses[0]) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'nr_accesses', 'max'), | |
| self.nr_accesses[1]) | |
| if err is not None: | |
| return err | |
| err = write_file( | |
| os.path.join(self.sysfs_dir(), 'age', 'min'), self.age[0]) | |
| if err is not None: | |
| return err | |
| err = write_file( | |
| os.path.join(self.sysfs_dir(), 'age', 'max'), self.age[1]) | |
| if err is not None: | |
| return err | |
| qgoal_metric_user_input = 'user_input' | |
| qgoal_metric_some_mem_psi_us = 'some_mem_psi_us' | |
| qgoal_metrics = [qgoal_metric_user_input, qgoal_metric_some_mem_psi_us] | |
| class DamosQuotaGoal: | |
| metric = None | |
| target_value = None | |
| current_value = None | |
| nid = None | |
| effective_bytes = None | |
| quota = None # owner quota | |
| idx = None | |
| def __init__(self, metric, target_value=10000, current_value=0, nid=0): | |
| self.metric = metric | |
| self.target_value = target_value | |
| self.current_value = current_value | |
| self.nid = nid | |
| def sysfs_dir(self): | |
| return os.path.join(self.quota.sysfs_dir(), 'goals', '%d' % self.idx) | |
| def stage(self): | |
| err = write_file(os.path.join(self.sysfs_dir(), 'target_metric'), | |
| self.metric) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'target_value'), | |
| self.target_value) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'current_value'), | |
| self.current_value) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'nid'), self.nid) | |
| if err is not None: | |
| return err | |
| return None | |
| class DamosQuota: | |
| sz = None # size quota, in bytes | |
| ms = None # time quota | |
| goals = None # quota goals | |
| goal_tuner = None # quota goal tuner | |
| reset_interval_ms = None # quota reset interval | |
| fail_charge_num = None | |
| fail_charge_denom = None | |
| weight_sz_permil = None | |
| weight_nr_accesses_permil = None | |
| weight_age_permil = None | |
| scheme = None # owner scheme | |
| def __init__(self, sz=0, ms=0, goals=None, goal_tuner='consist', | |
| reset_interval_ms=0, fail_charge_num=0, fail_charge_denom=0, | |
| weight_sz_permil=0, weight_nr_accesses_permil=0, | |
| weight_age_permil=0): | |
| self.sz = sz | |
| self.ms = ms | |
| self.reset_interval_ms = reset_interval_ms | |
| self.weight_sz_permil = weight_sz_permil | |
| self.weight_nr_accesses_permil = weight_nr_accesses_permil | |
| self.weight_age_permil = weight_age_permil | |
| self.goals = goals if goals is not None else [] | |
| self.goal_tuner = goal_tuner | |
| for idx, goal in enumerate(self.goals): | |
| goal.idx = idx | |
| goal.quota = self | |
| self.fail_charge_num = fail_charge_num | |
| self.fail_charge_denom = fail_charge_denom | |
| def sysfs_dir(self): | |
| return os.path.join(self.scheme.sysfs_dir(), 'quotas') | |
| def stage(self): | |
| err = write_file(os.path.join(self.sysfs_dir(), 'bytes'), self.sz) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'ms'), self.ms) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'reset_interval_ms'), | |
| self.reset_interval_ms) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join( | |
| self.sysfs_dir(), 'weights', 'sz_permil'), self.weight_sz_permil) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join( | |
| self.sysfs_dir(), 'weights', 'nr_accesses_permil'), | |
| self.weight_nr_accesses_permil) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join( | |
| self.sysfs_dir(), 'weights', 'age_permil'), self.weight_age_permil) | |
| if err is not None: | |
| return err | |
| nr_goals_file = os.path.join(self.sysfs_dir(), 'goals', 'nr_goals') | |
| content, err = read_file(nr_goals_file) | |
| if err is not None: | |
| return err | |
| if int(content) != len(self.goals): | |
| err = write_file(nr_goals_file, len(self.goals)) | |
| if err is not None: | |
| return err | |
| for goal in self.goals: | |
| err = goal.stage() | |
| if err is not None: | |
| return err | |
| err = write_file( | |
| os.path.join(self.sysfs_dir(), 'goal_tuner'), self.goal_tuner) | |
| if err is not None: | |
| return err | |
| err = write_file( | |
| os.path.join(self.sysfs_dir(), 'fail_charge_num'), | |
| self.fail_charge_num) | |
| if err is not None: | |
| return err | |
| err = write_file( | |
| os.path.join(self.sysfs_dir(), 'fail_charge_denom'), | |
| self.fail_charge_denom) | |
| if err is not None: | |
| return err | |
| return None | |
| class DamosWatermarks: | |
| metric = None | |
| interval = None | |
| high = None | |
| mid = None | |
| low = None | |
| scheme = None # owner scheme | |
| def __init__(self, metric='none', interval=0, high=0, mid=0, low=0): | |
| self.metric = metric | |
| self.interval = interval | |
| self.high = high | |
| self.mid = mid | |
| self.low = low | |
| def sysfs_dir(self): | |
| return os.path.join(self.scheme.sysfs_dir(), 'watermarks') | |
| def stage(self): | |
| err = write_file(os.path.join(self.sysfs_dir(), 'metric'), self.metric) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'interval_us'), | |
| self.interval) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'high'), self.high) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'mid'), self.mid) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'low'), self.low) | |
| if err is not None: | |
| return err | |
| class DamosFilter: | |
| type_ = None | |
| matching = None | |
| allow = None | |
| memcg_path = None | |
| addr_start = None | |
| addr_end = None | |
| target_idx = None | |
| min_ = None | |
| max_ = None | |
| idx = None | |
| filters = None # owner filters | |
| def __init__(self, type_='anon', matching=False, allow=False, | |
| memcg_path='', addr_start=0, addr_end=0, target_idx=0, min_=0, | |
| max_=0): | |
| self.type_ = type_ | |
| self.matching = matching | |
| self.allow = allow | |
| self.memcg_path = memcg_path | |
| self.addr_start = addr_start | |
| self.addr_end = addr_end | |
| self.target_idx = target_idx | |
| self.min_ = min_ | |
| self.max_ = max_ | |
| def sysfs_dir(self): | |
| return os.path.join(self.filters.sysfs_dir(), '%d' % self.idx) | |
| def stage(self): | |
| err = write_file(os.path.join(self.sysfs_dir(), 'type'), self.type_) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'matching'), | |
| self.matching) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'allow'), self.allow) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'memcg_path'), | |
| self.memcg_path) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'addr_start'), | |
| self.addr_start) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'addr_end'), | |
| self.addr_end) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'damon_target_idx'), | |
| self.target_idx) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'min'), self.min_) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'max'), self.max_) | |
| if err is not None: | |
| return err | |
| return None | |
| class DamosFilters: | |
| name = None | |
| filters = None | |
| scheme = None # owner scheme | |
| def __init__(self, name, filters=[]): | |
| self.name = name | |
| self.filters = filters | |
| for idx, filter_ in enumerate(self.filters): | |
| filter_.idx = idx | |
| filter_.filters = self | |
| def sysfs_dir(self): | |
| return os.path.join(self.scheme.sysfs_dir(), self.name) | |
| def stage(self): | |
| err = write_file(os.path.join(self.sysfs_dir(), 'nr_filters'), | |
| len(self.filters)) | |
| if err is not None: | |
| return err | |
| for filter_ in self.filters: | |
| err = filter_.stage() | |
| if err is not None: | |
| return err | |
| return None | |
| class DamosDest: | |
| id = None | |
| weight = None | |
| idx = None | |
| dests = None # owner dests | |
| def __init__(self, id=0, weight=0): | |
| self.id = id | |
| self.weight = weight | |
| def sysfs_dir(self): | |
| return os.path.join(self.dests.sysfs_dir(), '%d' % self.idx) | |
| def stage(self): | |
| err = write_file(os.path.join(self.sysfs_dir(), 'id'), self.id) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'weight'), self.weight) | |
| if err is not None: | |
| return err | |
| return None | |
| class DamosDests: | |
| dests = None | |
| scheme = None # owner scheme | |
| def __init__(self, dests=[]): | |
| self.dests = dests | |
| for idx, dest in enumerate(self.dests): | |
| dest.idx = idx | |
| dest.dests = self | |
| def sysfs_dir(self): | |
| return os.path.join(self.scheme.sysfs_dir(), 'dests') | |
| def stage(self): | |
| err = write_file(os.path.join(self.sysfs_dir(), 'nr_dests'), | |
| len(self.dests)) | |
| if err is not None: | |
| return err | |
| for dest in self.dests: | |
| err = dest.stage() | |
| if err is not None: | |
| return err | |
| return None | |
| class DamosStats: | |
| nr_tried = None | |
| sz_tried = None | |
| nr_applied = None | |
| sz_applied = None | |
| qt_exceeds = None | |
| def __init__(self, nr_tried, sz_tried, nr_applied, sz_applied, qt_exceeds): | |
| self.nr_tried = nr_tried | |
| self.sz_tried = sz_tried | |
| self.nr_applied = nr_applied | |
| self.sz_applied = sz_applied | |
| self.qt_exceeds = qt_exceeds | |
| class DamosTriedRegion: | |
| def __init__(self, start, end, nr_accesses, age): | |
| self.start = start | |
| self.end = end | |
| self.nr_accesses = nr_accesses | |
| self.age = age | |
| class Damos: | |
| action = None | |
| access_pattern = None | |
| quota = None | |
| watermarks = None | |
| core_filters = None | |
| ops_filters = None | |
| filters = None | |
| apply_interval_us = None | |
| target_nid = None | |
| dests = None | |
| idx = None | |
| context = None | |
| tried_bytes = None | |
| stats = None | |
| tried_regions = None | |
| def __init__(self, action='stat', access_pattern=DamosAccessPattern(), | |
| quota=DamosQuota(), watermarks=DamosWatermarks(), | |
| core_filters=[], ops_filters=[], filters=[], target_nid=0, | |
| dests=DamosDests(), apply_interval_us=0): | |
| self.action = action | |
| self.access_pattern = access_pattern | |
| self.access_pattern.scheme = self | |
| self.quota = quota | |
| self.quota.scheme = self | |
| self.watermarks = watermarks | |
| self.watermarks.scheme = self | |
| self.core_filters = DamosFilters(name='core_filters', | |
| filters=core_filters) | |
| self.core_filters.scheme = self | |
| self.ops_filters = DamosFilters(name='ops_filters', | |
| filters=ops_filters) | |
| self.ops_filters.scheme = self | |
| self.filters = DamosFilters(name='filters', filters=filters) | |
| self.filters.scheme = self | |
| self.target_nid = target_nid | |
| self.dests = dests | |
| self.dests.scheme = self | |
| self.apply_interval_us = apply_interval_us | |
| def sysfs_dir(self): | |
| return os.path.join( | |
| self.context.sysfs_dir(), 'schemes', '%d' % self.idx) | |
| def stage(self): | |
| err = write_file(os.path.join(self.sysfs_dir(), 'action'), self.action) | |
| if err is not None: | |
| return err | |
| err = self.access_pattern.stage() | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'apply_interval_us'), | |
| '%d' % self.apply_interval_us) | |
| if err is not None: | |
| return err | |
| err = self.quota.stage() | |
| if err is not None: | |
| return err | |
| err = self.watermarks.stage() | |
| if err is not None: | |
| return err | |
| err = self.core_filters.stage() | |
| if err is not None: | |
| return err | |
| err = self.ops_filters.stage() | |
| if err is not None: | |
| return err | |
| err = self.filters.stage() | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'target_nid'), '%d' % | |
| self.target_nid) | |
| if err is not None: | |
| return err | |
| err = self.dests.stage() | |
| if err is not None: | |
| return err | |
| class DamonTarget: | |
| pid = None | |
| obsolete = None | |
| # todo: Support target regions if test is made | |
| idx = None | |
| context = None | |
| def __init__(self, pid, obsolete=False): | |
| self.pid = pid | |
| self.obsolete = obsolete | |
| def sysfs_dir(self): | |
| return os.path.join( | |
| self.context.sysfs_dir(), 'targets', '%d' % self.idx) | |
| def stage(self): | |
| err = write_file( | |
| os.path.join(self.sysfs_dir(), 'regions', 'nr_regions'), '0') | |
| if err is not None: | |
| return err | |
| err = write_file( | |
| os.path.join(self.sysfs_dir(), 'pid_target'), self.pid) | |
| if err is not None: | |
| return err | |
| return write_file( | |
| os.path.join(self.sysfs_dir(), 'obsolete_target'), | |
| 'Y' if self.obsolete else 'N') | |
| class IntervalsGoal: | |
| access_bp = None | |
| aggrs = None | |
| min_sample_us = None | |
| max_sample_us = None | |
| attrs = None # owner DamonAttrs | |
| def __init__(self, access_bp=0, aggrs=0, min_sample_us=0, max_sample_us=0): | |
| self.access_bp = access_bp | |
| self.aggrs = aggrs | |
| self.min_sample_us = min_sample_us | |
| self.max_sample_us = max_sample_us | |
| def sysfs_dir(self): | |
| return os.path.join(self.attrs.interval_sysfs_dir(), 'intervals_goal') | |
| def stage(self): | |
| err = write_file( | |
| os.path.join(self.sysfs_dir(), 'access_bp'), self.access_bp) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'aggrs'), self.aggrs) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'min_sample_us'), | |
| self.min_sample_us) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'max_sample_us'), | |
| self.max_sample_us) | |
| if err is not None: | |
| return err | |
| return None | |
| class DamonAttrs: | |
| sample_us = None | |
| aggr_us = None | |
| intervals_goal = None | |
| update_us = None | |
| min_nr_regions = None | |
| max_nr_regions = None | |
| context = None | |
| def __init__(self, sample_us=5000, aggr_us=100000, | |
| intervals_goal=IntervalsGoal(), update_us=1000000, | |
| min_nr_regions=10, max_nr_regions=1000): | |
| self.sample_us = sample_us | |
| self.aggr_us = aggr_us | |
| self.intervals_goal = intervals_goal | |
| self.intervals_goal.attrs = self | |
| self.update_us = update_us | |
| self.min_nr_regions = min_nr_regions | |
| self.max_nr_regions = max_nr_regions | |
| def interval_sysfs_dir(self): | |
| return os.path.join(self.context.sysfs_dir(), 'monitoring_attrs', | |
| 'intervals') | |
| def nr_regions_range_sysfs_dir(self): | |
| return os.path.join(self.context.sysfs_dir(), 'monitoring_attrs', | |
| 'nr_regions') | |
| def stage(self): | |
| err = write_file(os.path.join(self.interval_sysfs_dir(), 'sample_us'), | |
| self.sample_us) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.interval_sysfs_dir(), 'aggr_us'), | |
| self.aggr_us) | |
| if err is not None: | |
| return err | |
| err = self.intervals_goal.stage() | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.interval_sysfs_dir(), 'update_us'), | |
| self.update_us) | |
| if err is not None: | |
| return err | |
| err = write_file( | |
| os.path.join(self.nr_regions_range_sysfs_dir(), 'min'), | |
| self.min_nr_regions) | |
| if err is not None: | |
| return err | |
| err = write_file( | |
| os.path.join(self.nr_regions_range_sysfs_dir(), 'max'), | |
| self.max_nr_regions) | |
| if err is not None: | |
| return err | |
| class DamonCtx: | |
| ops = None | |
| monitoring_attrs = None | |
| targets = None | |
| schemes = None | |
| kdamond = None | |
| pause = None | |
| idx = None | |
| def __init__(self, ops='paddr', monitoring_attrs=None, targets=None, | |
| schemes=None, pause=False): | |
| self.ops = ops | |
| if monitoring_attrs is None: | |
| monitoring_attrs = DamonAttrs() | |
| self.monitoring_attrs = monitoring_attrs | |
| self.monitoring_attrs.context = self | |
| if targets is None: | |
| targets = [] | |
| self.targets = targets | |
| for idx, target in enumerate(self.targets): | |
| target.idx = idx | |
| target.context = self | |
| if schemes is None: | |
| schemes = [] | |
| self.schemes = schemes | |
| for idx, scheme in enumerate(self.schemes): | |
| scheme.idx = idx | |
| scheme.context = self | |
| self.pause=pause | |
| def sysfs_dir(self): | |
| return os.path.join(self.kdamond.sysfs_dir(), 'contexts', | |
| '%d' % self.idx) | |
| def stage(self): | |
| err = write_file( | |
| os.path.join(self.sysfs_dir(), 'operations'), self.ops) | |
| if err is not None: | |
| return err | |
| err = self.monitoring_attrs.stage() | |
| if err is not None: | |
| return err | |
| nr_targets_file = os.path.join( | |
| self.sysfs_dir(), 'targets', 'nr_targets') | |
| content, err = read_file(nr_targets_file) | |
| if err is not None: | |
| return err | |
| if int(content) != len(self.targets): | |
| err = write_file(nr_targets_file, '%d' % len(self.targets)) | |
| if err is not None: | |
| return err | |
| for target in self.targets: | |
| err = target.stage() | |
| if err is not None: | |
| return err | |
| nr_schemes_file = os.path.join( | |
| self.sysfs_dir(), 'schemes', 'nr_schemes') | |
| content, err = read_file(nr_schemes_file) | |
| if err is not None: | |
| return err | |
| if int(content) != len(self.schemes): | |
| err = write_file(nr_schemes_file, '%d' % len(self.schemes)) | |
| if err is not None: | |
| return err | |
| for scheme in self.schemes: | |
| err = scheme.stage() | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'pause'), self.pause) | |
| if err is not None: | |
| return err | |
| return None | |
| class Kdamond: | |
| state = None | |
| pid = None | |
| refresh_ms = None | |
| contexts = None | |
| idx = None # index of this kdamond between siblings | |
| kdamonds = None # parent | |
| def __init__(self, contexts=[], refresh_ms=None): | |
| self.contexts = contexts | |
| self.refresh_ms = refresh_ms | |
| for idx, context in enumerate(self.contexts): | |
| context.idx = idx | |
| context.kdamond = self | |
| def sysfs_dir(self): | |
| return os.path.join(self.kdamonds.sysfs_dir(), '%d' % self.idx) | |
| def start(self): | |
| nr_contexts_file = os.path.join(self.sysfs_dir(), | |
| 'contexts', 'nr_contexts') | |
| content, err = read_file(nr_contexts_file) | |
| if err is not None: | |
| return err | |
| if int(content) != len(self.contexts): | |
| err = write_file(nr_contexts_file, '%d' % len(self.contexts)) | |
| if err is not None: | |
| return err | |
| for context in self.contexts: | |
| err = context.stage() | |
| if err is not None: | |
| return err | |
| if self.refresh_ms is not None: | |
| err = write_file(os.path.join(self.sysfs_dir(), 'refresh_ms'), | |
| '%d' % self.refresh_ms) | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'state'), 'on') | |
| if err is not None: | |
| return err | |
| self.pid, err = read_file(os.path.join(self.sysfs_dir(), 'pid')) | |
| return err | |
| def stop(self): | |
| err = write_file(os.path.join(self.sysfs_dir(), 'state'), 'off') | |
| return err | |
| def update_schemes_tried_regions(self): | |
| err = write_file(os.path.join(self.sysfs_dir(), 'state'), | |
| 'update_schemes_tried_regions') | |
| if err is not None: | |
| return err | |
| for context in self.contexts: | |
| for scheme in context.schemes: | |
| tried_regions = [] | |
| tried_regions_dir = os.path.join( | |
| scheme.sysfs_dir(), 'tried_regions') | |
| region_indices = [] | |
| for filename in os.listdir( | |
| os.path.join(scheme.sysfs_dir(), 'tried_regions')): | |
| tried_region_dir = os.path.join(tried_regions_dir, filename) | |
| if not os.path.isdir(tried_region_dir): | |
| continue | |
| region_indices.append(int(filename)) | |
| for region_idx in sorted(region_indices): | |
| tried_region_dir = os.path.join(tried_regions_dir, | |
| '%d' % region_idx) | |
| region_values = [] | |
| for f in ['start', 'end', 'nr_accesses', 'age']: | |
| content, err = read_file( | |
| os.path.join(tried_region_dir, f)) | |
| if err is not None: | |
| return err | |
| region_values.append(int(content)) | |
| tried_regions.append(DamosTriedRegion(*region_values)) | |
| scheme.tried_regions = tried_regions | |
| def update_schemes_tried_bytes(self): | |
| err = write_file(os.path.join(self.sysfs_dir(), 'state'), | |
| 'update_schemes_tried_bytes') | |
| if err is not None: | |
| return err | |
| for context in self.contexts: | |
| for scheme in context.schemes: | |
| content, err = read_file(os.path.join(scheme.sysfs_dir(), | |
| 'tried_regions', 'total_bytes')) | |
| if err is not None: | |
| return err | |
| scheme.tried_bytes = int(content) | |
| def update_schemes_stats(self): | |
| err = write_file(os.path.join(self.sysfs_dir(), 'state'), | |
| 'update_schemes_stats') | |
| if err is not None: | |
| return err | |
| for context in self.contexts: | |
| for scheme in context.schemes: | |
| stat_values = [] | |
| for stat in ['nr_tried', 'sz_tried', 'nr_applied', | |
| 'sz_applied', 'qt_exceeds']: | |
| content, err = read_file( | |
| os.path.join(scheme.sysfs_dir(), 'stats', stat)) | |
| if err is not None: | |
| return err | |
| stat_values.append(int(content)) | |
| scheme.stats = DamosStats(*stat_values) | |
| def update_schemes_effective_quotas(self): | |
| err = write_file(os.path.join(self.sysfs_dir(), 'state'), | |
| 'update_schemes_effective_quotas') | |
| if err is not None: | |
| return err | |
| for context in self.contexts: | |
| for scheme in context.schemes: | |
| for goal in scheme.quota.goals: | |
| content, err = read_file( | |
| os.path.join(scheme.quota.sysfs_dir(), | |
| 'effective_bytes')) | |
| if err is not None: | |
| return err | |
| goal.effective_bytes = int(content) | |
| return None | |
| def commit(self): | |
| nr_contexts_file = os.path.join(self.sysfs_dir(), | |
| 'contexts', 'nr_contexts') | |
| content, err = read_file(nr_contexts_file) | |
| if err is not None: | |
| return err | |
| if int(content) != len(self.contexts): | |
| err = write_file(nr_contexts_file, '%d' % len(self.contexts)) | |
| if err is not None: | |
| return err | |
| for context in self.contexts: | |
| err = context.stage() | |
| if err is not None: | |
| return err | |
| err = write_file(os.path.join(self.sysfs_dir(), 'state'), 'commit') | |
| return err | |
| def commit_schemes_quota_goals(self): | |
| for context in self.contexts: | |
| for scheme in context.schemes: | |
| for goal in scheme.quota.goals: | |
| err = goal.stage() | |
| if err is not None: | |
| print('commit_schemes_quota_goals failed staging: %s'% | |
| err) | |
| exit(1) | |
| return write_file(os.path.join(self.sysfs_dir(), 'state'), | |
| 'commit_schemes_quota_goals') | |
| class Kdamonds: | |
| kdamonds = [] | |
| def __init__(self, kdamonds=[]): | |
| self.kdamonds = kdamonds | |
| for idx, kdamond in enumerate(self.kdamonds): | |
| kdamond.idx = idx | |
| kdamond.kdamonds = self | |
| def sysfs_dir(self): | |
| return os.path.join(sysfs_root, 'kdamonds') | |
| def start(self): | |
| err = write_file(os.path.join(self.sysfs_dir(), 'nr_kdamonds'), | |
| '%s' % len(self.kdamonds)) | |
| if err is not None: | |
| return err | |
| for kdamond in self.kdamonds: | |
| err = kdamond.start() | |
| if err is not None: | |
| return err | |
| return None | |
| def stop(self): | |
| for kdamond in self.kdamonds: | |
| err = kdamond.stop() | |
| if err is not None: | |
| return err | |
| return None |