| // Copyright 2019 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <lib/counter-vmo-abi.h> |
| #include <lib/fdio/io.h> |
| #include <lib/fzl/owned-vmo-mapper.h> |
| #include <lib/zx/vmo.h> |
| #include <unistd.h> |
| #include <zircon/compiler.h> |
| #include <zircon/status.h> |
| |
| #include <algorithm> |
| #include <cinttypes> |
| #include <cstdio> |
| #include <cstring> |
| #include <utility> |
| #include <vector> |
| |
| #include <fbl/array.h> |
| #include <fbl/unique_fd.h> |
| |
| #include "kcounter_cmdline.h" |
| |
| namespace { |
| |
| constexpr char kVmoFileDir[] = "/boot/kernel"; |
| |
| } // anonymous namespace |
| |
| int main(int argc, char** argv) { |
| KcounterCmdline cmdline; |
| if (!kcounter_parse_cmdline(argc, argv, stderr, &cmdline)) { |
| return 1; |
| } |
| |
| if (cmdline.help) { |
| kcounter_usage(argv[0], stdout); |
| return 0; |
| } |
| |
| if (cmdline.period) { |
| printf("watch mode every %d seconds\n", cmdline.period); |
| } |
| |
| fbl::unique_fd dir_fd(open(kVmoFileDir, O_RDONLY | O_DIRECTORY)); |
| if (!dir_fd) { |
| fprintf(stderr, "%s: %s\n", kVmoFileDir, strerror(errno)); |
| return 2; |
| } |
| |
| fzl::OwnedVmoMapper desc_mapper; |
| const counters::DescriptorVmo* desc; |
| { |
| fbl::unique_fd desc_fd(openat(dir_fd.get(), counters::DescriptorVmo::kVmoName, O_RDONLY)); |
| if (!desc_fd) { |
| fprintf(stderr, "%s/%s: %s\n", kVmoFileDir, counters::DescriptorVmo::kVmoName, |
| strerror(errno)); |
| return 2; |
| } |
| zx::vmo vmo; |
| zx_status_t status = fdio_get_vmo_exact(desc_fd.get(), vmo.reset_and_get_address()); |
| if (status != ZX_OK) { |
| fprintf(stderr, "fdio_get_vmo_exact: %s: %s\n", counters::DescriptorVmo::kVmoName, |
| zx_status_get_string(status)); |
| return 2; |
| } |
| uint64_t size; |
| status = vmo.get_size(&size); |
| if (status != ZX_OK) { |
| fprintf(stderr, "cannot get %s VMO size: %s\n", counters::DescriptorVmo::kVmoName, |
| zx_status_get_string(status)); |
| return 2; |
| } |
| status = desc_mapper.Map(std::move(vmo), size, ZX_VM_PERM_READ); |
| if (status != ZX_OK) { |
| fprintf(stderr, "cannot map %s VMO: %s\n", counters::DescriptorVmo::kVmoName, |
| zx_status_get_string(status)); |
| return 2; |
| } |
| desc = reinterpret_cast<counters::DescriptorVmo*>(desc_mapper.start()); |
| if (desc->magic != counters::DescriptorVmo::kMagic) { |
| fprintf(stderr, "%s: magic number %" PRIu64 " != expected %" PRIu64 "\n", |
| counters::DescriptorVmo::kVmoName, desc->magic, counters::DescriptorVmo::kMagic); |
| return 2; |
| } |
| if (size < sizeof(*desc) + desc->descriptor_table_size) { |
| fprintf(stderr, "%s size %#" PRIx64 " too small for %" PRIu64 " bytes of descriptor table\n", |
| counters::DescriptorVmo::kVmoName, size, desc->descriptor_table_size); |
| return 2; |
| } |
| } |
| |
| fzl::OwnedVmoMapper arena_mapper; |
| const volatile int64_t* arena = nullptr; |
| if (!cmdline.list) { |
| fbl::unique_fd arena_fd(openat(dir_fd.get(), counters::kArenaVmoName, O_RDONLY)); |
| if (!arena_fd) { |
| fprintf(stderr, "%s/%s: %s\n", kVmoFileDir, counters::kArenaVmoName, strerror(errno)); |
| return 2; |
| } |
| zx::vmo vmo; |
| zx_status_t status = fdio_get_vmo_exact(arena_fd.get(), vmo.reset_and_get_address()); |
| if (status != ZX_OK) { |
| fprintf(stderr, "fdio_get_vmo_exact: %s: %s\n", counters::kArenaVmoName, |
| zx_status_get_string(status)); |
| return 2; |
| } |
| uint64_t size; |
| status = vmo.get_size(&size); |
| if (status != ZX_OK) { |
| fprintf(stderr, "cannot get %s VMO size: %s\n", counters::kArenaVmoName, |
| zx_status_get_string(status)); |
| return 2; |
| } |
| if (size < desc->max_cpus * desc->num_counters() * sizeof(int64_t)) { |
| fprintf(stderr, |
| "%s size %#" PRIx64 " too small for %" PRIu64 " CPUS * %" PRIu64 " counters\n", |
| counters::kArenaVmoName, size, desc->max_cpus, desc->num_counters()); |
| return 2; |
| } |
| status = arena_mapper.Map(std::move(vmo), size, ZX_VM_PERM_READ); |
| if (status != ZX_OK) { |
| fprintf(stderr, "cannot map %s VMO: %s\n", counters::kArenaVmoName, |
| zx_status_get_string(status)); |
| return 2; |
| } |
| arena = reinterpret_cast<int64_t*>(arena_mapper.start()); |
| } |
| |
| dir_fd.reset(); |
| |
| fbl::Array<bool> matched(new bool[argc - cmdline.unparsed_args_start](), |
| argc - cmdline.unparsed_args_start); |
| auto matches = [&](const char* name) -> bool { |
| if (cmdline.unparsed_args_start == argc) { |
| return true; |
| } |
| for (int i = cmdline.unparsed_args_start; i < argc; ++i) { |
| if (!strncmp(name, argv[i], strlen(argv[i]))) { |
| matched[i - cmdline.unparsed_args_start] = true; |
| return true; |
| } |
| } |
| return false; |
| }; |
| |
| size_t times = 1; |
| zx_time_t deadline = zx_clock_get_monotonic(); |
| bool match_failed = false; |
| |
| if (cmdline.cpuid != kNoCpuIdChosen) { |
| // The command line parser should have already ensured that this value is |
| // non-negative. |
| ZX_DEBUG_ASSERT(cmdline.cpuid >= 0); |
| |
| // The command line parser should have made certain we did not select both |
| // --cpuid and --verbose. |
| ZX_DEBUG_ASSERT(cmdline.verbose == false); |
| |
| if (static_cast<uint64_t>(cmdline.cpuid) >= desc->max_cpus) { |
| fprintf(stderr, "CPU ID %d is out of range. Descriptor reports max_cpus as %lu\n", |
| cmdline.cpuid, desc->max_cpus); |
| return 1; |
| } |
| printf("Dumping counters for CPU ID %d.\n", cmdline.cpuid); |
| } |
| |
| if (cmdline.period != 0) { |
| printf("Dumping counters every %d seconds. Press any key to stop.\n", cmdline.period); |
| } |
| |
| uint64_t cpu_range_start = (cmdline.cpuid != kNoCpuIdChosen) ? cmdline.cpuid : 0; |
| uint64_t cpu_range_end = (cmdline.cpuid != kNoCpuIdChosen) ? cmdline.cpuid + 1 : desc->max_cpus; |
| |
| size_t match_count = 0; |
| size_t max_name_length = 0; |
| for (size_t i = 0; i < desc->num_counters(); ++i) { |
| const auto& entry = desc->descriptor_table[i]; |
| if (matches(entry.name)) { |
| max_name_length = std::max(max_name_length, strlen(entry.name)); |
| match_count++; |
| } |
| } |
| std::vector<int64_t> previous_values(cmdline.verbose ? 0 : match_count); |
| |
| // Set last sample time to zero so that the system and period averages match |
| // on the first iteration. |
| zx_time_t last_sample_time = 0; |
| |
| // The printf modifier * expects an int for the field size. A negative value |
| // specifies left justification. |
| const auto name_field_width = -static_cast<int>(max_name_length); |
| |
| while (true) { |
| if (cmdline.period != 0) { |
| deadline += ZX_SEC(cmdline.period); |
| printf("[%zu]\n", times); |
| } |
| |
| if (!cmdline.terse && !cmdline.verbose && !cmdline.list) { |
| printf("%*s %-10s %-9s %-10s\n", name_field_width, "Counter", "Value", "Sys Avg", |
| "Period Avg"); |
| } |
| |
| const zx_time_t sample_time = zx_clock_get_monotonic(); |
| size_t match_index = 0; |
| for (size_t i = 0; i < desc->num_counters(); ++i) { |
| const auto& entry = desc->descriptor_table[i]; |
| if (matches(entry.name)) { |
| if (cmdline.list) { |
| fputs(entry.name, stdout); |
| switch (entry.type) { |
| case counters::Type::kSum: |
| puts(" sum"); |
| break; |
| case counters::Type::kMin: |
| puts(" min"); |
| break; |
| case counters::Type::kMax: |
| puts(" max"); |
| break; |
| default: |
| fprintf(stderr, " ??? unknown type %" PRIu64 " ???\n", |
| static_cast<uint64_t>(entry.type)); |
| } |
| } else { |
| if (!cmdline.terse) { |
| printf("%*s =%s", name_field_width, entry.name, |
| !cmdline.verbose ? " " |
| : entry.type == counters::Type::kMin ? " min(" |
| : entry.type == counters::Type::kMax ? " max(" |
| : " "); |
| } |
| int64_t value = 0; |
| for (uint64_t cpu = cpu_range_start; cpu < cpu_range_end; ++cpu) { |
| const int64_t cpu_value = arena[(cpu * desc->num_counters()) + i]; |
| if (cmdline.verbose) { |
| printf("%s%" PRId64, |
| cpu == 0 ? "" |
| : entry.type == counters::Type::kSum ? " + " |
| : ", ", |
| cpu_value); |
| } |
| switch (entry.type) { |
| case counters::Type::kSum: |
| default: |
| value += cpu_value; |
| break; |
| case counters::Type::kMin: |
| if (cpu_value < value) { |
| value = cpu_value; |
| } |
| break; |
| case counters::Type::kMax: |
| if (cpu_value > value) { |
| value = cpu_value; |
| } |
| break; |
| } |
| } |
| if (cmdline.verbose) { |
| printf("%s = %" PRId64 "\n", entry.type == counters::Type::kSum ? "" : ")", value); |
| } else { |
| int64_t ev_per_nsec = 0; |
| const bool overflow = mul_overflow(value, 1000000000LL, &ev_per_nsec); |
| const int64_t system_rate = ev_per_nsec / sample_time; |
| const int64_t delta_value = value - previous_values[match_index]; |
| const int64_t delta_sample_time = sample_time - last_sample_time; |
| const int64_t period_rate = delta_value * 1000000000LL / delta_sample_time; |
| |
| previous_values[match_index] = value; |
| |
| if (!overflow) { |
| printf("%12" PRId64 " [%8" PRId64 "/sec %8" PRId64 "/sec]\n", value, system_rate, |
| period_rate); |
| } else { |
| printf("%12" PRId64 " [%8s %8" PRId64 "/sec]\n", value, "overflow", period_rate); |
| } |
| } |
| } |
| |
| match_index++; |
| } // if (matches(entry.name)) |
| } // for (size_t i = 0; i < desc->num_counters(); ++i) |
| last_sample_time = sample_time; |
| |
| // Check that each prefix was actually used. |
| if (times == 1) { |
| for (auto it = matched.begin(); it != matched.end(); ++it) { |
| if (!*it) { |
| fprintf(stderr, "%s: prefix not found\n", |
| argv[cmdline.unparsed_args_start + (it - matched.begin())]); |
| match_failed = true; |
| } |
| } |
| } |
| |
| if ((cmdline.period == 0) || match_failed) { |
| break; |
| } |
| |
| zx_time_t now = zx_clock_get_monotonic(); |
| zx_duration_t timeout = zx_time_sub_time(deadline, now); |
| if (timeout > 0) { |
| struct pollfd pfd = {.fd = STDIN_FILENO, .events = POLLIN, .revents = 0}; |
| int msec_timeout = static_cast<int>(std::min<zx_duration_t>( |
| (timeout + ZX_MSEC(1) - 1) / ZX_MSEC(1), std::numeric_limits<int>::max())); |
| |
| int poll_result = poll(&pfd, 1, msec_timeout); |
| if (poll_result > 0) { |
| printf("Shutting down\n"); |
| break; |
| } |
| } else { |
| // We are falling behind. Reset our deadline to catch up |
| deadline = now; |
| } |
| |
| ++times; |
| } // while |
| |
| return match_failed ? 1 : 0; |
| } |
