ACIL FM

Nama	Ukuran	Aksi
clk.py	2.46 MB	View DL Edit
config.py	1.27 MB	View DL Edit
constants.py.in	3.15 MB	View DL Edit
cpus.py	5.2 MB	View DL Edit
device.py	5.65 MB	View DL Edit
dmesg.py	5.82 MB	View DL Edit
genpd.py	2.52 MB	View DL Edit
lists.py	4.16 MB	View DL Edit
Makefile	667 B	View DL Edit
mm.py	13.98 MB	View DL Edit
modules.py	2.75 MB	View DL Edit
pgtable.py	10.08 MB	View DL Edit
proc.py	8.54 MB	View DL Edit
rbtree.py	4.25 MB	View DL Edit
symbols.py	6.92 MB	View DL Edit
tasks.py	3.55 MB	View DL Edit
timerlist.py	7.55 MB	View DL Edit
utils.py	5.03 MB	View DL Edit
__init__.py	55 B	View DL Edit

Edit file: /usr/src/kernels/5.14.0-611.27.1.el9_7.x86_64/scripts/gdb/linux/cpus.py

#
# gdb helper commands and functions for Linux kernel debugging
#
#  per-cpu tools
#
# Copyright (c) Siemens AG, 2011-2013
#
# Authors:
#  Jan Kiszka <jan.kiszka@siemens.com>
#
# This work is licensed under the terms of the GNU GPL version 2.
#

import gdb

from linux import tasks, utils

task_type = utils.CachedType("struct task_struct")

MAX_CPUS = 4096

def get_current_cpu():
    if utils.get_gdbserver_type() == utils.GDBSERVER_QEMU:
        return gdb.selected_thread().num - 1
    elif utils.get_gdbserver_type() == utils.GDBSERVER_KGDB:
        tid = gdb.selected_thread().ptid[2]
        if tid > (0x100000000 - MAX_CPUS - 2):
            return 0x100000000 - tid - 2
        else:
            return tasks.get_thread_info(tasks.get_task_by_pid(tid))['cpu']
    else:
        raise gdb.GdbError("Sorry, obtaining the current CPU is not yet "
                           "supported with this gdb server.")

def per_cpu(var_ptr, cpu):
    if cpu == -1:
        cpu = get_current_cpu()
    if utils.is_target_arch("sparc:v9"):
        offset = gdb.parse_and_eval(
            "trap_block[{0}].__per_cpu_base".format(str(cpu)))
    else:
        try:
            offset = gdb.parse_and_eval(
                "__per_cpu_offset[{0}]".format(str(cpu)))
        except gdb.error:
            # !CONFIG_SMP case
            offset = 0
    pointer = var_ptr.cast(utils.get_long_type()) + offset
    return pointer.cast(var_ptr.type).dereference()

cpu_mask = {}

def cpu_mask_invalidate(event):
    global cpu_mask
    cpu_mask = {}
    gdb.events.stop.disconnect(cpu_mask_invalidate)
    if hasattr(gdb.events, 'new_objfile'):
        gdb.events.new_objfile.disconnect(cpu_mask_invalidate)

def cpu_list(mask_name):
    global cpu_mask
    mask = None
    if mask_name in cpu_mask:
        mask = cpu_mask[mask_name]
    if mask is None:
        mask = gdb.parse_and_eval(mask_name + ".bits")
        if hasattr(gdb, 'events'):
            cpu_mask[mask_name] = mask
            gdb.events.stop.connect(cpu_mask_invalidate)
            if hasattr(gdb.events, 'new_objfile'):
                gdb.events.new_objfile.connect(cpu_mask_invalidate)
    bits_per_entry = mask[0].type.sizeof * 8
    num_entries = mask.type.sizeof * 8 / bits_per_entry
    entry = -1
    bits = 0

while True:
        while bits == 0:
            entry += 1
            if entry == num_entries:
                return
            bits = mask[entry]
            if bits != 0:
                bit = 0
                break

while bits & 1 == 0:
            bits >>= 1
            bit += 1

cpu = entry * bits_per_entry + bit

bits >>= 1
        bit += 1

yield int(cpu)

def each_online_cpu():
    for cpu in cpu_list("__cpu_online_mask"):
        yield cpu

def each_present_cpu():
    for cpu in cpu_list("__cpu_present_mask"):
        yield cpu

def each_possible_cpu():
    for cpu in cpu_list("__cpu_possible_mask"):
        yield cpu

def each_active_cpu():
    for cpu in cpu_list("__cpu_active_mask"):
        yield cpu

class LxCpus(gdb.Command):
    """List CPU status arrays

Displays the known state of each CPU based on the kernel masks
and can help identify the state of hotplugged CPUs"""

def __init__(self):
        super(LxCpus, self).__init__("lx-cpus", gdb.COMMAND_DATA)

def invoke(self, arg, from_tty):
        gdb.write("Possible CPUs : {}\n".format(list(each_possible_cpu())))
        gdb.write("Present CPUs  : {}\n".format(list(each_present_cpu())))
        gdb.write("Online CPUs   : {}\n".format(list(each_online_cpu())))
        gdb.write("Active CPUs   : {}\n".format(list(each_active_cpu())))

LxCpus()

class PerCpu(gdb.Function):
    """Return per-cpu variable.

$lx_per_cpu("VAR"[, CPU]): Return the per-cpu variable called VAR for the
given CPU number. If CPU is omitted, the CPU of the current context is used.
Note that VAR has to be quoted as string."""

def __init__(self):
        super(PerCpu, self).__init__("lx_per_cpu")

def invoke(self, var_name, cpu=-1):
        var_ptr = gdb.parse_and_eval("&" + var_name.string())
        return per_cpu(var_ptr, cpu)

PerCpu()

def get_current_task(cpu):
    task_ptr_type = task_type.get_type().pointer()

if utils.is_target_arch("x86"):
         var_ptr = gdb.parse_and_eval("&pcpu_hot.current_task")
         return per_cpu(var_ptr, cpu).dereference()
    elif utils.is_target_arch("aarch64"):
         current_task_addr = gdb.parse_and_eval("$SP_EL0")
         if((current_task_addr >> 63) != 0):
             current_task = current_task_addr.cast(task_ptr_type)
             return current_task.dereference()
         else:
             raise gdb.GdbError("Sorry, obtaining the current task is not allowed "
                                "while running in userspace(EL0)")
    else:
        raise gdb.GdbError("Sorry, obtaining the current task is not yet "
                           "supported with this arch")

class LxCurrentFunc(gdb.Function):
    """Return current task.

$lx_current([CPU]): Return the per-cpu task variable for the given CPU
number. If CPU is omitted, the CPU of the current context is used."""

def __init__(self):
        super(LxCurrentFunc, self).__init__("lx_current")

def invoke(self, cpu=-1):
        return get_current_task(cpu)

LxCurrentFunc()

Batal