Exemple #1
0
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"
Exemple #2
0
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)
Exemple #6
0
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"
Exemple #7
0
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"
Exemple #9
0
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"
Exemple #10
0
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"
Exemple #12
0
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"