diff --git a/common/libs/fs/shared_fd.h b/common/libs/fs/shared_fd.h
index 79f5405..69542e6 100644
--- a/common/libs/fs/shared_fd.h
+++ b/common/libs/fs/shared_fd.h
@@ -232,16 +232,14 @@
 
   int EpollCtl(int op, cvd::SharedFD new_fd, struct epoll_event* event) {
     errno = 0;
-    int rval = TEMP_FAILURE_RETRY(
-        epoll_ctl(fd_, op, new_fd->fd_, event));
+    int rval = TEMP_FAILURE_RETRY(epoll_ctl(fd_, op, new_fd->fd_, event));
     errno_ = errno;
     return rval;
   }
 
   int EpollWait(struct epoll_event* events, int maxevents, int timeout) {
     errno = 0;
-    int rval = TEMP_FAILURE_RETRY(
-        epoll_wait(fd_, events, maxevents, timeout));
+    int rval = TEMP_FAILURE_RETRY(epoll_wait(fd_, events, maxevents, timeout));
     errno_ = errno;
     return rval;
   }
@@ -461,7 +459,7 @@
   }
 
   int TimerSet(int flags, const struct itimerspec* new_value,
-                   struct itimerspec* old_value) {
+               struct itimerspec* old_value) {
     errno = 0;
     int rval = timerfd_settime(fd_, flags, new_value, old_value);
     errno_ = errno;
diff --git a/common/vsoc/lib/circqueue_impl.h b/common/vsoc/lib/circqueue_impl.h
index 154dbbb..fae406a 100644
--- a/common/vsoc/lib/circqueue_impl.h
+++ b/common/vsoc/lib/circqueue_impl.h
@@ -18,8 +18,8 @@
 
 #include <string.h>
 
-#include "common/vsoc/shm/circqueue.h"
 #include "common/vsoc/lib/region_signaling_interface.h"
+#include "common/vsoc/shm/circqueue.h"
 
 namespace {
 // Increases the given index until it is naturally aligned for T.
@@ -80,10 +80,7 @@
 
 template <uint32_t SizeLog2>
 intptr_t CircularQueueBase<SizeLog2>::WriteReserveLocked(
-    RegionSignalingInterface* r,
-    size_t bytes,
-    Range* t,
-                                                         bool non_blocking) {
+    RegionSignalingInterface* r, size_t bytes, Range* t, bool non_blocking) {
   // Can't write more than the buffer will hold
   if (bytes > BufferSize) {
     return -ENOSPC;
@@ -109,8 +106,8 @@
 }
 
 template <uint32_t SizeLog2>
-intptr_t CircularByteQueue<SizeLog2>::Read(RegionSignalingInterface* r, char* buffer_out,
-                                           size_t max_size) {
+intptr_t CircularByteQueue<SizeLog2>::Read(RegionSignalingInterface* r,
+                                           char* buffer_out, size_t max_size) {
   this->lock_.Lock();
   this->WaitForDataLocked(r);
   Range t;
@@ -131,11 +128,9 @@
 }
 
 template <uint32_t SizeLog2>
-intptr_t CircularByteQueue<SizeLog2>::Write(
-    RegionSignalingInterface* r,
-    const char* buffer_in,
-    size_t bytes,
-    bool non_blocking) {
+intptr_t CircularByteQueue<SizeLog2>::Write(RegionSignalingInterface* r,
+                                            const char* buffer_in, size_t bytes,
+                                            bool non_blocking) {
   Range range;
   this->lock_.Lock();
   intptr_t rval = this->WriteReserveLocked(r, bytes, &range, non_blocking);
@@ -161,9 +156,8 @@
 }
 
 template <uint32_t SizeLog2, uint32_t MaxPacketSize>
-intptr_t CircularPacketQueue<SizeLog2, MaxPacketSize>::Read(RegionSignalingInterface* r,
-                                                            char* buffer_out,
-                                                            size_t max_size) {
+intptr_t CircularPacketQueue<SizeLog2, MaxPacketSize>::Read(
+    RegionSignalingInterface* r, char* buffer_out, size_t max_size) {
   this->lock_.Lock();
   this->WaitForDataLocked(r);
   uint32_t packet_size = *reinterpret_cast<uint32_t*>(
@@ -186,9 +180,7 @@
 
 template <uint32_t SizeLog2, uint32_t MaxPacketSize>
 intptr_t CircularPacketQueue<SizeLog2, MaxPacketSize>::Write(
-    RegionSignalingInterface* r,
-    const char* buffer_in,
-    uint32_t bytes,
+    RegionSignalingInterface* r, const char* buffer_in, uint32_t bytes,
     bool non_blocking) {
   if (bytes > MaxPacketSize) {
     return -ENOSPC;
@@ -205,9 +197,9 @@
   Range header = range;
   header.end_idx = header.start_idx + sizeof(uint32_t);
   uint32_t sizeof_uint32_t = sizeof(uint32_t);
-  Range payload{static_cast<uint32_t>(range.start_idx + sizeof(uint32_t)),
-                static_cast<uint32_t>(
-                    range.start_idx + sizeof(uint32_t) + bytes)};
+  Range payload{
+      static_cast<uint32_t>(range.start_idx + sizeof(uint32_t)),
+      static_cast<uint32_t>(range.start_idx + sizeof(uint32_t) + bytes)};
   this->CopyInRange(reinterpret_cast<const char*>(&bytes), header);
   this->CopyInRange(buffer_in, payload);
   this->w_pub_ = range.end_idx;
diff --git a/guest/frontend/vnc_server/vnc_client_connection.cpp b/guest/frontend/vnc_server/vnc_client_connection.cpp
index f6b4669..b551f64 100644
--- a/guest/frontend/vnc_server/vnc_client_connection.cpp
+++ b/guest/frontend/vnc_server/vnc_client_connection.cpp
@@ -15,9 +15,9 @@
  */
 
 #include "vnc_client_connection.h"
-#include "vnc_utils.h"
-#include "tcp_socket.h"
 #include "keysyms.h"
+#include "tcp_socket.h"
+#include "vnc_utils.h"
 
 #include <guest/libs/legacy_framebuffer/vsoc_framebuffer.h>
 
@@ -43,9 +43,9 @@
 #include <cutils/sockets.h>
 
 using cvd::vnc::Message;
-using cvd::vnc::VncClientConnection;
 using cvd::vnc::Stripe;
 using cvd::vnc::StripePtrVec;
+using cvd::vnc::VncClientConnection;
 
 namespace {
 class BigEndianChecker {
@@ -54,9 +54,7 @@
     uint32_t u = 1;
     is_big_endian_ = *reinterpret_cast<const char*>(&u) == 0;
   }
-  bool operator()() const {
-    return is_big_endian_;
-  }
+  bool operator()() const { return is_big_endian_; }
 
  private:
   bool is_big_endian_{};
@@ -117,9 +115,7 @@
   return m;
 }
 
-std::string HostName() {
-  return "Cuttlefish";
-}
+std::string HostName() { return "Cuttlefish"; }
 
 std::uint16_t uint16_tAt(const void* p) {
   std::uint16_t u{};
@@ -156,7 +152,7 @@
   return (pixel >> VSoCFrameBuffer::kGreenShift) &
          ((0x1 << VSoCFrameBuffer::kGreenBits) - 1);
 }
-}
+}  // namespace
 namespace cvd {
 namespace vnc {
 bool operator==(const VncClientConnection::FrameBufferUpdateRequest& lhs,
@@ -170,14 +166,12 @@
   return !(lhs == rhs);
 }
 }  // namespace vnc
-}  // namespace cvd  // namespace
+}  // namespace cvd
 
 VncClientConnection::VncClientConnection(ClientSocket client,
                                          VirtualInputs* virtual_inputs,
                                          BlackBoard* bb, bool aggressive)
-    : client_{std::move(client)},
-      virtual_inputs_{virtual_inputs},
-      bb_{bb} {
+    : client_{std::move(client)}, virtual_inputs_{virtual_inputs}, bb_{bb} {
   frame_buffer_request_handler_tid_ = std::thread(
       &VncClientConnection::FrameBufferUpdateRequestHandler, this, aggressive);
 }
diff --git a/host/frontend/vnc_server/vnc_client_connection.cpp b/host/frontend/vnc_server/vnc_client_connection.cpp
index c9a87c8..8f44a97 100644
--- a/host/frontend/vnc_server/vnc_client_connection.cpp
+++ b/host/frontend/vnc_server/vnc_client_connection.cpp
@@ -44,10 +44,9 @@
 
 DEFINE_bool(debug_client, false, "Turn on detailed logging for the client");
 
-#define DLOG(LEVEL)                                 \
+#define DLOG(LEVEL) \
   if (FLAGS_debug_client) LOG(LEVEL)
 
-
 namespace {
 class BigEndianChecker {
  public:
diff --git a/host/libs/config/guest_config.cpp b/host/libs/config/guest_config.cpp
index 359cb24..6cd1528 100644
--- a/host/libs/config/guest_config.cpp
+++ b/host/libs/config/guest_config.cpp
@@ -18,8 +18,8 @@
 #include <iomanip>
 #include <sstream>
 
-#include <glog/logging.h>
 #include <gflags/gflags.h>
+#include <glog/logging.h>
 #include "host/libs/config/host_config.h"
 
 std::string g_default_libvirt_domain{vsoc::GetPerInstanceDefault("cvd-")};
diff --git a/host/libs/config/guest_config.h b/host/libs/config/guest_config.h
index 462ed6c..eaf8ff6 100644
--- a/host/libs/config/guest_config.h
+++ b/host/libs/config/guest_config.h
@@ -135,20 +135,16 @@
 
   // GetUSBSocketName returns name of the USB socket that will be used to
   // forward access to USB gadget. This is for V1 of the USB bus.
-  std::string GetUSBV1SocketName() const {
-    return usb_v1_socket_name_;
-  }
+  std::string GetUSBV1SocketName() const { return usb_v1_socket_name_; }
 
   GuestConfig& SetUSBV1SocketName(const std::string& source) {
     usb_v1_socket_name_ = source;
     return *this;
   }
 
-  std::string GetKernelLogSocketName() const {
-    return kernel_log_socket_name_;
-  }
+  std::string GetKernelLogSocketName() const { return kernel_log_socket_name_; }
 
-  GuestConfig& SetKernelLogSocketName( const std::string& source) {
+  GuestConfig& SetKernelLogSocketName(const std::string& source) {
     kernel_log_socket_name_ = source;
     return *this;
   }
diff --git a/host/libs/ivserver/hald_client_test.cc b/host/libs/ivserver/hald_client_test.cc
index c566079..434f153 100644
--- a/host/libs/ivserver/hald_client_test.cc
+++ b/host/libs/ivserver/hald_client_test.cc
@@ -26,11 +26,11 @@
 #include "host/libs/ivserver/hald_client.h"
 #include "host/libs/ivserver/vsocsharedmem_mock.h"
 
+using ::testing::_;
 using ::testing::DoAll;
 using ::testing::Return;
 using ::testing::ReturnRef;
 using ::testing::SetArgPointee;
-using ::testing::_;
 
 namespace ivserver {
 namespace test {
diff --git a/host/vsoc/lib/host_region_e2e_test.cpp b/host/vsoc/lib/host_region_e2e_test.cpp
index d4f9e29..dc87f46 100644
--- a/host/vsoc/lib/host_region_e2e_test.cpp
+++ b/host/vsoc/lib/host_region_e2e_test.cpp
@@ -86,21 +86,21 @@
   primary.SendSignal(side, &primary.data()->host_to_guest_signal);
   LOG(INFO) << "Signal sent. Waiting for first signal from peer";
   primary.WaitForInterrupt();
-  int count = 0; // counts the number of signals received.
-  primary.ProcessSignalsFromPeer([&primary, &count](uint32_t* uaddr){
-      ++count;
-      EXPECT_TRUE(uaddr == &primary.data()->guest_to_host_signal);
-    });
+  int count = 0;  // counts the number of signals received.
+  primary.ProcessSignalsFromPeer([&primary, &count](uint32_t* uaddr) {
+    ++count;
+    EXPECT_TRUE(uaddr == &primary.data()->guest_to_host_signal);
+  });
   EXPECT_TRUE(count == 1);
   LOG(INFO) << "Signal received on primary region";
   secondary.SendSignal(side, &secondary.data()->host_to_guest_signal);
   LOG(INFO) << "Signal sent. Waiting for second signal from peer";
   secondary.WaitForInterrupt();
   count = 0;
-  secondary.ProcessSignalsFromPeer([&secondary, &count](uint32_t* uaddr){
-      ++count;
-      EXPECT_TRUE(uaddr == &secondary.data()->guest_to_host_signal);
-    });
+  secondary.ProcessSignalsFromPeer([&secondary, &count](uint32_t* uaddr) {
+    ++count;
+    EXPECT_TRUE(uaddr == &secondary.data()->guest_to_host_signal);
+  });
   EXPECT_TRUE(count == 1);
   LOG(INFO) << "Signal received on secondary region";