LLVM 19.0.0git
raw_socket_stream.cpp
Go to the documentation of this file.
1//===-- llvm/Support/raw_socket_stream.cpp - Socket streams --*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file contains raw_ostream implementations for streams to communicate
10// via UNIX sockets
11//
12//===----------------------------------------------------------------------===//
13
15#include "llvm/Config/config.h"
16#include "llvm/Support/Error.h"
18
19#include <atomic>
20#include <fcntl.h>
21#include <thread>
22
23#ifndef _WIN32
24#include <poll.h>
25#include <sys/socket.h>
26#include <sys/un.h>
27#else
29// winsock2.h must be included before afunix.h. Briefly turn off clang-format to
30// avoid error.
31// clang-format off
32#include <winsock2.h>
33#include <afunix.h>
34// clang-format on
35#include <io.h>
36#endif // _WIN32
37
38#if defined(HAVE_UNISTD_H)
39#include <unistd.h>
40#endif
41
42using namespace llvm;
43
44#ifdef _WIN32
45WSABalancer::WSABalancer() {
46 WSADATA WsaData;
47 ::memset(&WsaData, 0, sizeof(WsaData));
48 if (WSAStartup(MAKEWORD(2, 2), &WsaData) != 0) {
49 llvm::report_fatal_error("WSAStartup failed");
50 }
51}
52
53WSABalancer::~WSABalancer() { WSACleanup(); }
54#endif // _WIN32
55
56static std::error_code getLastSocketErrorCode() {
57#ifdef _WIN32
58 return std::error_code(::WSAGetLastError(), std::system_category());
59#else
60 return errnoAsErrorCode();
61#endif
62}
63
64static sockaddr_un setSocketAddr(StringRef SocketPath) {
65 struct sockaddr_un Addr;
66 memset(&Addr, 0, sizeof(Addr));
67 Addr.sun_family = AF_UNIX;
68 strncpy(Addr.sun_path, SocketPath.str().c_str(), sizeof(Addr.sun_path) - 1);
69 return Addr;
70}
71
73#ifdef _WIN32
74 SOCKET Socket = socket(AF_UNIX, SOCK_STREAM, 0);
75 if (Socket == INVALID_SOCKET) {
76#else
77 int Socket = socket(AF_UNIX, SOCK_STREAM, 0);
78 if (Socket == -1) {
79#endif // _WIN32
80 return llvm::make_error<StringError>(getLastSocketErrorCode(),
81 "Create socket failed");
82 }
83
84 struct sockaddr_un Addr = setSocketAddr(SocketPath);
85 if (::connect(Socket, (struct sockaddr *)&Addr, sizeof(Addr)) == -1)
86 return llvm::make_error<StringError>(getLastSocketErrorCode(),
87 "Connect socket failed");
88
89#ifdef _WIN32
90 return _open_osfhandle(Socket, 0);
91#else
92 return Socket;
93#endif // _WIN32
94}
95
96ListeningSocket::ListeningSocket(int SocketFD, StringRef SocketPath,
97 int PipeFD[2])
98 : FD(SocketFD), SocketPath(SocketPath), PipeFD{PipeFD[0], PipeFD[1]} {}
99
100ListeningSocket::ListeningSocket(ListeningSocket &&LS)
101 : FD(LS.FD.load()), SocketPath(LS.SocketPath),
102 PipeFD{LS.PipeFD[0], LS.PipeFD[1]} {
103
104 LS.FD = -1;
105 LS.SocketPath.clear();
106 LS.PipeFD[0] = -1;
107 LS.PipeFD[1] = -1;
108}
109
111 int MaxBacklog) {
112
113 // Handle instances where the target socket address already exists and
114 // differentiate between a preexisting file with and without a bound socket
115 //
116 // ::bind will return std::errc:address_in_use if a file at the socket address
117 // already exists (e.g., the file was not properly unlinked due to a crash)
118 // even if another socket has not yet binded to that address
119 if (llvm::sys::fs::exists(SocketPath)) {
120 Expected<int> MaybeFD = getSocketFD(SocketPath);
121 if (!MaybeFD) {
122
123 // Regardless of the error, notify the caller that a file already exists
124 // at the desired socket address and that there is no bound socket at that
125 // address. The file must be removed before ::bind can use the address
126 consumeError(MaybeFD.takeError());
127 return llvm::make_error<StringError>(
128 std::make_error_code(std::errc::file_exists),
129 "Socket address unavailable");
130 }
131 ::close(std::move(*MaybeFD));
132
133 // Notify caller that the provided socket address already has a bound socket
134 return llvm::make_error<StringError>(
135 std::make_error_code(std::errc::address_in_use),
136 "Socket address unavailable");
137 }
138
139#ifdef _WIN32
140 WSABalancer _;
141 SOCKET Socket = socket(AF_UNIX, SOCK_STREAM, 0);
142 if (Socket == INVALID_SOCKET)
143#else
144 int Socket = socket(AF_UNIX, SOCK_STREAM, 0);
145 if (Socket == -1)
146#endif
147 return llvm::make_error<StringError>(getLastSocketErrorCode(),
148 "socket create failed");
149
150 struct sockaddr_un Addr = setSocketAddr(SocketPath);
151 if (::bind(Socket, (struct sockaddr *)&Addr, sizeof(Addr)) == -1) {
152 // Grab error code from call to ::bind before calling ::close
153 std::error_code EC = getLastSocketErrorCode();
154 ::close(Socket);
155 return llvm::make_error<StringError>(EC, "Bind error");
156 }
157
158 // Mark socket as passive so incoming connections can be accepted
159 if (::listen(Socket, MaxBacklog) == -1)
160 return llvm::make_error<StringError>(getLastSocketErrorCode(),
161 "Listen error");
162
163 int PipeFD[2];
164#ifdef _WIN32
165 // Reserve 1 byte for the pipe and use default textmode
166 if (::_pipe(PipeFD, 1, 0) == -1)
167#else
168 if (::pipe(PipeFD) == -1)
169#endif // _WIN32
170 return llvm::make_error<StringError>(getLastSocketErrorCode(),
171 "pipe failed");
172
173#ifdef _WIN32
174 return ListeningSocket{_open_osfhandle(Socket, 0), SocketPath, PipeFD};
175#else
176 return ListeningSocket{Socket, SocketPath, PipeFD};
177#endif // _WIN32
178}
179
181ListeningSocket::accept(std::chrono::milliseconds Timeout) {
182
183 struct pollfd FDs[2];
184 FDs[0].events = POLLIN;
185#ifdef _WIN32
186 SOCKET WinServerSock = _get_osfhandle(FD);
187 FDs[0].fd = WinServerSock;
188#else
189 FDs[0].fd = FD;
190#endif
191 FDs[1].events = POLLIN;
192 FDs[1].fd = PipeFD[0];
193
194 // Keep track of how much time has passed in case poll is interupted by a
195 // signal and needs to be recalled
196 int RemainingTime = Timeout.count();
197 std::chrono::milliseconds ElapsedTime = std::chrono::milliseconds(0);
198 int PollStatus = -1;
199
200 while (PollStatus == -1 && (Timeout.count() == -1 || ElapsedTime < Timeout)) {
201 if (Timeout.count() != -1)
202 RemainingTime -= ElapsedTime.count();
203
204 auto Start = std::chrono::steady_clock::now();
205#ifdef _WIN32
206 PollStatus = WSAPoll(FDs, 2, RemainingTime);
207#else
208 PollStatus = ::poll(FDs, 2, RemainingTime);
209#endif
210 // If FD equals -1 then ListeningSocket::shutdown has been called and it is
211 // appropriate to return operation_canceled
212 if (FD.load() == -1)
213 return llvm::make_error<StringError>(
214 std::make_error_code(std::errc::operation_canceled),
215 "Accept canceled");
216
217#if _WIN32
218 if (PollStatus == SOCKET_ERROR) {
219#else
220 if (PollStatus == -1) {
221#endif
222 std::error_code PollErrCode = getLastSocketErrorCode();
223 // Ignore EINTR (signal occured before any request event) and retry
224 if (PollErrCode != std::errc::interrupted)
225 return llvm::make_error<StringError>(PollErrCode, "FD poll failed");
226 }
227 if (PollStatus == 0)
228 return llvm::make_error<StringError>(
229 std::make_error_code(std::errc::timed_out),
230 "No client requests within timeout window");
231
232 if (FDs[0].revents & POLLNVAL)
233 return llvm::make_error<StringError>(
234 std::make_error_code(std::errc::bad_file_descriptor));
235
236 auto Stop = std::chrono::steady_clock::now();
237 ElapsedTime +=
238 std::chrono::duration_cast<std::chrono::milliseconds>(Stop - Start);
239 }
240
241 int AcceptFD;
242#ifdef _WIN32
243 SOCKET WinAcceptSock = ::accept(WinServerSock, NULL, NULL);
244 AcceptFD = _open_osfhandle(WinAcceptSock, 0);
245#else
246 AcceptFD = ::accept(FD, NULL, NULL);
247#endif
248
249 if (AcceptFD == -1)
250 return llvm::make_error<StringError>(getLastSocketErrorCode(),
251 "Socket accept failed");
252 return std::make_unique<raw_socket_stream>(AcceptFD);
253}
254
256 int ObservedFD = FD.load();
257
258 if (ObservedFD == -1)
259 return;
260
261 // If FD equals ObservedFD set FD to -1; If FD doesn't equal ObservedFD then
262 // another thread is responsible for shutdown so return
263 if (!FD.compare_exchange_strong(ObservedFD, -1))
264 return;
265
266 ::close(ObservedFD);
267 ::unlink(SocketPath.c_str());
268
269 // Ensure ::poll returns if shutdown is called by a seperate thread
270 char Byte = 'A';
271 ssize_t written = ::write(PipeFD[1], &Byte, 1);
272
273 // Ignore any write() error
274 (void)written;
275}
276
278 shutdown();
279
280 // Close the pipe's FDs in the destructor instead of within
281 // ListeningSocket::shutdown to avoid unnecessary synchronization issues that
282 // would occur as PipeFD's values would have to be changed to -1
283 //
284 // The move constructor sets PipeFD to -1
285 if (PipeFD[0] != -1)
286 ::close(PipeFD[0]);
287 if (PipeFD[1] != -1)
288 ::close(PipeFD[1]);
289}
290
291//===----------------------------------------------------------------------===//
292// raw_socket_stream
293//===----------------------------------------------------------------------===//
294
296 : raw_fd_stream(SocketFD, true) {}
297
300#ifdef _WIN32
301 WSABalancer _;
302#endif // _WIN32
303 Expected<int> FD = getSocketFD(SocketPath);
304 if (!FD)
305 return FD.takeError();
306 return std::make_unique<raw_socket_stream>(*FD);
307}
308
AMDGPU Mark last scratch load
basic Basic Alias true
uint64_t Addr
#define _
Tagged union holding either a T or a Error.
Definition: Error.h:474
Error takeError()
Take ownership of the stored error.
Definition: Error.h:601
Manages a passive (i.e., listening) UNIX domain socket.
static Expected< ListeningSocket > createUnix(StringRef SocketPath, int MaxBacklog=llvm::hardware_concurrency().compute_thread_count())
Creates a listening socket bound to the specified file system path.
void shutdown()
Closes the FD, unlinks the socket file, and writes to PipeFD.
Expected< std::unique_ptr< raw_socket_stream > > accept(std::chrono::milliseconds Timeout=std::chrono::milliseconds(-1))
Accepts an incoming connection on the listening socket.
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:223
A raw_ostream of a file for reading/writing/seeking.
Definition: raw_ostream.h:628
static Expected< std::unique_ptr< raw_socket_stream > > createConnectedUnix(StringRef SocketPath)
Create a raw_socket_stream connected to the UNIX domain socket at SocketPath.
bool exists(const basic_file_status &status)
Does file exist?
Definition: Path.cpp:1078
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
Error write(MCStreamer &Out, ArrayRef< std::string > Inputs, OnCuIndexOverflow OverflowOptValue)
Definition: DWP.cpp:601
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:159
std::error_code errnoAsErrorCode()
Helper to get errno as an std::error_code.
Definition: Error.h:1193
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1041
static Expected< int > getSocketFD(StringRef SocketPath)
static std::error_code getLastSocketErrorCode()
static sockaddr_un setSocketAddr(StringRef SocketPath)