feat(devices): migrate callsites to rate-limited macros

Migrate 7 guest-triggered high-rate logging callsites from error!() to
error_rate_limited!():

- balloon: duplicate PFN, discard_range failure, hinting failure
- net: oversized TX frame
- block: malformed descriptor chain
- PCI: device activation failure
- MMIO: device activation failure

Each callsite now independently rate-limits to 10 messages per 5-second
window, preventing log floods from guest-driven error paths.

Signed-off-by: Nikita Kalyazin <kalyazin@amazon.com>

Author: kalyazin

src/vmm/src/devices/virtio/balloon/device.rs

@@ -32,7 +32,7 @@ use crate::devices::virtio::device::{ActiveState, VirtioDeviceType};
 use crate::devices::virtio::generated::virtio_config::VIRTIO_F_VERSION_1;
 use crate::devices::virtio::queue::InvalidAvailIdx;
 use crate::devices::virtio::transport::{VirtioInterrupt, VirtioInterruptType};
-use crate::logger::{IncMetric, log_dev_preview_warning};
+use crate::logger::{IncMetric, error_rate_limited, log_dev_preview_warning};
 use crate::utils::u64_to_usize;
 use crate::vstate::memory::{
     Address, ByteValued, Bytes, GuestAddress, GuestMemoryExtension, GuestMemoryMmap,
@@ -455,7 +455,7 @@ impl Balloon {
                     guest_addr,
                     usize::try_from(range_len).unwrap() << VIRTIO_BALLOON_PFN_SHIFT,
                 ) {
-                    error!("Error removing memory range: {:?}", err);
+                    error_rate_limited!("Error removing memory range: {:?}", err);
                 }
             }
         }
@@ -596,7 +596,7 @@ impl Balloon {
                 METRICS.free_page_hint_count.inc();
                 if let Err(err) = mem.discard_range(desc.addr, desc.len as usize) {
                     METRICS.free_page_hint_fails.inc();
-                    error!("balloon hinting: failed to remove range: {err:?}");
+                    error_rate_limited!("balloon hinting: failed to remove range: {err:?}");
                 } else {
                     METRICS.free_page_hint_freed.add(desc.len as u64);
                 }

src/vmm/src/devices/virtio/balloon/util.rs

@@ -4,7 +4,7 @@
 use std::io;
 
 use super::{MAX_PAGE_COMPACT_BUFFER, RemoveRegionError};
-use crate::logger::error;
+use crate::logger::error_rate_limited;
 use crate::utils::u64_to_usize;
 use crate::vstate::memory::{GuestAddress, GuestMemory, GuestMemoryMmap, GuestMemoryRegion};
 
@@ -36,7 +36,7 @@ pub(crate) fn compact_page_frame_numbers(v: &mut [u32]) -> Vec<(u32, u32)> {
         // Skip duplicate pages. This will ensure we only consider
         // distinct PFNs.
         if page_frame_number == v[pfn_index - 1] {
-            error!("Skipping duplicate PFN {}.", page_frame_number);
+            error_rate_limited!("Skipping duplicate PFN {}.", page_frame_number);
             continue;
         }
 

src/vmm/src/devices/virtio/block/virtio/device.rs

@@ -34,7 +34,7 @@ use crate::devices::virtio::generated::virtio_ring::VIRTIO_RING_F_EVENT_IDX;
 use crate::devices::virtio::queue::{InvalidAvailIdx, Queue};
 use crate::devices::virtio::transport::{VirtioInterrupt, VirtioInterruptType};
 use crate::impl_device_type;
-use crate::logger::{IncMetric, error, warn};
+use crate::logger::{IncMetric, error, error_rate_limited, warn};
 use crate::rate_limiter::{BucketUpdate, RateLimiter};
 use crate::utils::u64_to_usize;
 use crate::vmm_config::RateLimiterConfig;
@@ -414,7 +414,10 @@ impl VirtioBlock {
                         )
                     }
                     Err(err) => {
-                        error!("Failed to parse available descriptor chain: {:?}", err);
+                        error_rate_limited!(
+                            "Failed to parse available descriptor chain: {:?}",
+                            err
+                        );
                         self.metrics.execute_fails.inc();
                         ProcessingResult::Executed(FinishedRequest {
                             num_bytes_to_mem: 0,

src/vmm/src/devices/virtio/net/device.rs

@@ -40,7 +40,7 @@ use crate::devices::{DeviceError, report_net_event_fail};
 use crate::dumbo::pdu::arp::ETH_IPV4_FRAME_LEN;
 use crate::dumbo::pdu::ethernet::{EthernetFrame, PAYLOAD_OFFSET};
 use crate::impl_device_type;
-use crate::logger::{IncMetric, METRICS};
+use crate::logger::{IncMetric, METRICS, error_rate_limited};
 use crate::mmds::data_store::Mmds;
 use crate::mmds::ns::MmdsNetworkStack;
 use crate::rate_limiter::{BucketUpdate, RateLimiter, TokenType};
@@ -708,7 +708,7 @@ impl Net {
 
             // We only handle frames that are up to MAX_BUFFER_SIZE
             if self.tx_buffer.len() as usize > MAX_BUFFER_SIZE {
-                error!("net: received too big frame from driver");
+                error_rate_limited!("net: received too big frame from driver");
                 self.metrics.tx_malformed_frames.inc();
                 tx_queue.add_used(head_index, 0)?;
                 continue;

src/vmm/src/devices/virtio/transport/mmio.rs

@@ -15,7 +15,7 @@ use super::{VirtioInterrupt, VirtioInterruptType};
 use crate::devices::virtio::device::VirtioDevice;
 use crate::devices::virtio::device_status;
 use crate::devices::virtio::queue::Queue;
-use crate::logger::{IncMetric, METRICS, error, warn};
+use crate::logger::{IncMetric, METRICS, error, error_rate_limited, warn};
 use crate::utils::byte_order;
 use crate::vstate::bus::BusDevice;
 use crate::vstate::interrupts::InterruptError;
@@ -194,7 +194,7 @@ impl MmioTransport {
                         // configuration change interrupt
                         let _ = self.interrupt.trigger(VirtioInterruptType::Config);
 
-                        error!("Failed to activate virtio device: {}", err)
+                        error_rate_limited!("Failed to activate virtio device: {}", err)
                     }
                 }
             }

src/vmm/src/devices/virtio/transport/pci/device.rs

@@ -35,7 +35,7 @@ use crate::devices::virtio::transport::pci::common_config::{
     VirtioPciCommonConfig, VirtioPciCommonConfigState,
 };
 use crate::devices::virtio::transport::{VirtioInterrupt, VirtioInterruptType};
-use crate::logger::{debug, error};
+use crate::logger::{debug, error, error_rate_limited};
 use crate::pci::configuration::{PciCapability, PciConfiguration, PciConfigurationState};
 use crate::pci::msix::{MsixCap, MsixConfig, MsixConfigState};
 use crate::pci::{BarReprogrammingParams, DeviceRelocationError, PciDevice};
@@ -901,7 +901,7 @@ impl PciDevice for VirtioPciDevice {
             {
                 Ok(()) => self.device_activated.store(true, Ordering::SeqCst),
                 Err(err) => {
-                    error!("Error activating device: {err:?}");
+                    error_rate_limited!("Error activating device: {err:?}");
 
                     // Section 2.1.2 of the specification states that we need to send a device
                     // configuration change interrupt