class ProcStatTest(KernelProcFileTestBase.KernelProcFileTestBase):
'''/proc/stat provides kernel and system statistics.'''
start = 'stat'
t_CPU = literal_token(r'cpu[0-9]*')
t_INTR = literal_token(r'intr')
t_CTXT = literal_token(r'ctxt')
t_BTIME = literal_token(r'btime')
t_PROCESSES = literal_token(r'processes')
t_PROCS_RUNNING = literal_token(r'procs_running')
t_PROCS_BLOCKED = literal_token(r'procs_blocked')
t_SOFTIRQ = literal_token(r'softirq')
p_cpus = repeat_rule('cpu')
p_numbers = repeat_rule('NUMBER')
t_ignore = ' '
def p_stat(self, p):
'stat : cpus intr ctxt btime processes procs_running procs_blocked softirq'
p[0] = p[1:]
def p_cpu(self, p):
'cpu : CPU NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NEWLINE'
p[0] = p[1:]
def p_intr(self, p):
'intr : INTR NUMBERs NEWLINE'
p[0] = p[1:]
def p_ctxt(self, p):
'ctxt : CTXT NUMBER NEWLINE'
p[0] = p[1:]
def p_btime(self, p):
'btime : BTIME NUMBER NEWLINE'
p[0] = p[1:]
def p_processes(self, p):
'processes : PROCESSES NUMBER NEWLINE'
p[0] = p[1:]
def p_procs_running(self, p):
'procs_running : PROCS_RUNNING NUMBER NEWLINE'
p[0] = p[1:]
def p_procs_blocked(self, p):
'procs_blocked : PROCS_BLOCKED NUMBER NEWLINE'
p[0] = p[1:]
def p_softirq(self, p):
'softirq : SOFTIRQ NUMBERs NEWLINE'
p[0] = p[1:]
def get_path(self):
return "/proc/stat"
class ProcCpuInfoTest(KernelProcFileTestBase.KernelProcFileTestBase):
'''/proc/cpuinfo displays a collection of cpu and architecture specific items.
The file consists of multiple lines of 'identifier : values' where
'identifier' is a space separated name that can end in some tabs, and
'values' are space separated items that can also in in a space.
Extra newlines are allowed between normal lines.
'''
EXPECTED_FIELDS = [
['processor', ['\t']],
]
start = 'lines'
# Any character except for ':' and whitespace is allowed
t_STRING = r'[^:^ ^\t^\n]+'
# Numbers and literals are tokenized as strings instead
t_NUMBER = r'x'
t_HEX_LITERAL = r'x'
t_FLOAT = r'x'
p_lines = repeat_rule('line')
p_string_spaces = repeat_rule('string_space', zero_ok=True)
p_space_items = repeat_rule('space_item', zero_ok=True)
p_TABs = repeat_rule('TAB', zero_ok=True)
def p_line(self, p):
'''line : string_spaces STRING TABs COLON space_items SPACE NEWLINE
| string_spaces STRING TABs COLON space_items NEWLINE
| NEWLINE'''
if len(p) == 2:
p[0] = []
return
p[0] = [p[1] + [p[2], p[3]], p[5], p[6]]
def p_space_item(self, p):
'space_item : SPACE STRING'
p[0] = p[2]
def p_string_space(self, p):
'string_space : STRING SPACE'
p[0] = p[1]
def result_correct(self, parse_result):
expected_fields = self.EXPECTED_FIELDS[:]
for line in parse_result:
if len(line) > 0:
if line[0] in expected_fields:
expected_fields.remove(line[0])
return len(expected_fields) == 0
def get_path(self):
return "/proc/cpuinfo"
class ProcUidConcurrentPolicyTimeTest(
KernelProcFileTestBase.KernelProcFileTestBase):
'''/proc/uid_concurrent_policy_time provides the time each UID's processes spend
executing concurrently with processes on the same cluster.
This is an Android specific file.
'''
start = 'uid_policy_time_table'
t_POLICY = literal_token(r'policy')
p_policy_infos = repeat_rule('policy_info')
p_uid_policy_times = repeat_rule('uid_policy_time')
p_numbers = repeat_rule('NUMBER')
t_ignore = ' '
def p_uid_policy_time_table(self, p):
'uid_policy_time_table : header_row uid_policy_times'
p[0] = p[1:]
def p_header_row(self, p):
'header_row : policy_infos NEWLINE'
p[0] = sum(int(x) for x in p[1])
def p_policy_info(self, p):
'policy_info : POLICY NUMBER COLON NUMBER'
p[0] = p[4]
def p_uid_policy_time(self, p):
'uid_policy_time : NUMBER COLON NUMBERs NEWLINE'
p[0] = [p[1], p[3]]
def get_path(self):
return "/proc/uid_concurrent_policy_time"
def file_optional(self, shell=None, dut=None):
return True
def result_correct(self, result):
cpus, times = result
no_repeated_uids = len(set(x[0] for x in times)) == len(times)
row_lengths_match = all(len(time[1]) == int(cpus) for time in times)
return no_repeated_uids and row_lengths_match
class ProcUidConcurrentActiveTimeTest(
KernelProcFileTestBase.KernelProcFileTestBase):
'''/proc/uid_concurrent_active_time provides the time each UID's processes spend
executing concurrently with processes on other CPUs.
This is an Android specific file.
'''
start = 'uid_active_time_table'
t_CPU = literal_token(r'cpus')
p_uid_active_times = repeat_rule('uid_active_time')
p_numbers = repeat_rule('NUMBER')
t_ignore = ' '
def p_uid_active_time_table(self, p):
'uid_active_time_table : cpus uid_active_times'
p[0] = p[1:]
def p_cpus(self, p):
'cpus : CPU COLON NUMBER NEWLINE'
p[0] = p[3]
def p_uid_active_time(self, p):
'uid_active_time : NUMBER COLON NUMBERs NEWLINE'
p[0] = [p[1], p[3]]
def get_path(self):
return "/proc/uid_concurrent_active_time"
def file_optional(self, shell=None, dut=None):
return True
def result_correct(self, result):
cpus, times = result
no_repeated_uids = len(set(x[0] for x in times)) == len(times)
row_lengths_match = all(len(time[1]) == int(cpus) for time in times)
return no_repeated_uids and row_lengths_match
class ProcUidTimeInStateTest(KernelProcFileTestBase.KernelProcFileTestBase):
'''/proc/uid_time_in_state provides the time each UID's processes spend
executing at each available frequency.
This is an Android specific file.
'''
start = 'uid_time_table'
t_UID = literal_token(r'uid')
p_uid_times = repeat_rule('uid_time')
p_numbers = repeat_rule('NUMBER')
t_ignore = ' '
def p_uid_time_table(self, p):
'uid_time_table : freqs uid_times'
p[0] = p[1:]
def p_freqs(self, p):
'freqs : UID COLON NUMBERs NEWLINE'
p[0] = p[3]
def p_uid_time(self, p):
'uid_time : NUMBER COLON NUMBERs NEWLINE'
p[0] = [p[1], p[3]]
def get_path(self):
return "/proc/uid_time_in_state"
def file_optional(self, shell=None, dut=None):
return True
def result_correct(self, result):
freqs, times = result
return all(len(time[1]) == len(freqs) for time in times)
class ProcVmstat(KernelProcFileTestBase.KernelProcFileTestBase):
'''/proc/vmstat shows virtual memory statistics from the kernel.'''
t_ignore = ' '
start = 'lines'
p_lines = repeat_rule('line')
def p_line(self, p):
'line : STRING NUMBER NEWLINE'
p[0] = [p[1], p[2]]
def get_path(self):
return "/proc/vmstat"
class ProcDiskstatsTest(KernelProcFileTestBase.KernelProcFileTestBase):
'''/proc/diskstats displays I/O statistics of block devices.'''
t_ignore = ' '
start = 'lines'
p_lines = repeat_rule('line')
def p_line(self, p):
'''line : NUMBER NUMBER STRING NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NEWLINE
| NUMBER NUMBER STRING NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NEWLINE
| NUMBER NUMBER STRING NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NEWLINE'''
p[0] = p[1:]
def get_path(self):
return "/proc/diskstats"
class ProcUidIoStatsTest(KernelProcFileTestBase.KernelProcFileTestBase):
'''/proc/uid_io/stats returns a list of I/O stats for each UID in the system.
This is an Android specific file.
'''
t_ignore = ' '
start = 'lines'
p_lines = repeat_rule('line')
def p_line(self, p):
'''line : NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NEWLINE'''
p[0] = p[1:]
def get_path(self):
return "/proc/uid_io/stats"
class ProcAsoundCardsTest(KernelProcFileTestBase.KernelProcFileTestBase):
'''/proc/asound/cards shows the list of currently configured ALSA drivers.
List entries include index, the id string, short and long descriptions.'''
t_LBRACKET = literal_token(r'\[')
t_RBRACKET = literal_token(r'\]')
t_NO = literal_token(r'no')
t_SOUNDCARDS = literal_token(r'soundcards')
t_ignore = ' '
start = 'soundcards'
def p_soundcards(self, p):
'''soundcards : DASH DASH DASH NO SOUNDCARDS DASH DASH DASH NEWLINE
| drivers'''
p[0] = [p[4], p[5]] if len(p) == 10 else p[1]
p_drivers = repeat_rule('driver')
def p_driver(self, p):
'driver : NUMBER id COLON STRING DASH description NEWLINE description NEWLINE'
p[0] = [p[1], p[2], p[4], p[6], p[8]]
def p_description(self, p):
'''description : description word
| word'''
p[0] = [p[1]] if len(p) == 2 else p[1] + [p[2]]
def p_word(self, p):
'''word : NUMBER
| STRING
| COMMA
| PERIOD
| FLOAT
| DASH
| HEX_LITERAL'''
p[0] = p[1]
def p_id(self, p):
'id : LBRACKET STRING RBRACKET'
p[0] = p[2]
def get_path(self):
return "/proc/asound/cards"
class ProcMisc(KernelProcFileTestBase.KernelProcFileTestBase):
'''/proc/misc lists miscellaneous drivers registered on the miscellaneous
major device.
'''
t_ignore = ' '
start = 'drivers'
p_drivers = repeat_rule('driver')
def p_line(self, p):
'driver : NUMBER STRING NEWLINE'
p[0] = [p[1], p[2]]
def get_path(self):
return "/proc/misc"
class ProcVmallocInfoTest(KernelProcFileTestBase.KernelProcFileTestBase):
'''/proc/vmallocinfo provides info on vmalloc'd ranges.'''
start = 'lines'
def t_CALLER(self, t):
'[^ ^\t^\n^-^=^+^/]+\+0x[a-f0-9]+/0x[a-f0-9]+'
t.value = t.value.split('+')
return t
t_PAGES = literal_token('pages')
t_IOREMAP = literal_token('ioremap')
t_MODULE = literal_token('\[[^\n^\0]*\]')
t_VMALLOC = literal_token('vmalloc')
t_VMAP = literal_token('vmap')
t_USER = literal_token('user')
t_VPAGES = literal_token('vpages')
t_VM_AREA = literal_token('vm_area')
t_UNPURGED = literal_token('unpurged')
t_VM_MAP_RAM = literal_token('vm_map_ram')
t_DMA_COHERENT = literal_token('dma-coherent')
t_ignore = ' '
def t_PHYS(self, t):
r'phys=(0x)?[a-f0-9]+'
t.value = [t.value[:4], int(t.value[5:], 16)]
return t
def t_NODES(self, t):
r'N[0-9]+=[1-9][0-9]*'
t.value = t.value.split('=', 1)
return t
p_lines = repeat_rule('line')
p_nodes = repeat_rule('node')
def p_line(self, p):
'line : addr_range NUMBER caller module pages phys ioremap vmalloc vmap user dma_coherent vpages vm_vm_area nodes NEWLINE'
p[0] = p[1:]
def p_addr_range(self, p):
'addr_range : HEX_LITERAL DASH HEX_LITERAL'
p[0] = [p[1], p[3]]
def p_module(self, p):
'''module : MODULE
| empty'''
p[0] = p[1]
def p_pages(self, p):
'''pages : PAGES EQUALS NUMBER
| empty'''
p[0] = [] if len(p) == 2 else [p[1], p[3]]
def p_phys(self, p):
'''phys : PHYS
| empty'''
p[0] = p[1]
def p_ioremap(self, p):
'''ioremap : IOREMAP
| empty'''
p[0] = p[1]
def p_vmalloc(self, p):
'''vmalloc : VMALLOC
| empty'''
p[0] = p[1]
def p_dma_coherent(self, p):
'''dma_coherent : DMA_COHERENT
| empty'''
p[0] = p[1]
def p_vmap(self, p):
'''vmap : VMAP
| empty'''
p[0] = p[1]
def p_user(self, p):
'''user : USER
| empty'''
p[0] = p[1]
def p_vpages(self, p):
'''vpages : VPAGES
| empty'''
p[0] = p[1]
def p_vm_vm_area(self, p):
'''vm_vm_area : UNPURGED VM_AREA
| VM_MAP_RAM
| empty'''
if len(p) == 2:
p[0] = []
else:
p[0] = p[1:]
def p_node(self, p):
'''node : NODES
| empty'''
p[0] = [1]
def p_caller(self, p):
'''caller : CALLER
| HEX_LITERAL
| empty'''
p[0] = p[1]
def get_path(self):
return "/proc/vmallocinfo"
class ProcZoneInfoTest(KernelProcFileTestBase.KernelProcFileTestBase):
'''/proc/zoneinfo displays information about memory zones.'''
t_APAGES = literal_token(r'pages\s')
t_PAGESETS = literal_token(r'pagesets')
t_CPU = literal_token(r'cpu')
t_VM = literal_token(r'vm')
t_STATS = literal_token(r'stats')
t_THRESHOLD = literal_token(r'threshold')
t_NODE = literal_token(r'Node')
t_ZONE = literal_token(r'zone')
t_PROTECTION = literal_token(r'protection')
t_PERNODE = literal_token(r'per-node')
t_LPAREN = literal_token(r'\(')
t_RPAREN = literal_token(r'\)')
t_ignore = ' '
start = 'nodes'
p_nodes = repeat_rule('node')
p_lines = repeat_rule('line')
p_cpus = repeat_rule('cpu')
p_colonlines = repeat_rule('colonline')
p_numcommas = repeat_rule('numcomma')
def p_node(self, p):
'''node : heading pernode APAGES lines protection populated'''
p[0] = [p[1], p[2], p[4], p[5], p[6]]
def p_populated(self, p):
'''populated : PAGESETS NEWLINE cpus colonlines
| lines PAGESETS NEWLINE cpus colonlines
| empty'''
if len(p) == 2:
p[0] = []
elif len(p) == 6:
p[0] = [p[1], p[4], p[5]]
else:
p[0] = [p[3], p[4]]
def p_pernode(self, p):
'''pernode : PERNODE STATS NEWLINE lines
| empty'''
p[0] = [] if len(p) == 2 else [p[1], p[4]]
def p_protection(self, p):
'protection : PROTECTION COLON LPAREN numcommas NUMBER RPAREN NEWLINE'
p[0] = p[4] + [p[5]]
def p_numcomma(self, p):
'numcomma : NUMBER COMMA'
p[0] = p[1]
def p_line(self, p):
'''line : STRING NUMBER NEWLINE
| NUMBER NEWLINE'''
if len(p) == 4:
p[0] = p[1:3]
else:
p[0] = p[1]
def p_cpu(self, p):
'cpu : CPU COLON NUMBER NEWLINE colonline colonline colonline \
VM STATS THRESHOLD COLON NUMBER NEWLINE'
p[0] = [p[3], p[5], p[6], p[7], [p[10], p[12]]]
def p_colonline(self, p):
'colonline : STRING COLON NUMBER NEWLINE'
p[0] = [p[1], p[3]]
def p_heading(self, p):
'heading : NODE NUMBER COMMA ZONE STRING NEWLINE'
p[0] = [p[2], p[5]]
def get_path(self):
return "/proc/zoneinfo"