def get_super_block(desc: AddressSpecifier, force: bool = False) -> gdb.Value:
"""
Given an address description return a gdb.Value that contains
a struct super_block at that address.
Args:
desc: The address for which to provide a casted pointer. The address
may be specified using an existing Value, an integer address,
or a hexadecimal address represented as a 0x-prefixed string.
force: Skip testing whether the value is available.
Returns:
:obj:`gdb.Value`: The super block at the requested location.
The value will be ``struct super_block``.
Raises:
:obj:`gdb.NotAvailableError`: The target value was not available.
"""
sb = get_typed_pointer(desc, types.super_block_type).dereference()
if not force:
try:
x = int(sb['s_dev']) # pylint: disable=unused-variable
except gdb.NotAvailableError:
raise gdb.NotAvailableError(f"no superblock available at `{desc}'")
return sb
def test_inode_on_bdev_poison_inode(self):
inode = util.get_typed_pointer(self.poisonptr, self.inode_type)
inode = inode.dereference()
self.assertTrue(type(inode) is gdb.Value)
self.assertTrue(inode.type == self.inode_type)
with self.assertRaises(gdb.NotAvailableError):
bdev = storage.inode_on_bdev(inode)
def test_for_each_block_device_filtered_nullptr(self):
null_type = util.get_typed_pointer(self.nullptr,
storage.types.device_type_type)
# The pointer is only used for comparison so we won't raise
# an exception but we won't get any results either.
for bdev in storage.for_each_block_device(null_type.dereference()):
self.assertTrue(False)
def test_inode_to_block_device_null_inode(self):
inode = util.get_typed_pointer(self.nullptr, self.inode_type)
inode = inode.dereference()
self.assertTrue(type(inode) is gdb.Value)
self.assertTrue(inode.type == self.inode_type)
with self.assertRaises(gdb.NotAvailableError):
bdev = storage.inode_to_block_device(inode)
def find_kn(addr: AddressSpecifier) -> gdb.Value:
"""
Finds ``struct kernfs_node`` by given address.
Note: Function does no checking whether address points to ``struct
kernfs_node``. This may change in future.
Args:
addr: representation of memory address
Returns:
:obj:`gdb.Value`: ``struct kernfs_node``
"""
kn = get_typed_pointer(addr, types.kernfs_node_type).dereference()
return kn
def page_owner(self) -> Optional[gdb.Value]:
if self._page_owner is not None:
return self._page_owner
page_ext = self.page_ext
if page_ext is None:
return None
page_owner_offset = int(symvals.page_owner_ops["offset"])
page_owner = get_typed_pointer(self._page_ext_addr + page_owner_offset,
types.page_owner_type)
self._page_owner = page_owner.dereference()
return self._page_owner
def page_ext(self) -> Optional[gdb.Value]:
if self._page_ext is not None:
return self._page_ext
section = Page.pfn_to_section(self.pfn)
base = section["page_ext"]
if int(base) == 0:
return None
try:
page_ext_size = int(symvals.page_ext_size)
except DelayedAttributeError:
page_ext_size = int(symvals.extra_mem) + types.page_ext_type.sizeof
page_ext_addr = int(base) + self.pfn * page_ext_size
page_ext = get_typed_pointer(page_ext_addr, base.type)
if int(page_ext) == 0:
return None
self._page_ext_addr = page_ext_addr
self._page_ext = page_ext.dereference()
return self._page_ext
def test_gendisk_name_disk_poison_bdev(self):
bdev = util.get_typed_pointer(self.poisonptr, self.block_device_type)
bdev = bdev.dereference()
with self.assertRaises(gdb.NotAvailableError):
name = storage.gendisk_name(bdev['bd_disk'])
def test_block_device_name_poisonptr(self):
bdev = util.get_typed_pointer(self.poisonptr, self.block_device_type).dereference()
self.assertTrue(type(bdev) is gdb.Value)
self.assertTrue(bdev.type == self.block_device_type)
with self.assertRaises(gdb.NotAvailableError):
name = storage.block_device_name(bdev)
def _symname(cls, kallsyms: gdb.Value, symnum: int) -> str:
offset = int(kallsyms["symtab"][symnum]["st_name"])
string_addr = int(kallsyms["strtab"]) + offset
string = get_typed_pointer(string_addr, types.char_p_type)
return string.string()
