diff --git a/build/source_list.bzl b/build/source_list.bzl
index b663445..5aeac68 100644
--- a/build/source_list.bzl
+++ b/build/source_list.bzl
@@ -1311,6 +1311,7 @@
     "quic/core/quic_time_test.cc",
     "quic/core/quic_time_wait_list_manager_test.cc",
     "quic/core/quic_trace_visitor_test.cc",
+    "quic/core/quic_udp_socket_test.cc",
     "quic/core/quic_unacked_packet_map_test.cc",
     "quic/core/quic_utils_test.cc",
     "quic/core/quic_version_manager_test.cc",
diff --git a/build/source_list.gni b/build/source_list.gni
index 35732c7..ce85b0e 100644
--- a/build/source_list.gni
+++ b/build/source_list.gni
@@ -1312,6 +1312,7 @@
     "src/quiche/quic/core/quic_time_test.cc",
     "src/quiche/quic/core/quic_time_wait_list_manager_test.cc",
     "src/quiche/quic/core/quic_trace_visitor_test.cc",
+    "src/quiche/quic/core/quic_udp_socket_test.cc",
     "src/quiche/quic/core/quic_unacked_packet_map_test.cc",
     "src/quiche/quic/core/quic_utils_test.cc",
     "src/quiche/quic/core/quic_version_manager_test.cc",
diff --git a/build/source_list.json b/build/source_list.json
index 1f6ca08..c10a0a9 100644
--- a/build/source_list.json
+++ b/build/source_list.json
@@ -1311,6 +1311,7 @@
     "quiche/quic/core/quic_time_test.cc",
     "quiche/quic/core/quic_time_wait_list_manager_test.cc",
     "quiche/quic/core/quic_trace_visitor_test.cc",
+    "quiche/quic/core/quic_udp_socket_test.cc",
     "quiche/quic/core/quic_unacked_packet_map_test.cc",
     "quiche/quic/core/quic_utils_test.cc",
     "quiche/quic/core/quic_version_manager_test.cc",
diff --git a/quiche/common/quiche_feature_flags_list.h b/quiche/common/quiche_feature_flags_list.h
index fd1fd04..2235d21 100755
--- a/quiche/common/quiche_feature_flags_list.h
+++ b/quiche/common/quiche_feature_flags_list.h
@@ -49,6 +49,7 @@
 QUICHE_FLAG(bool, quiche_reloadable_flag_quic_require_handshake_confirmation, true, true, "If true, require handshake confirmation for QUIC connections, functionally disabling 0-rtt handshakes.")
 QUICHE_FLAG(bool, quiche_reloadable_flag_quic_send_placeholder_ticket_when_encrypt_ticket_fails, false, true, "If true, when TicketCrypter fails to encrypt a session ticket, quic::TlsServerHandshaker will send a placeholder ticket, instead of an empty one, to the client.")
 QUICHE_FLAG(bool, quiche_reloadable_flag_quic_stop_reading_also_stops_header_decompression, true, true, "If true, QUIC stream will not continue decompressing buffer headers after StopReading() called.")
+QUICHE_FLAG(bool, quiche_reloadable_flag_quic_support_flow_label, false, false, "If true, QUIC will support reading and writing IPv6 flow labels.")
 QUICHE_FLAG(bool, quiche_reloadable_flag_quic_test_peer_addr_change_after_normalize, false, false, "If true, QuicConnection::ProcessValidatedPacket will use normalized address to test peer address changes.")
 QUICHE_FLAG(bool, quiche_reloadable_flag_quic_testonly_default_false, false, false, "A testonly reloadable flag that will always default to false.")
 QUICHE_FLAG(bool, quiche_reloadable_flag_quic_testonly_default_true, true, true, "A testonly reloadable flag that will always default to true.")
diff --git a/quiche/quic/core/quic_udp_socket.h b/quiche/quic/core/quic_udp_socket.h
index 404563f..001bc85 100644
--- a/quiche/quic/core/quic_udp_socket.h
+++ b/quiche/quic/core/quic_udp_socket.h
@@ -36,6 +36,7 @@
   ECN,                   // Read
   GOOGLE_PACKET_HEADER,  // Read
   IS_GRO,                // Read
+  V6_FLOW_LABEL,         // Read & Write
 
   // Must be the last value.
   NUM_BITS
@@ -154,13 +155,26 @@
     bitmask_.Set(QuicUdpPacketInfoBit::GOOGLE_PACKET_HEADER);
   }
 
-  QuicEcnCodepoint ecn_codepoint() const { return ecn_codepoint_; }
+  QuicEcnCodepoint ecn_codepoint() const {
+    QUICHE_DCHECK(HasValue(QuicUdpPacketInfoBit::ECN));
+    return ecn_codepoint_;
+  }
 
   void SetEcnCodepoint(const QuicEcnCodepoint ecn_codepoint) {
     ecn_codepoint_ = ecn_codepoint;
     bitmask_.Set(QuicUdpPacketInfoBit::ECN);
   }
 
+  uint32_t flow_label() const {
+    QUICHE_DCHECK(HasValue(QuicUdpPacketInfoBit::V6_FLOW_LABEL));
+    return ipv6_flow_label_;
+  }
+
+  void SetFlowLabel(uint32_t ipv6_flow_label) {
+    ipv6_flow_label_ = ipv6_flow_label;
+    bitmask_.Set(QuicUdpPacketInfoBit::V6_FLOW_LABEL);
+  }
+
  private:
   QuicUdpPacketInfoBitMask bitmask_;
   QuicPacketCount dropped_packets_;
@@ -172,6 +186,7 @@
   BufferSpan google_packet_headers_;
   size_t gso_size_ = 0;
   QuicEcnCodepoint ecn_codepoint_ = ECN_NOT_ECT;
+  uint32_t ipv6_flow_label_ = 0;
 };
 
 // QuicUdpSocketApi provides a minimal set of apis for sending and receiving
diff --git a/quiche/quic/core/quic_udp_socket_posix.inc b/quiche/quic/core/quic_udp_socket_posix.inc
index 9293bf2..0b8d7b6 100644
--- a/quiche/quic/core/quic_udp_socket_posix.inc
+++ b/quiche/quic/core/quic_udp_socket_posix.inc
@@ -10,6 +10,15 @@
 #include <sys/socket.h>
 #include <sys/types.h>
 
+#if defined(__linux__)
+#include <linux/in6.h>
+#ifndef IPV6_FLOWLABEL
+#define IPV6_FLOWINFO 11
+#define IPV6_FLOWINFO_SEND 33
+#define IPV6_FLOWINFO_FLOWLABEL 0x000fffff
+#endif
+#endif
+
 #include "absl/base/optimization.h"
 #include "quiche/quic/core/io/socket.h"
 #include "quiche/quic/core/quic_udp_socket.h"
@@ -145,6 +154,17 @@
     }
   }
 
+#if defined(__linux__)
+  if (cmsg->cmsg_level == IPPROTO_IPV6 && cmsg->cmsg_type == IPV6_FLOWINFO) {
+    if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::V6_FLOW_LABEL)) {
+      uint32_t flow_label = 0;
+      memcpy(&flow_label, CMSG_DATA(cmsg), sizeof(flow_label));
+      flow_label = IPV6_FLOWINFO_FLOWLABEL & ntohl(flow_label);
+      packet_info->SetFlowLabel(flow_label);
+    }
+  }
+#endif
+
   if (packet_info_interested.IsSet(
           QuicUdpPacketInfoBit::GOOGLE_PACKET_HEADER)) {
     BufferSpan google_packet_headers;
@@ -223,6 +243,23 @@
                                    << "IPv6 socket";
       return false;
     }
+#if defined(__linux__)
+    if (GetQuicReloadableFlag(quic_support_flow_label)) {
+      if (setsockopt(fd, SOL_IPV6, IPV6_FLOWINFO, &set, sizeof(set)) != 0) {
+        QUIC_LOG_FIRST_N(ERROR, 100)
+            << "Failed to request to receive flow label on "
+            << "IPv6 socket";
+        return false;
+      }
+      if (setsockopt(fd, SOL_IPV6, IPV6_FLOWINFO_SEND, &set, sizeof(set)) !=
+          0) {
+        QUIC_LOG_FIRST_N(ERROR, 100)
+            << "Failed to request to send flow label on "
+            << "IPv6 socket";
+        return false;
+      }
+    }
+#endif
     if (!EnableReceiveSelfIpAddressForV6(fd)) {
       QUIC_LOG_FIRST_N(ERROR, 100)
           << "Failed to enable receiving of self v6 ip";
@@ -488,6 +525,20 @@
 
   cmsghdr* cmsg = nullptr;
 
+  // Set IPv6 flow label.
+#if defined(__linux__)
+  if (packet_info.HasValue(QuicUdpPacketInfoBit::V6_FLOW_LABEL) &&
+      packet_info.flow_label() != 0) {
+    uint32_t flowlabel = packet_info.flow_label();
+    if (!NextCmsg(&hdr, control_buffer, sizeof(control_buffer), SOL_IPV6,
+                  IPV6_FLOWINFO, sizeof(flowlabel), &cmsg)) {
+      QUIC_LOG_FIRST_N(ERROR, 100) << "Not enough buffer to set flow label.";
+      return WriteResult(WRITE_STATUS_ERROR, EINVAL);
+    }
+    *reinterpret_cast<uint32_t*>(CMSG_DATA(cmsg)) =
+        htonl(flowlabel & IPV6_FLOWINFO_FLOWLABEL);
+  }
+#endif
   // Set self IP.
   if (packet_info.HasValue(QuicUdpPacketInfoBit::V4_SELF_IP) &&
       packet_info.self_v4_ip().IsInitialized()) {
diff --git a/quiche/quic/core/quic_udp_socket_test.cc b/quiche/quic/core/quic_udp_socket_test.cc
new file mode 100644
index 0000000..3d46f87
--- /dev/null
+++ b/quiche/quic/core/quic_udp_socket_test.cc
@@ -0,0 +1,136 @@
+// Copyright 2024 The Chromium 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 "quiche/quic/core/quic_udp_socket.h"
+
+#include <netinet/in.h>
+#include <stdint.h>
+
+#include <cstddef>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "quiche/quic/platform/api/quic_test.h"
+
+namespace quic {
+namespace test {
+namespace {
+
+const int kReceiveBufferSize = 16000;
+const int kSendBufferSize = 16000;
+
+class QuicUdpSocketTest : public QuicTest {
+ protected:
+  ABSL_CACHELINE_ALIGNED char packet_buffer_[20];
+  ABSL_CACHELINE_ALIGNED char control_buffer_[512];
+};
+
+TEST_F(QuicUdpSocketTest, Basic) {
+  SetQuicReloadableFlag(quic_support_flow_label, true);
+  const QuicSocketAddress any_address(quiche::QuicheIpAddress::Any6(), 0);
+  QuicUdpSocketApi socket_api;
+
+  SocketFd server_socket =
+      socket_api.Create(AF_INET6, kSendBufferSize, kReceiveBufferSize);
+  ASSERT_NE(kQuicInvalidSocketFd, server_socket);
+  ASSERT_TRUE(socket_api.Bind(server_socket, any_address));
+  QuicSocketAddress server_address;
+  ASSERT_EQ(0, server_address.FromSocket(server_socket));
+
+  SocketFd client_socket =
+      socket_api.Create(AF_INET6, kSendBufferSize, kReceiveBufferSize);
+  ASSERT_NE(kQuicInvalidSocketFd, client_socket);
+  ASSERT_TRUE(socket_api.Bind(client_socket, any_address));
+  QuicSocketAddress client_address;
+  ASSERT_EQ(0, client_address.FromSocket(client_socket));
+
+  QuicUdpPacketInfo packet_info;
+  packet_info.SetPeerAddress(server_address);
+
+  WriteResult write_result;
+  const absl::string_view client_data = "acd";
+  write_result = socket_api.WritePacket(client_socket, client_data.data(),
+                                        client_data.length(), packet_info);
+  ASSERT_EQ(WRITE_STATUS_OK, write_result.status);
+
+  QuicUdpPacketInfoBitMask packet_info_interested;
+  QuicUdpSocketApi::ReadPacketResult read_result;
+  read_result.packet_buffer = {&packet_buffer_[0], sizeof(packet_buffer_)};
+  read_result.control_buffer = {&control_buffer_[0], sizeof(control_buffer_)};
+
+  socket_api.ReadPacket(server_socket, packet_info_interested, &read_result);
+  ASSERT_TRUE(read_result.ok);
+  ASSERT_EQ(client_data,
+            absl::string_view(read_result.packet_buffer.buffer,
+                              read_result.packet_buffer.buffer_len));
+
+  const absl::string_view server_data = "acd";
+  packet_info.SetPeerAddress(client_address);
+  write_result = socket_api.WritePacket(server_socket, server_data.data(),
+                                        server_data.length(), packet_info);
+  ASSERT_EQ(WRITE_STATUS_OK, write_result.status);
+
+  read_result.Reset(sizeof(packet_buffer_));
+  socket_api.ReadPacket(client_socket, packet_info_interested, &read_result);
+  ASSERT_TRUE(read_result.ok);
+  ASSERT_EQ(server_data,
+            absl::string_view(read_result.packet_buffer.buffer,
+                              read_result.packet_buffer.buffer_len));
+}
+
+TEST_F(QuicUdpSocketTest, FlowLabel) {
+  SetQuicReloadableFlag(quic_support_flow_label, true);
+  const QuicSocketAddress any_address(quiche::QuicheIpAddress::Any6(), 0);
+  QuicUdpSocketApi socket_api;
+
+  SocketFd server_socket =
+      socket_api.Create(AF_INET6, kSendBufferSize, kReceiveBufferSize);
+  ASSERT_NE(kQuicInvalidSocketFd, server_socket);
+  ASSERT_TRUE(socket_api.Bind(server_socket, any_address));
+  QuicSocketAddress server_address;
+  ASSERT_EQ(0, server_address.FromSocket(server_socket));
+
+  SocketFd client_socket =
+      socket_api.Create(AF_INET6, kSendBufferSize, kReceiveBufferSize);
+  ASSERT_NE(kQuicInvalidSocketFd, client_socket);
+  ASSERT_TRUE(socket_api.Bind(client_socket, any_address));
+  QuicSocketAddress client_address;
+  ASSERT_EQ(0, client_address.FromSocket(client_socket));
+
+  const absl::string_view data = "a";
+  const uint32_t client_flow_label = 1;
+  QuicUdpPacketInfo packet_info;
+  packet_info.SetFlowLabel(client_flow_label);
+  packet_info.SetPeerAddress(server_address);
+
+  WriteResult write_result;
+  write_result = socket_api.WritePacket(client_socket, data.data(),
+                                        data.length(), packet_info);
+  ASSERT_EQ(WRITE_STATUS_OK, write_result.status);
+
+  QuicUdpPacketInfoBitMask packet_info_interested(
+      {quic::QuicUdpPacketInfoBit::V6_FLOW_LABEL});
+  QuicUdpSocketApi::ReadPacketResult read_result;
+  read_result.packet_buffer = {&packet_buffer_[0], sizeof(packet_buffer_)};
+  read_result.control_buffer = {&control_buffer_[0], sizeof(control_buffer_)};
+
+  socket_api.ReadPacket(server_socket, packet_info_interested, &read_result);
+  EXPECT_EQ(client_flow_label, read_result.packet_info.flow_label());
+
+  const uint32_t server_flow_label = 3;
+  packet_info.SetPeerAddress(client_address);
+  packet_info.SetFlowLabel(server_flow_label);
+  write_result = socket_api.WritePacket(server_socket, data.data(),
+                                        data.length(), packet_info);
+  ASSERT_EQ(WRITE_STATUS_OK, write_result.status);
+
+  read_result.Reset(sizeof(packet_buffer_));
+  socket_api.ReadPacket(client_socket, packet_info_interested, &read_result);
+  EXPECT_EQ(server_flow_label, read_result.packet_info.flow_label());
+}
+
+}  // namespace
+}  // namespace test
+}  // namespace quic