ladybird/Userland/Utilities/lspci.cpp
Ali Mohammad Pur 5e1499d104 Everywhere: Rename {Deprecated => Byte}String
This commit un-deprecates DeprecatedString, and repurposes it as a byte
string.
As the null state has already been removed, there are no other
particularly hairy blockers in repurposing this type as a byte string
(what it _really_ is).

This commit is auto-generated:
  $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \
    Meta Ports Ladybird Tests Kernel)
  $ perl -pie 's/\bDeprecatedString\b/ByteString/g;
    s/deprecated_string/byte_string/g' $xs
  $ clang-format --style=file -i \
    $(git diff --name-only | grep \.cpp\|\.h)
  $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-17 18:25:10 +03:30

203 lines
8.3 KiB
C++

/*
* Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
* Copyright (c) 2022, the SerenityOS developers.
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/ByteString.h>
#include <AK/Hex.h>
#include <AK/JsonArray.h>
#include <AK/JsonObject.h>
#include <AK/StringUtils.h>
#include <AK/StringView.h>
#include <LibCore/ArgsParser.h>
#include <LibCore/DirIterator.h>
#include <LibCore/File.h>
#include <LibCore/System.h>
#include <LibMain/Main.h>
#include <LibPCIDB/Database.h>
static bool flag_show_numerical = false;
static bool flag_verbose = false;
static constexpr StringView format_numerical = "{:04x}:{:02x}:{:02x}.{} {}: {}:{} (rev {:02x})"sv;
static constexpr StringView format_textual = "{:04x}:{:02x}:{:02x}.{} {}: {} {} (rev {:02x})"sv;
static constexpr StringView format_region = "\tBAR {}: {} region @ {:#x}"sv;
static u32 read_hex_string_from_bytebuffer(ByteBuffer const& buf)
{
// FIXME: Propagate errors.
return AK::StringUtils::convert_to_uint_from_hex(
ByteString(MUST(buf.slice(2, buf.size() - 2)).bytes()))
.release_value();
}
static u32 convert_sysfs_value_to_uint(ByteString const& value)
{
if (auto result = AK::StringUtils::convert_to_uint_from_hex(value); result.has_value())
return result.release_value();
if (auto result = AK::StringUtils::convert_to_uint(value); result.has_value())
return result.release_value();
VERIFY_NOT_REACHED();
}
ErrorOr<int> serenity_main(Main::Arguments arguments)
{
TRY(Core::System::pledge("stdio rpath"));
Core::ArgsParser args_parser;
args_parser.set_general_help("List PCI devices.");
args_parser.add_option(flag_show_numerical, "Show numerical IDs", "numerical", 'n');
args_parser.add_option(flag_verbose, "Show verbose info on devices", "verbose", 'v');
args_parser.parse(arguments);
if (!flag_show_numerical)
TRY(Core::System::unveil("/res/pci.ids", "r"));
TRY(Core::System::unveil("/sys/bus/pci", "r"));
TRY(Core::System::unveil(nullptr, nullptr));
auto const format = flag_show_numerical ? format_numerical : format_textual;
RefPtr<PCIDB::Database> db;
if (!flag_show_numerical) {
db = PCIDB::Database::open();
if (!db) {
warnln("Couldn't open PCI ID database");
flag_show_numerical = true;
}
}
Core::DirIterator di("/sys/bus/pci/", Core::DirIterator::SkipParentAndBaseDir);
if (di.has_error()) {
auto error = di.error();
warnln("Failed to open /sys/bus/pci - {}", error);
return error;
}
TRY(Core::System::pledge("stdio rpath"));
while (di.has_next()) {
auto dir = di.next_path();
auto domain_bus_device_parts = dir.split(':');
VERIFY(domain_bus_device_parts.size() == 3);
auto domain = convert_sysfs_value_to_uint(domain_bus_device_parts[0]);
auto bus = convert_sysfs_value_to_uint(domain_bus_device_parts[1]);
auto device = convert_sysfs_value_to_uint(domain_bus_device_parts[2].split('.')[0]);
auto function_parts = dir.split('.');
VERIFY(function_parts.size() == 2);
auto function = convert_sysfs_value_to_uint(function_parts[1]);
auto vendor_id_filename = ByteString::formatted("/sys/bus/pci/{}/vendor", dir);
auto vendor_id_file = Core::File::open(vendor_id_filename, Core::File::OpenMode::Read);
if (vendor_id_file.is_error()) {
dbgln("Error: Could not open {}: {}", vendor_id_filename, vendor_id_file.error());
continue;
}
auto device_id_filename = ByteString::formatted("/sys/bus/pci/{}/device_id", dir);
auto device_id_file = Core::File::open(device_id_filename, Core::File::OpenMode::Read);
if (device_id_file.is_error()) {
dbgln("Error: Could not open {}: {}", device_id_filename, device_id_file.error());
continue;
}
auto class_id_filename = ByteString::formatted("/sys/bus/pci/{}/class", dir);
auto class_id_file = Core::File::open(class_id_filename, Core::File::OpenMode::Read);
if (class_id_file.is_error()) {
dbgln("Error: Could not open {}: {}", class_id_filename, class_id_file.error());
continue;
}
auto subclass_id_filename = ByteString::formatted("/sys/bus/pci/{}/subclass", dir);
auto subclass_id_file = Core::File::open(subclass_id_filename, Core::File::OpenMode::Read);
if (subclass_id_file.is_error()) {
dbgln("Error: Could not open {}: {}", subclass_id_filename, subclass_id_file.error());
continue;
}
auto revision_id_filename = ByteString::formatted("/sys/bus/pci/{}/revision", dir);
auto revision_id_file = Core::File::open(revision_id_filename, Core::File::OpenMode::Read);
if (revision_id_file.is_error()) {
dbgln("Error: Could not open {}: {}", revision_id_filename, revision_id_file.error());
continue;
}
auto vendor_id_contents = vendor_id_file.value()->read_until_eof();
if (vendor_id_contents.is_error()) {
dbgln("Error: Could not read {}: {}", vendor_id_filename, vendor_id_contents.error());
continue;
}
u32 vendor_id = read_hex_string_from_bytebuffer(vendor_id_contents.value());
auto device_id_contents = device_id_file.value()->read_until_eof();
if (device_id_contents.is_error()) {
dbgln("Error: Could not read {}: {}", device_id_filename, device_id_contents.error());
continue;
}
u32 device_id = read_hex_string_from_bytebuffer(device_id_contents.value());
auto revision_id_contents = revision_id_file.value()->read_until_eof();
if (revision_id_contents.is_error()) {
dbgln("Error: Could not read {}: {}", revision_id_filename, revision_id_contents.error());
continue;
}
u32 revision_id = read_hex_string_from_bytebuffer(revision_id_contents.value());
auto class_id_contents = class_id_file.value()->read_until_eof();
if (class_id_contents.is_error()) {
dbgln("Error: Could not read {}: {}", class_id_filename, class_id_contents.error());
continue;
}
u32 class_id = read_hex_string_from_bytebuffer(class_id_contents.value());
auto subclass_id_contents = subclass_id_file.value()->read_until_eof();
if (subclass_id_contents.is_error()) {
dbgln("Error: Could not read {}: {}", subclass_id_filename, subclass_id_contents.error());
continue;
}
u32 subclass_id = read_hex_string_from_bytebuffer(subclass_id_contents.value());
ByteString vendor_name;
ByteString device_name;
ByteString class_name;
if (db) {
vendor_name = db->get_vendor(vendor_id);
device_name = db->get_device(vendor_id, device_id);
class_name = db->get_class(class_id);
}
if (vendor_name.is_empty())
vendor_name = ByteString::formatted("{:04x}", vendor_id);
if (device_name.is_empty())
device_name = ByteString::formatted("{:04x}", device_id);
if (class_name.is_empty())
class_name = ByteString::formatted("{:02x}{:02x}", class_id, subclass_id);
outln(format, domain, bus, device, function, class_name, vendor_name, device_name, revision_id);
if (!flag_verbose)
continue;
for (size_t bar_index = 0; bar_index <= 5; bar_index++) {
auto bar_value_filename = ByteString::formatted("/sys/bus/pci/{}/bar{}", dir, bar_index);
auto bar_value_file = Core::File::open(bar_value_filename, Core::File::OpenMode::Read);
if (bar_value_file.is_error()) {
dbgln("Error: Could not open {}: {}", bar_value_filename, bar_value_file.error());
continue;
}
auto bar_value_contents = bar_value_file.value()->read_until_eof();
if (bar_value_contents.is_error()) {
dbgln("Error: Could not read {}: {}", bar_value_filename, bar_value_contents.error());
continue;
}
u32 bar_value = read_hex_string_from_bytebuffer(bar_value_contents.value());
if (bar_value == 0)
continue;
bool memory_region = ((bar_value & 1) == 0);
outln(format_region, bar_index, memory_region ? "Memory" : "IO", bar_value);
}
}
return 0;
}