tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1# SPDX-License-Identifier: GPL-2.0
2
3import os
4
5ksft_skip=4
6
7sysfs_root = None
8with open('/proc/mounts', 'r') as f:
9 for line in f:
10 dev_name, mount_point, dev_fs = line.split()[:3]
11 if dev_fs == 'sysfs':
12 sysfs_root = '%s/kernel/mm/damon/admin' % mount_point
13 break
14if sysfs_root is None:
15 print('Seems sysfs not mounted?')
16 exit(ksft_skip)
17
18if not os.path.exists(sysfs_root):
19 print('Seems DAMON disabled?')
20 exit(ksft_skip)
21
22def write_file(path, string):
23 "Returns error string if failed, or None otherwise"
24 string = '%s' % string
25 try:
26 with open(path, 'w') as f:
27 f.write(string)
28 except Exception as e:
29 return '%s' % e
30 return None
31
32def read_file(path):
33 '''Returns the read content and error string. The read content is None if
34 the reading failed'''
35 try:
36 with open(path, 'r') as f:
37 return f.read(), None
38 except Exception as e:
39 return None, '%s' % e
40
41class DamosAccessPattern:
42 size = None
43 nr_accesses = None
44 age = None
45 scheme = None
46
47 def __init__(self, size=None, nr_accesses=None, age=None):
48 self.size = size
49 self.nr_accesses = nr_accesses
50 self.age = age
51
52 if self.size is None:
53 self.size = [0, 2**64 - 1]
54 if self.nr_accesses is None:
55 self.nr_accesses = [0, 2**32 - 1]
56 if self.age is None:
57 self.age = [0, 2**32 - 1]
58
59 def sysfs_dir(self):
60 return os.path.join(self.scheme.sysfs_dir(), 'access_pattern')
61
62 def stage(self):
63 err = write_file(
64 os.path.join(self.sysfs_dir(), 'sz', 'min'), self.size[0])
65 if err is not None:
66 return err
67 err = write_file(
68 os.path.join(self.sysfs_dir(), 'sz', 'max'), self.size[1])
69 if err is not None:
70 return err
71 err = write_file(os.path.join(self.sysfs_dir(), 'nr_accesses', 'min'),
72 self.nr_accesses[0])
73 if err is not None:
74 return err
75 err = write_file(os.path.join(self.sysfs_dir(), 'nr_accesses', 'max'),
76 self.nr_accesses[1])
77 if err is not None:
78 return err
79 err = write_file(
80 os.path.join(self.sysfs_dir(), 'age', 'min'), self.age[0])
81 if err is not None:
82 return err
83 err = write_file(
84 os.path.join(self.sysfs_dir(), 'age', 'max'), self.age[1])
85 if err is not None:
86 return err
87
88qgoal_metric_user_input = 'user_input'
89qgoal_metric_some_mem_psi_us = 'some_mem_psi_us'
90qgoal_metrics = [qgoal_metric_user_input, qgoal_metric_some_mem_psi_us]
91
92class DamosQuotaGoal:
93 metric = None
94 target_value = None
95 current_value = None
96 nid = None
97 effective_bytes = None
98 quota = None # owner quota
99 idx = None
100
101 def __init__(self, metric, target_value=10000, current_value=0, nid=0):
102 self.metric = metric
103 self.target_value = target_value
104 self.current_value = current_value
105 self.nid = nid
106
107 def sysfs_dir(self):
108 return os.path.join(self.quota.sysfs_dir(), 'goals', '%d' % self.idx)
109
110 def stage(self):
111 err = write_file(os.path.join(self.sysfs_dir(), 'target_metric'),
112 self.metric)
113 if err is not None:
114 return err
115 err = write_file(os.path.join(self.sysfs_dir(), 'target_value'),
116 self.target_value)
117 if err is not None:
118 return err
119 err = write_file(os.path.join(self.sysfs_dir(), 'current_value'),
120 self.current_value)
121 if err is not None:
122 return err
123 err = write_file(os.path.join(self.sysfs_dir(), 'nid'), self.nid)
124 if err is not None:
125 return err
126
127 return None
128
129class DamosQuota:
130 sz = None # size quota, in bytes
131 ms = None # time quota
132 goals = None # quota goals
133 reset_interval_ms = None # quota reset interval
134 weight_sz_permil = None
135 weight_nr_accesses_permil = None
136 weight_age_permil = None
137 scheme = None # owner scheme
138
139 def __init__(self, sz=0, ms=0, goals=None, reset_interval_ms=0,
140 weight_sz_permil=0, weight_nr_accesses_permil=0,
141 weight_age_permil=0):
142 self.sz = sz
143 self.ms = ms
144 self.reset_interval_ms = reset_interval_ms
145 self.weight_sz_permil = weight_sz_permil
146 self.weight_nr_accesses_permil = weight_nr_accesses_permil
147 self.weight_age_permil = weight_age_permil
148 self.goals = goals if goals is not None else []
149 for idx, goal in enumerate(self.goals):
150 goal.idx = idx
151 goal.quota = self
152
153 def sysfs_dir(self):
154 return os.path.join(self.scheme.sysfs_dir(), 'quotas')
155
156 def stage(self):
157 err = write_file(os.path.join(self.sysfs_dir(), 'bytes'), self.sz)
158 if err is not None:
159 return err
160 err = write_file(os.path.join(self.sysfs_dir(), 'ms'), self.ms)
161 if err is not None:
162 return err
163 err = write_file(os.path.join(self.sysfs_dir(), 'reset_interval_ms'),
164 self.reset_interval_ms)
165 if err is not None:
166 return err
167
168 err = write_file(os.path.join(
169 self.sysfs_dir(), 'weights', 'sz_permil'), self.weight_sz_permil)
170 if err is not None:
171 return err
172 err = write_file(os.path.join(
173 self.sysfs_dir(), 'weights', 'nr_accesses_permil'),
174 self.weight_nr_accesses_permil)
175 if err is not None:
176 return err
177 err = write_file(os.path.join(
178 self.sysfs_dir(), 'weights', 'age_permil'), self.weight_age_permil)
179 if err is not None:
180 return err
181
182 nr_goals_file = os.path.join(self.sysfs_dir(), 'goals', 'nr_goals')
183 content, err = read_file(nr_goals_file)
184 if err is not None:
185 return err
186 if int(content) != len(self.goals):
187 err = write_file(nr_goals_file, len(self.goals))
188 if err is not None:
189 return err
190 for goal in self.goals:
191 err = goal.stage()
192 if err is not None:
193 return err
194 return None
195
196class DamosWatermarks:
197 metric = None
198 interval = None
199 high = None
200 mid = None
201 low = None
202 scheme = None # owner scheme
203
204 def __init__(self, metric='none', interval=0, high=0, mid=0, low=0):
205 self.metric = metric
206 self.interval = interval
207 self.high = high
208 self.mid = mid
209 self.low = low
210
211 def sysfs_dir(self):
212 return os.path.join(self.scheme.sysfs_dir(), 'watermarks')
213
214 def stage(self):
215 err = write_file(os.path.join(self.sysfs_dir(), 'metric'), self.metric)
216 if err is not None:
217 return err
218 err = write_file(os.path.join(self.sysfs_dir(), 'interval_us'),
219 self.interval)
220 if err is not None:
221 return err
222 err = write_file(os.path.join(self.sysfs_dir(), 'high'), self.high)
223 if err is not None:
224 return err
225 err = write_file(os.path.join(self.sysfs_dir(), 'mid'), self.mid)
226 if err is not None:
227 return err
228 err = write_file(os.path.join(self.sysfs_dir(), 'low'), self.low)
229 if err is not None:
230 return err
231
232class DamosFilter:
233 type_ = None
234 matching = None
235 allow = None
236 memcg_path = None
237 addr_start = None
238 addr_end = None
239 target_idx = None
240 min_ = None
241 max_ = None
242 idx = None
243 filters = None # owner filters
244
245 def __init__(self, type_='anon', matching=False, allow=False,
246 memcg_path='', addr_start=0, addr_end=0, target_idx=0, min_=0,
247 max_=0):
248 self.type_ = type_
249 self.matching = matching
250 self.allow = allow
251 self.memcg_path = memcg_path,
252 self.addr_start = addr_start
253 self.addr_end = addr_end
254 self.target_idx = target_idx
255 self.min_ = min_
256 self.max_ = max_
257
258 def sysfs_dir(self):
259 return os.path.join(self.filters.sysfs_dir(), '%d' % self.idx)
260
261 def stage(self):
262 err = write_file(os.path.join(self.sysfs_dir(), 'type'), self.type_)
263 if err is not None:
264 return err
265 err = write_file(os.path.join(self.sysfs_dir(), 'matching'),
266 self.matching)
267 if err is not None:
268 return err
269 err = write_file(os.path.join(self.sysfs_dir(), 'allow'), self.allow)
270 if err is not None:
271 return err
272 err = write_file(os.path.join(self.sysfs_dir(), 'memcg_path'),
273 self.memcg_path)
274 if err is not None:
275 return err
276 err = write_file(os.path.join(self.sysfs_dir(), 'addr_start'),
277 self.addr_start)
278 if err is not None:
279 return err
280 err = write_file(os.path.join(self.sysfs_dir(), 'addr_end'),
281 self.addr_end)
282 if err is not None:
283 return err
284 err = write_file(os.path.join(self.sysfs_dir(), 'damon_target_idx'),
285 self.target_idx)
286 if err is not None:
287 return err
288 err = write_file(os.path.join(self.sysfs_dir(), 'min'), self.min_)
289 if err is not None:
290 return err
291 err = write_file(os.path.join(self.sysfs_dir(), 'max'), self.max_)
292 if err is not None:
293 return err
294 return None
295
296class DamosFilters:
297 name = None
298 filters = None
299 scheme = None # owner scheme
300
301 def __init__(self, name, filters=[]):
302 self.name = name
303 self.filters = filters
304 for idx, filter_ in enumerate(self.filters):
305 filter_.idx = idx
306 filter_.filters = self
307
308 def sysfs_dir(self):
309 return os.path.join(self.scheme.sysfs_dir(), self.name)
310
311 def stage(self):
312 err = write_file(os.path.join(self.sysfs_dir(), 'nr_filters'),
313 len(self.filters))
314 if err is not None:
315 return err
316 for filter_ in self.filters:
317 err = filter_.stage()
318 if err is not None:
319 return err
320 return None
321
322class DamosDest:
323 id = None
324 weight = None
325 idx = None
326 dests = None # owner dests
327
328 def __init__(self, id=0, weight=0):
329 self.id = id
330 self.weight = weight
331
332 def sysfs_dir(self):
333 return os.path.join(self.dests.sysfs_dir(), '%d' % self.idx)
334
335 def stage(self):
336 err = write_file(os.path.join(self.sysfs_dir(), 'id'), self.id)
337 if err is not None:
338 return err
339 err = write_file(os.path.join(self.sysfs_dir(), 'weight'), self.weight)
340 if err is not None:
341 return err
342 return None
343
344class DamosDests:
345 dests = None
346 scheme = None # owner scheme
347
348 def __init__(self, dests=[]):
349 self.dests = dests
350 for idx, dest in enumerate(self.dests):
351 dest.idx = idx
352 dest.dests = self
353
354 def sysfs_dir(self):
355 return os.path.join(self.scheme.sysfs_dir(), 'dests')
356
357 def stage(self):
358 err = write_file(os.path.join(self.sysfs_dir(), 'nr_dests'),
359 len(self.dests))
360 if err is not None:
361 return err
362 for dest in self.dests:
363 err = dest.stage()
364 if err is not None:
365 return err
366 return None
367
368class DamosStats:
369 nr_tried = None
370 sz_tried = None
371 nr_applied = None
372 sz_applied = None
373 qt_exceeds = None
374
375 def __init__(self, nr_tried, sz_tried, nr_applied, sz_applied, qt_exceeds):
376 self.nr_tried = nr_tried
377 self.sz_tried = sz_tried
378 self.nr_applied = nr_applied
379 self.sz_applied = sz_applied
380 self.qt_exceeds = qt_exceeds
381
382class DamosTriedRegion:
383 def __init__(self, start, end, nr_accesses, age):
384 self.start = start
385 self.end = end
386 self.nr_accesses = nr_accesses
387 self.age = age
388
389class Damos:
390 action = None
391 access_pattern = None
392 quota = None
393 watermarks = None
394 core_filters = None
395 ops_filters = None
396 filters = None
397 apply_interval_us = None
398 target_nid = None
399 dests = None
400 idx = None
401 context = None
402 tried_bytes = None
403 stats = None
404 tried_regions = None
405
406 def __init__(self, action='stat', access_pattern=DamosAccessPattern(),
407 quota=DamosQuota(), watermarks=DamosWatermarks(),
408 core_filters=[], ops_filters=[], filters=[], target_nid=0,
409 dests=DamosDests(), apply_interval_us=0):
410 self.action = action
411 self.access_pattern = access_pattern
412 self.access_pattern.scheme = self
413 self.quota = quota
414 self.quota.scheme = self
415 self.watermarks = watermarks
416 self.watermarks.scheme = self
417
418 self.core_filters = DamosFilters(name='core_filters',
419 filters=core_filters)
420 self.core_filters.scheme = self
421 self.ops_filters = DamosFilters(name='ops_filters',
422 filters=ops_filters)
423 self.ops_filters.scheme = self
424 self.filters = DamosFilters(name='filters', filters=filters)
425 self.filters.scheme = self
426
427 self.target_nid = target_nid
428 self.dests = dests
429 self.dests.scheme = self
430
431 self.apply_interval_us = apply_interval_us
432
433 def sysfs_dir(self):
434 return os.path.join(
435 self.context.sysfs_dir(), 'schemes', '%d' % self.idx)
436
437 def stage(self):
438 err = write_file(os.path.join(self.sysfs_dir(), 'action'), self.action)
439 if err is not None:
440 return err
441 err = self.access_pattern.stage()
442 if err is not None:
443 return err
444 err = write_file(os.path.join(self.sysfs_dir(), 'apply_interval_us'),
445 '%d' % self.apply_interval_us)
446 if err is not None:
447 return err
448
449 err = self.quota.stage()
450 if err is not None:
451 return err
452
453 err = self.watermarks.stage()
454 if err is not None:
455 return err
456
457 err = self.core_filters.stage()
458 if err is not None:
459 return err
460 err = self.ops_filters.stage()
461 if err is not None:
462 return err
463 err = self.filters.stage()
464 if err is not None:
465 return err
466
467 err = write_file(os.path.join(self.sysfs_dir(), 'target_nid'), '%d' %
468 self.target_nid)
469 if err is not None:
470 return err
471
472 err = self.dests.stage()
473 if err is not None:
474 return err
475
476class DamonTarget:
477 pid = None
478 obsolete = None
479 # todo: Support target regions if test is made
480 idx = None
481 context = None
482
483 def __init__(self, pid, obsolete=False):
484 self.pid = pid
485 self.obsolete = obsolete
486
487 def sysfs_dir(self):
488 return os.path.join(
489 self.context.sysfs_dir(), 'targets', '%d' % self.idx)
490
491 def stage(self):
492 err = write_file(
493 os.path.join(self.sysfs_dir(), 'regions', 'nr_regions'), '0')
494 if err is not None:
495 return err
496 err = write_file(
497 os.path.join(self.sysfs_dir(), 'pid_target'), self.pid)
498 if err is not None:
499 return err
500 return write_file(
501 os.path.join(self.sysfs_dir(), 'obsolete_target'),
502 'Y' if self.obsolete else 'N')
503
504class IntervalsGoal:
505 access_bp = None
506 aggrs = None
507 min_sample_us = None
508 max_sample_us = None
509 attrs = None # owner DamonAttrs
510
511 def __init__(self, access_bp=0, aggrs=0, min_sample_us=0, max_sample_us=0):
512 self.access_bp = access_bp
513 self.aggrs = aggrs
514 self.min_sample_us = min_sample_us
515 self.max_sample_us = max_sample_us
516
517 def sysfs_dir(self):
518 return os.path.join(self.attrs.interval_sysfs_dir(), 'intervals_goal')
519
520 def stage(self):
521 err = write_file(
522 os.path.join(self.sysfs_dir(), 'access_bp'), self.access_bp)
523 if err is not None:
524 return err
525 err = write_file(os.path.join(self.sysfs_dir(), 'aggrs'), self.aggrs)
526 if err is not None:
527 return err
528 err = write_file(os.path.join(self.sysfs_dir(), 'min_sample_us'),
529 self.min_sample_us)
530 if err is not None:
531 return err
532 err = write_file(os.path.join(self.sysfs_dir(), 'max_sample_us'),
533 self.max_sample_us)
534 if err is not None:
535 return err
536 return None
537
538class DamonAttrs:
539 sample_us = None
540 aggr_us = None
541 intervals_goal = None
542 update_us = None
543 min_nr_regions = None
544 max_nr_regions = None
545 context = None
546
547 def __init__(self, sample_us=5000, aggr_us=100000,
548 intervals_goal=IntervalsGoal(), update_us=1000000,
549 min_nr_regions=10, max_nr_regions=1000):
550 self.sample_us = sample_us
551 self.aggr_us = aggr_us
552 self.intervals_goal = intervals_goal
553 self.intervals_goal.attrs = self
554 self.update_us = update_us
555 self.min_nr_regions = min_nr_regions
556 self.max_nr_regions = max_nr_regions
557
558 def interval_sysfs_dir(self):
559 return os.path.join(self.context.sysfs_dir(), 'monitoring_attrs',
560 'intervals')
561
562 def nr_regions_range_sysfs_dir(self):
563 return os.path.join(self.context.sysfs_dir(), 'monitoring_attrs',
564 'nr_regions')
565
566 def stage(self):
567 err = write_file(os.path.join(self.interval_sysfs_dir(), 'sample_us'),
568 self.sample_us)
569 if err is not None:
570 return err
571 err = write_file(os.path.join(self.interval_sysfs_dir(), 'aggr_us'),
572 self.aggr_us)
573 if err is not None:
574 return err
575 err = self.intervals_goal.stage()
576 if err is not None:
577 return err
578 err = write_file(os.path.join(self.interval_sysfs_dir(), 'update_us'),
579 self.update_us)
580 if err is not None:
581 return err
582
583 err = write_file(
584 os.path.join(self.nr_regions_range_sysfs_dir(), 'min'),
585 self.min_nr_regions)
586 if err is not None:
587 return err
588
589 err = write_file(
590 os.path.join(self.nr_regions_range_sysfs_dir(), 'max'),
591 self.max_nr_regions)
592 if err is not None:
593 return err
594
595class DamonCtx:
596 ops = None
597 monitoring_attrs = None
598 targets = None
599 schemes = None
600 kdamond = None
601 idx = None
602
603 def __init__(self, ops='paddr', monitoring_attrs=DamonAttrs(), targets=[],
604 schemes=[]):
605 self.ops = ops
606 self.monitoring_attrs = monitoring_attrs
607 self.monitoring_attrs.context = self
608
609 self.targets = targets
610 for idx, target in enumerate(self.targets):
611 target.idx = idx
612 target.context = self
613
614 self.schemes = schemes
615 for idx, scheme in enumerate(self.schemes):
616 scheme.idx = idx
617 scheme.context = self
618
619 def sysfs_dir(self):
620 return os.path.join(self.kdamond.sysfs_dir(), 'contexts',
621 '%d' % self.idx)
622
623 def stage(self):
624 err = write_file(
625 os.path.join(self.sysfs_dir(), 'operations'), self.ops)
626 if err is not None:
627 return err
628 err = self.monitoring_attrs.stage()
629 if err is not None:
630 return err
631
632 nr_targets_file = os.path.join(
633 self.sysfs_dir(), 'targets', 'nr_targets')
634 content, err = read_file(nr_targets_file)
635 if err is not None:
636 return err
637 if int(content) != len(self.targets):
638 err = write_file(nr_targets_file, '%d' % len(self.targets))
639 if err is not None:
640 return err
641 for target in self.targets:
642 err = target.stage()
643 if err is not None:
644 return err
645
646 nr_schemes_file = os.path.join(
647 self.sysfs_dir(), 'schemes', 'nr_schemes')
648 content, err = read_file(nr_schemes_file)
649 if err is not None:
650 return err
651 if int(content) != len(self.schemes):
652 err = write_file(nr_schemes_file, '%d' % len(self.schemes))
653 if err is not None:
654 return err
655 for scheme in self.schemes:
656 err = scheme.stage()
657 if err is not None:
658 return err
659 return None
660
661class Kdamond:
662 state = None
663 pid = None
664 contexts = None
665 idx = None # index of this kdamond between siblings
666 kdamonds = None # parent
667
668 def __init__(self, contexts=[]):
669 self.contexts = contexts
670 for idx, context in enumerate(self.contexts):
671 context.idx = idx
672 context.kdamond = self
673
674 def sysfs_dir(self):
675 return os.path.join(self.kdamonds.sysfs_dir(), '%d' % self.idx)
676
677 def start(self):
678 nr_contexts_file = os.path.join(self.sysfs_dir(),
679 'contexts', 'nr_contexts')
680 content, err = read_file(nr_contexts_file)
681 if err is not None:
682 return err
683 if int(content) != len(self.contexts):
684 err = write_file(nr_contexts_file, '%d' % len(self.contexts))
685 if err is not None:
686 return err
687
688 for context in self.contexts:
689 err = context.stage()
690 if err is not None:
691 return err
692 err = write_file(os.path.join(self.sysfs_dir(), 'state'), 'on')
693 if err is not None:
694 return err
695 self.pid, err = read_file(os.path.join(self.sysfs_dir(), 'pid'))
696 return err
697
698 def stop(self):
699 err = write_file(os.path.join(self.sysfs_dir(), 'state'), 'off')
700 return err
701
702 def update_schemes_tried_regions(self):
703 err = write_file(os.path.join(self.sysfs_dir(), 'state'),
704 'update_schemes_tried_regions')
705 if err is not None:
706 return err
707 for context in self.contexts:
708 for scheme in context.schemes:
709 tried_regions = []
710 tried_regions_dir = os.path.join(
711 scheme.sysfs_dir(), 'tried_regions')
712 region_indices = []
713 for filename in os.listdir(
714 os.path.join(scheme.sysfs_dir(), 'tried_regions')):
715 tried_region_dir = os.path.join(tried_regions_dir, filename)
716 if not os.path.isdir(tried_region_dir):
717 continue
718 region_indices.append(int(filename))
719 for region_idx in sorted(region_indices):
720 tried_region_dir = os.path.join(tried_regions_dir,
721 '%d' % region_idx)
722 region_values = []
723 for f in ['start', 'end', 'nr_accesses', 'age']:
724 content, err = read_file(
725 os.path.join(tried_region_dir, f))
726 if err is not None:
727 return err
728 region_values.append(int(content))
729 tried_regions.append(DamosTriedRegion(*region_values))
730 scheme.tried_regions = tried_regions
731
732 def update_schemes_tried_bytes(self):
733 err = write_file(os.path.join(self.sysfs_dir(), 'state'),
734 'update_schemes_tried_bytes')
735 if err is not None:
736 return err
737 for context in self.contexts:
738 for scheme in context.schemes:
739 content, err = read_file(os.path.join(scheme.sysfs_dir(),
740 'tried_regions', 'total_bytes'))
741 if err is not None:
742 return err
743 scheme.tried_bytes = int(content)
744
745 def update_schemes_stats(self):
746 err = write_file(os.path.join(self.sysfs_dir(), 'state'),
747 'update_schemes_stats')
748 if err is not None:
749 return err
750 for context in self.contexts:
751 for scheme in context.schemes:
752 stat_values = []
753 for stat in ['nr_tried', 'sz_tried', 'nr_applied',
754 'sz_applied', 'qt_exceeds']:
755 content, err = read_file(
756 os.path.join(scheme.sysfs_dir(), 'stats', stat))
757 if err is not None:
758 return err
759 stat_values.append(int(content))
760 scheme.stats = DamosStats(*stat_values)
761
762 def update_schemes_effective_quotas(self):
763 err = write_file(os.path.join(self.sysfs_dir(), 'state'),
764 'update_schemes_effective_quotas')
765 if err is not None:
766 return err
767 for context in self.contexts:
768 for scheme in context.schemes:
769 for goal in scheme.quota.goals:
770 content, err = read_file(
771 os.path.join(scheme.quota.sysfs_dir(),
772 'effective_bytes'))
773 if err is not None:
774 return err
775 goal.effective_bytes = int(content)
776 return None
777
778 def commit(self):
779 nr_contexts_file = os.path.join(self.sysfs_dir(),
780 'contexts', 'nr_contexts')
781 content, err = read_file(nr_contexts_file)
782 if err is not None:
783 return err
784 if int(content) != len(self.contexts):
785 err = write_file(nr_contexts_file, '%d' % len(self.contexts))
786 if err is not None:
787 return err
788
789 for context in self.contexts:
790 err = context.stage()
791 if err is not None:
792 return err
793 err = write_file(os.path.join(self.sysfs_dir(), 'state'), 'commit')
794 return err
795
796
797 def commit_schemes_quota_goals(self):
798 for context in self.contexts:
799 for scheme in context.schemes:
800 for goal in scheme.quota.goals:
801 err = goal.stage()
802 if err is not None:
803 print('commit_schemes_quota_goals failed stagign: %s'%
804 err)
805 exit(1)
806 return write_file(os.path.join(self.sysfs_dir(), 'state'),
807 'commit_schemes_quota_goals')
808
809class Kdamonds:
810 kdamonds = []
811
812 def __init__(self, kdamonds=[]):
813 self.kdamonds = kdamonds
814 for idx, kdamond in enumerate(self.kdamonds):
815 kdamond.idx = idx
816 kdamond.kdamonds = self
817
818 def sysfs_dir(self):
819 return os.path.join(sysfs_root, 'kdamonds')
820
821 def start(self):
822 err = write_file(os.path.join(self.sysfs_dir(), 'nr_kdamonds'),
823 '%s' % len(self.kdamonds))
824 if err is not None:
825 return err
826 for kdamond in self.kdamonds:
827 err = kdamond.start()
828 if err is not None:
829 return err
830 return None
831
832 def stop(self):
833 for kdamond in self.kdamonds:
834 err = kdamond.stop()
835 if err is not None:
836 return err
837 return None