Update cvd monitor to use inotify

This replaces the 50ms polling loop with an event-driven approach using
inotify to wait for log file changes, implementing FIONREAD event
coalescing and a 20 FPS rate-limiting throttle to protect terminal
bandwidth during log storms.

Assisted-by: Jetski:Gemini Next

Author: Databean

base/cvd/cuttlefish/host/commands/cvd/cli/commands/monitor/command_handler.cc

@@ -17,6 +17,7 @@
 #include "cuttlefish/host/commands/cvd/cli/commands/monitor/command_handler.h"
 
 #include <fcntl.h>
+#include <sys/inotify.h>
 #include <unistd.h>
 
 #include <chrono>
@@ -97,15 +98,36 @@ Result<void> CvdMonitorCommandHandler::Handle(const CommandRequest& request) {
   SharedFD launcher_fd;
   SharedFD logcat_fd;
 
+  SharedFD inotify_fd = SharedFD::InotifyFd();
+  CF_EXPECT(inotify_fd->IsOpen(), "Failed to create inotify fd");
+
+  std::string logs_dir = absl::StrCat(instance.InstanceDirectory(), "/logs");
+  inotify_fd->InotifyAddWatch(logs_dir, IN_CREATE);
+
+  int kernel_watch = -1;
+  int launcher_watch = -1;
+  int logcat_watch = -1;
+  std::chrono::steady_clock::time_point last_draw_time =
+      std::chrono::steady_clock::now();
+
   while (true) {
     if (!kernel_fd->IsOpen()) {
       kernel_fd = SharedFD::Open(kernel_log, O_RDONLY);
+      if (kernel_fd->IsOpen() && kernel_watch == -1) {
+        kernel_watch = inotify_fd->InotifyAddWatch(kernel_log, IN_MODIFY);
+      }
     }
     if (!launcher_fd->IsOpen()) {
       launcher_fd = SharedFD::Open(launcher_log, O_RDONLY);
+      if (launcher_fd->IsOpen() && launcher_watch == -1) {
+        launcher_watch = inotify_fd->InotifyAddWatch(launcher_log, IN_MODIFY);
+      }
     }
     if (!logcat_fd->IsOpen()) {
       logcat_fd = SharedFD::Open(logcat, O_RDONLY);
+      if (logcat_fd->IsOpen() && logcat_watch == -1) {
+        logcat_watch = inotify_fd->InotifyAddWatch(logcat, IN_MODIFY);
+      }
     }
 
     Result<TerminalSize> term_size_result = GetTerminalSize();
@@ -121,9 +143,35 @@ Result<void> CvdMonitorCommandHandler::Handle(const CommandRequest& request) {
 
     auto [output, total_lines_drawn] = display.Finalize();
     std::cout << output << std::flush;
+    last_draw_time = std::chrono::steady_clock::now();
+
+    // Block until file changes occur (wait for the first event).
+    // An oversized buffer is required because IN_CREATE events for the logs/
+    // directory append the variable-length newly created filename to the
+    // end of the struct inotify_event. A buffer that is too small to fit the
+    // event plus the name will cause read() to fail with EINVAL.
+    char buf[4096] __attribute__((aligned(__alignof__(struct inotify_event))));
+    inotify_fd->Read(buf, sizeof(buf));
+
+    // Enforce a maximum framerate (max 20 FPS / min 50ms between draws)
+    // so we don't saturate SSH bandwidth or CPU during heavy, continuous
+    // logging.
+    std::chrono::steady_clock::time_point now =
+        std::chrono::steady_clock::now();
+    std::chrono::steady_clock::duration elapsed = now - last_draw_time;
+    std::chrono::milliseconds min_frame_time(50);
+    if (elapsed < min_frame_time) {
+      std::this_thread::sleep_for(min_frame_time - elapsed);
+    }
 
-    // Wait a bit before clearing and redrawing
-    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    // Drain any additional events that queued up in the meantime
+    int bytes_available = 0;
+    // NOLINTNEXTLINE(misc-include-cleaner)
+    if (inotify_fd->Ioctl(FIONREAD, &bytes_available) == 0 &&
+        bytes_available > 0) {
+      std::vector<char> drain_buf(bytes_available);
+      inotify_fd->Read(drain_buf.data(), bytes_available);
+    }
     ClearLastNLines(total_lines_drawn);
   }