Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1# SPDX-License-Identifier: GPL-2.0
2
3import configparser
4import os
5import sys
6import glob
7import optparse
8import platform
9import tempfile
10import logging
11import re
12import shutil
13import subprocess
14
15def data_equal(a, b):
16 # Allow multiple values in assignment separated by '|'
17 a_list = a.split('|')
18 b_list = b.split('|')
19
20 for a_item in a_list:
21 for b_item in b_list:
22 if (a_item == b_item):
23 return True
24 elif (a_item == '*') or (b_item == '*'):
25 return True
26
27 return False
28
29class Fail(Exception):
30 def __init__(self, test, msg):
31 self.msg = msg
32 self.test = test
33 def getMsg(self):
34 return '\'%s\' - %s' % (self.test.path, self.msg)
35
36class Notest(Exception):
37 def __init__(self, test, arch):
38 self.arch = arch
39 self.test = test
40 def getMsg(self):
41 return '[%s] \'%s\'' % (self.arch, self.test.path)
42
43class Unsup(Exception):
44 def __init__(self, test):
45 self.test = test
46 def getMsg(self):
47 return '\'%s\'' % self.test.path
48
49class Event(dict):
50 terms = [
51 'cpu',
52 'flags',
53 'type',
54 'size',
55 'config',
56 'sample_period',
57 'sample_type',
58 'read_format',
59 'disabled',
60 'inherit',
61 'pinned',
62 'exclusive',
63 'exclude_user',
64 'exclude_kernel',
65 'exclude_hv',
66 'exclude_idle',
67 'mmap',
68 'comm',
69 'freq',
70 'inherit_stat',
71 'enable_on_exec',
72 'task',
73 'watermark',
74 'precise_ip',
75 'mmap_data',
76 'sample_id_all',
77 'exclude_host',
78 'exclude_guest',
79 'exclude_callchain_kernel',
80 'exclude_callchain_user',
81 'wakeup_events',
82 'bp_type',
83 'config1',
84 'config2',
85 'branch_sample_type',
86 'sample_regs_user',
87 'sample_stack_user',
88 ]
89
90 def add(self, data):
91 for key, val in data:
92 log.debug(" %s = %s" % (key, val))
93 self[key] = val
94
95 def __init__(self, name, data, base):
96 log.debug(" Event %s" % name);
97 self.name = name;
98 self.group = ''
99 self.add(base)
100 self.add(data)
101
102 def equal(self, other):
103 for t in Event.terms:
104 log.debug(" [%s] %s %s" % (t, self[t], other[t]));
105 if t not in self or t not in other:
106 return False
107 if not data_equal(self[t], other[t]):
108 return False
109 return True
110
111 def optional(self):
112 if 'optional' in self and self['optional'] == '1':
113 return True
114 return False
115
116 def diff(self, other):
117 for t in Event.terms:
118 if t not in self or t not in other:
119 continue
120 if not data_equal(self[t], other[t]):
121 log.warning("expected %s=%s, got %s" % (t, self[t], other[t]))
122
123def parse_version(version):
124 if not version:
125 return None
126 return [int(v) for v in version.split(".")[0:2]]
127
128# Test file description needs to have following sections:
129# [config]
130# - just single instance in file
131# - needs to specify:
132# 'command' - perf command name
133# 'args' - special command arguments
134# 'ret' - Skip test if Perf doesn't exit with this value (0 by default)
135# 'test_ret'- If set to 'true', fail test instead of skipping for 'ret' argument
136# 'arch' - architecture specific test (optional)
137# comma separated list, ! at the beginning
138# negates it.
139# 'auxv' - Truthy statement that is evaled in the scope of the auxv map. When false,
140# the test is skipped. For example 'auxv["AT_HWCAP"] == 10'. (optional)
141# 'kernel_since' - Inclusive kernel version from which the test will start running. Only the
142# first two values are supported, for example "6.1" (optional)
143# 'kernel_until' - Exclusive kernel version from which the test will stop running. (optional)
144# [eventX:base]
145# - one or multiple instances in file
146# - expected values assignments
147class Test(object):
148 def __init__(self, path, options):
149 parser = configparser.ConfigParser()
150 parser.read(path)
151
152 log.warning("running '%s'" % path)
153
154 self.path = path
155 self.test_dir = options.test_dir
156 self.perf = options.perf
157 self.command = parser.get('config', 'command')
158 self.args = parser.get('config', 'args')
159
160 try:
161 self.ret = parser.get('config', 'ret')
162 except:
163 self.ret = 0
164
165 self.test_ret = parser.getboolean('config', 'test_ret', fallback=False)
166
167 try:
168 self.arch = parser.get('config', 'arch')
169 log.warning("test limitation '%s'" % self.arch)
170 except:
171 self.arch = ''
172
173 self.auxv = parser.get('config', 'auxv', fallback=None)
174 self.kernel_since = parse_version(parser.get('config', 'kernel_since', fallback=None))
175 self.kernel_until = parse_version(parser.get('config', 'kernel_until', fallback=None))
176 self.expect = {}
177 self.result = {}
178 log.debug(" loading expected events");
179 self.load_events(path, self.expect)
180
181 def is_event(self, name):
182 if name.find("event") == -1:
183 return False
184 else:
185 return True
186
187 def skip_test_kernel_since(self):
188 if not self.kernel_since:
189 return False
190 return not self.kernel_since <= parse_version(platform.release())
191
192 def skip_test_kernel_until(self):
193 if not self.kernel_until:
194 return False
195 return not parse_version(platform.release()) < self.kernel_until
196
197 def skip_test_auxv(self):
198 def new_auxv(a, pattern):
199 items = list(filter(None, pattern.split(a)))
200 # AT_HWCAP is hex but doesn't have a prefix, so special case it
201 if items[0] == "AT_HWCAP":
202 value = int(items[-1], 16)
203 else:
204 try:
205 value = int(items[-1], 0)
206 except:
207 value = items[-1]
208 return (items[0], value)
209
210 if not self.auxv:
211 return False
212 auxv = subprocess.check_output("LD_SHOW_AUXV=1 sleep 0", shell=True) \
213 .decode(sys.stdout.encoding)
214 pattern = re.compile(r"[: ]+")
215 auxv = dict([new_auxv(a, pattern) for a in auxv.splitlines()])
216 return not eval(self.auxv)
217
218 def skip_test_arch(self, myarch):
219 # If architecture not set always run test
220 if self.arch == '':
221 # log.warning("test for arch %s is ok" % myarch)
222 return False
223
224 # Allow multiple values in assignment separated by ','
225 arch_list = self.arch.split(',')
226
227 # Handle negated list such as !s390x,ppc
228 if arch_list[0][0] == '!':
229 arch_list[0] = arch_list[0][1:]
230 log.warning("excluded architecture list %s" % arch_list)
231 for arch_item in arch_list:
232 # log.warning("test for %s arch is %s" % (arch_item, myarch))
233 if arch_item == myarch:
234 return True
235 return False
236
237 for arch_item in arch_list:
238 # log.warning("test for architecture '%s' current '%s'" % (arch_item, myarch))
239 if arch_item == myarch:
240 return False
241 return True
242
243 def restore_sample_rate(self, value=10000):
244 try:
245 # Check value of sample_rate
246 with open("/proc/sys/kernel/perf_event_max_sample_rate", "r") as fIn:
247 curr_value = fIn.readline()
248 # If too low restore to reasonable value
249 if not curr_value or int(curr_value) < int(value):
250 with open("/proc/sys/kernel/perf_event_max_sample_rate", "w") as fOut:
251 fOut.write(str(value))
252
253 except IOError as e:
254 log.warning("couldn't restore sample_rate value: I/O error %s" % e)
255 except ValueError as e:
256 log.warning("couldn't restore sample_rate value: Value error %s" % e)
257 except TypeError as e:
258 log.warning("couldn't restore sample_rate value: Type error %s" % e)
259
260 def load_events(self, path, events):
261 parser_event = configparser.ConfigParser()
262 parser_event.read(path)
263
264 # The event record section header contains 'event' word,
265 # optionaly followed by ':' allowing to load 'parent
266 # event' first as a base
267 for section in filter(self.is_event, parser_event.sections()):
268
269 parser_items = parser_event.items(section);
270 base_items = {}
271
272 # Read parent event if there's any
273 if (':' in section):
274 base = section[section.index(':') + 1:]
275 parser_base = configparser.ConfigParser()
276 parser_base.read(self.test_dir + '/' + base)
277 base_items = parser_base.items('event')
278
279 e = Event(section, parser_items, base_items)
280 events[section] = e
281
282 def run_cmd(self, tempdir):
283 junk1, junk2, junk3, junk4, myarch = (os.uname())
284
285 if self.skip_test_arch(myarch):
286 raise Notest(self, myarch)
287
288 if self.skip_test_auxv():
289 raise Notest(self, "auxv skip")
290
291 if self.skip_test_kernel_since():
292 raise Notest(self, "old kernel skip")
293
294 if self.skip_test_kernel_until():
295 raise Notest(self, "new kernel skip")
296
297 self.restore_sample_rate()
298 cmd = "PERF_TEST_ATTR=%s %s %s -o %s/perf.data %s" % (tempdir,
299 self.perf, self.command, tempdir, self.args)
300 ret = os.WEXITSTATUS(os.system(cmd))
301
302 log.info(" '%s' ret '%s', expected '%s'" % (cmd, str(ret), str(self.ret)))
303
304 if not data_equal(str(ret), str(self.ret)):
305 if self.test_ret:
306 raise Fail(self, "Perf exit code failure")
307 else:
308 raise Unsup(self)
309
310 def compare(self, expect, result):
311 match = {}
312
313 log.debug(" compare");
314
315 # For each expected event find all matching
316 # events in result. Fail if there's not any.
317 for exp_name, exp_event in expect.items():
318 exp_list = []
319 res_event = {}
320 log.debug(" matching [%s]" % exp_name)
321 for res_name, res_event in result.items():
322 log.debug(" to [%s]" % res_name)
323 if (exp_event.equal(res_event)):
324 exp_list.append(res_name)
325 log.debug(" ->OK")
326 else:
327 log.debug(" ->FAIL");
328
329 log.debug(" match: [%s] matches %s" % (exp_name, str(exp_list)))
330
331 # we did not any matching event - fail
332 if not exp_list:
333 if exp_event.optional():
334 log.debug(" %s does not match, but is optional" % exp_name)
335 else:
336 if not res_event:
337 log.debug(" res_event is empty");
338 else:
339 exp_event.diff(res_event)
340 raise Fail(self, 'match failure');
341
342 match[exp_name] = exp_list
343
344 # For each defined group in the expected events
345 # check we match the same group in the result.
346 for exp_name, exp_event in expect.items():
347 group = exp_event.group
348
349 if (group == ''):
350 continue
351
352 for res_name in match[exp_name]:
353 res_group = result[res_name].group
354 if res_group not in match[group]:
355 raise Fail(self, 'group failure')
356
357 log.debug(" group: [%s] matches group leader %s" %
358 (exp_name, str(match[group])))
359
360 log.debug(" matched")
361
362 def resolve_groups(self, events):
363 for name, event in events.items():
364 group_fd = event['group_fd'];
365 if group_fd == '-1':
366 continue;
367
368 for iname, ievent in events.items():
369 if (ievent['fd'] == group_fd):
370 event.group = iname
371 log.debug('[%s] has group leader [%s]' % (name, iname))
372 break;
373
374 def run(self):
375 tempdir = tempfile.mkdtemp();
376
377 try:
378 # run the test script
379 self.run_cmd(tempdir);
380
381 # load events expectation for the test
382 log.debug(" loading result events");
383 for f in glob.glob(tempdir + '/event*'):
384 self.load_events(f, self.result);
385
386 # resolve group_fd to event names
387 self.resolve_groups(self.expect);
388 self.resolve_groups(self.result);
389
390 # do the expectation - results matching - both ways
391 self.compare(self.expect, self.result)
392 self.compare(self.result, self.expect)
393
394 finally:
395 # cleanup
396 shutil.rmtree(tempdir)
397
398
399def run_tests(options):
400 for f in glob.glob(options.test_dir + '/' + options.test):
401 try:
402 Test(f, options).run()
403 except Unsup as obj:
404 log.warning("unsupp %s" % obj.getMsg())
405 except Notest as obj:
406 log.warning("skipped %s" % obj.getMsg())
407
408def setup_log(verbose):
409 global log
410 level = logging.CRITICAL
411
412 if verbose == 1:
413 level = logging.WARNING
414 if verbose == 2:
415 level = logging.INFO
416 if verbose >= 3:
417 level = logging.DEBUG
418
419 log = logging.getLogger('test')
420 log.setLevel(level)
421 ch = logging.StreamHandler()
422 ch.setLevel(level)
423 formatter = logging.Formatter('%(message)s')
424 ch.setFormatter(formatter)
425 log.addHandler(ch)
426
427USAGE = '''%s [OPTIONS]
428 -d dir # tests dir
429 -p path # perf binary
430 -t test # single test
431 -v # verbose level
432''' % sys.argv[0]
433
434def main():
435 parser = optparse.OptionParser(usage=USAGE)
436
437 parser.add_option("-t", "--test",
438 action="store", type="string", dest="test")
439 parser.add_option("-d", "--test-dir",
440 action="store", type="string", dest="test_dir")
441 parser.add_option("-p", "--perf",
442 action="store", type="string", dest="perf")
443 parser.add_option("-v", "--verbose",
444 default=0, action="count", dest="verbose")
445
446 options, args = parser.parse_args()
447 if args:
448 parser.error('FAILED wrong arguments %s' % ' '.join(args))
449 return -1
450
451 setup_log(options.verbose)
452
453 if not options.test_dir:
454 print('FAILED no -d option specified')
455 sys.exit(-1)
456
457 if not options.test:
458 options.test = 'test*'
459
460 try:
461 run_tests(options)
462
463 except Fail as obj:
464 print("FAILED %s" % obj.getMsg())
465 sys.exit(-1)
466
467 sys.exit(0)
468
469if __name__ == '__main__':
470 main()