1 //===-- SelectHelper.cpp ----------------------------------------*- 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 #if defined(__APPLE__)
10 // Enable this special support for Apple builds where we can have unlimited
11 // select bounds. We tried switching to poll() and kqueue and we were panicing
12 // the kernel, so we have to stick with select for now.
13 #define _DARWIN_UNLIMITED_SELECT
14 #endif
15 
16 #include "lldb/Utility/SelectHelper.h"
17 #include "lldb/Utility/LLDBAssert.h"
18 #include "lldb/Utility/Status.h"
19 #include "lldb/lldb-enumerations.h"
20 #include "lldb/lldb-types.h"
21 
22 #include "llvm/ADT/DenseMap.h"
23 #include "llvm/ADT/Optional.h"
24 
25 #include <algorithm>
26 #include <chrono>
27 
28 #include <errno.h>
29 #if defined(_WIN32)
30 // Define NOMINMAX to avoid macros that conflict with std::min and std::max
31 #define NOMINMAX
32 #include <winsock2.h>
33 #else
34 #include <sys/time.h>
35 #include <sys/select.h>
36 #endif
37 
38 
39 SelectHelper::SelectHelper()
40     : m_fd_map(), m_end_time() // Infinite timeout unless
41                                // SelectHelper::SetTimeout() gets called
42 {}
43 
44 void SelectHelper::SetTimeout(const std::chrono::microseconds &timeout) {
45   using namespace std::chrono;
46   m_end_time = steady_clock::time_point(steady_clock::now() + timeout);
47 }
48 
49 void SelectHelper::FDSetRead(lldb::socket_t fd) {
50   m_fd_map[fd].read_set = true;
51 }
52 
53 void SelectHelper::FDSetWrite(lldb::socket_t fd) {
54   m_fd_map[fd].write_set = true;
55 }
56 
57 void SelectHelper::FDSetError(lldb::socket_t fd) {
58   m_fd_map[fd].error_set = true;
59 }
60 
61 bool SelectHelper::FDIsSetRead(lldb::socket_t fd) const {
62   auto pos = m_fd_map.find(fd);
63   if (pos != m_fd_map.end())
64     return pos->second.read_is_set;
65   else
66     return false;
67 }
68 
69 bool SelectHelper::FDIsSetWrite(lldb::socket_t fd) const {
70   auto pos = m_fd_map.find(fd);
71   if (pos != m_fd_map.end())
72     return pos->second.write_is_set;
73   else
74     return false;
75 }
76 
77 bool SelectHelper::FDIsSetError(lldb::socket_t fd) const {
78   auto pos = m_fd_map.find(fd);
79   if (pos != m_fd_map.end())
80     return pos->second.error_is_set;
81   else
82     return false;
83 }
84 
85 static void updateMaxFd(llvm::Optional<lldb::socket_t> &vold,
86                         lldb::socket_t vnew) {
87   if (!vold.hasValue())
88     vold = vnew;
89   else
90     vold = std::max(*vold, vnew);
91 }
92 
93 lldb_private::Status SelectHelper::Select() {
94   lldb_private::Status error;
95 #ifdef _MSC_VER
96   // On windows FD_SETSIZE limits the number of file descriptors, not their
97   // numeric value.
98   lldbassert(m_fd_map.size() <= FD_SETSIZE);
99   if (m_fd_map.size() > FD_SETSIZE)
100     return lldb_private::Status("Too many file descriptors for select()");
101 #endif
102 
103   llvm::Optional<lldb::socket_t> max_read_fd;
104   llvm::Optional<lldb::socket_t> max_write_fd;
105   llvm::Optional<lldb::socket_t> max_error_fd;
106   llvm::Optional<lldb::socket_t> max_fd;
107   for (auto &pair : m_fd_map) {
108     pair.second.PrepareForSelect();
109     const lldb::socket_t fd = pair.first;
110 #if !defined(__APPLE__) && !defined(_MSC_VER)
111     lldbassert(fd < static_cast<int>(FD_SETSIZE));
112     if (fd >= static_cast<int>(FD_SETSIZE)) {
113       error.SetErrorStringWithFormat("%i is too large for select()", fd);
114       return error;
115     }
116 #endif
117     if (pair.second.read_set)
118       updateMaxFd(max_read_fd, fd);
119     if (pair.second.write_set)
120       updateMaxFd(max_write_fd, fd);
121     if (pair.second.error_set)
122       updateMaxFd(max_error_fd, fd);
123     updateMaxFd(max_fd, fd);
124   }
125 
126   if (!max_fd.hasValue()) {
127     error.SetErrorString("no valid file descriptors");
128     return error;
129   }
130 
131   const unsigned nfds = static_cast<unsigned>(*max_fd) + 1;
132   fd_set *read_fdset_ptr = nullptr;
133   fd_set *write_fdset_ptr = nullptr;
134   fd_set *error_fdset_ptr = nullptr;
135 //----------------------------------------------------------------------
136 // Initialize and zero out the fdsets
137 //----------------------------------------------------------------------
138 #if defined(__APPLE__)
139   llvm::SmallVector<fd_set, 1> read_fdset;
140   llvm::SmallVector<fd_set, 1> write_fdset;
141   llvm::SmallVector<fd_set, 1> error_fdset;
142 
143   if (max_read_fd.hasValue()) {
144     read_fdset.resize((nfds / FD_SETSIZE) + 1);
145     read_fdset_ptr = read_fdset.data();
146   }
147   if (max_write_fd.hasValue()) {
148     write_fdset.resize((nfds / FD_SETSIZE) + 1);
149     write_fdset_ptr = write_fdset.data();
150   }
151   if (max_error_fd.hasValue()) {
152     error_fdset.resize((nfds / FD_SETSIZE) + 1);
153     error_fdset_ptr = error_fdset.data();
154   }
155   for (auto &fd_set : read_fdset)
156     FD_ZERO(&fd_set);
157   for (auto &fd_set : write_fdset)
158     FD_ZERO(&fd_set);
159   for (auto &fd_set : error_fdset)
160     FD_ZERO(&fd_set);
161 #else
162   fd_set read_fdset;
163   fd_set write_fdset;
164   fd_set error_fdset;
165 
166   if (max_read_fd.hasValue()) {
167     FD_ZERO(&read_fdset);
168     read_fdset_ptr = &read_fdset;
169   }
170   if (max_write_fd.hasValue()) {
171     FD_ZERO(&write_fdset);
172     write_fdset_ptr = &write_fdset;
173   }
174   if (max_error_fd.hasValue()) {
175     FD_ZERO(&error_fdset);
176     error_fdset_ptr = &error_fdset;
177   }
178 #endif
179   //----------------------------------------------------------------------
180   // Set the FD bits in the fdsets for read/write/error
181   //----------------------------------------------------------------------
182   for (auto &pair : m_fd_map) {
183     const lldb::socket_t fd = pair.first;
184 
185     if (pair.second.read_set)
186       FD_SET(fd, read_fdset_ptr);
187 
188     if (pair.second.write_set)
189       FD_SET(fd, write_fdset_ptr);
190 
191     if (pair.second.error_set)
192       FD_SET(fd, error_fdset_ptr);
193   }
194 
195   //----------------------------------------------------------------------
196   // Setup our timeout time value if needed
197   //----------------------------------------------------------------------
198   struct timeval *tv_ptr = nullptr;
199   struct timeval tv = {0, 0};
200 
201   while (1) {
202     using namespace std::chrono;
203     //------------------------------------------------------------------
204     // Setup out relative timeout based on the end time if we have one
205     //------------------------------------------------------------------
206     if (m_end_time.hasValue()) {
207       tv_ptr = &tv;
208       const auto remaining_dur = duration_cast<microseconds>(
209           m_end_time.getValue() - steady_clock::now());
210       if (remaining_dur.count() > 0) {
211         // Wait for a specific amount of time
212         const auto dur_secs = duration_cast<seconds>(remaining_dur);
213         const auto dur_usecs = remaining_dur % seconds(1);
214         tv.tv_sec = dur_secs.count();
215         tv.tv_usec = dur_usecs.count();
216       } else {
217         // Just poll once with no timeout
218         tv.tv_sec = 0;
219         tv.tv_usec = 0;
220       }
221     }
222     const int num_set_fds = ::select(nfds, read_fdset_ptr, write_fdset_ptr,
223                                      error_fdset_ptr, tv_ptr);
224     if (num_set_fds < 0) {
225       // We got an error
226       error.SetErrorToErrno();
227       if (error.GetError() == EINTR) {
228         error.Clear();
229         continue; // Keep calling select if we get EINTR
230       } else
231         return error;
232     } else if (num_set_fds == 0) {
233       // Timeout
234       error.SetError(ETIMEDOUT, lldb::eErrorTypePOSIX);
235       error.SetErrorString("timed out");
236       return error;
237     } else {
238       // One or more descriptors were set, update the FDInfo::select_is_set
239       // mask so users can ask the SelectHelper class so clients can call one
240       // of:
241 
242       for (auto &pair : m_fd_map) {
243         const int fd = pair.first;
244 
245         if (pair.second.read_set) {
246           if (FD_ISSET(fd, read_fdset_ptr))
247             pair.second.read_is_set = true;
248         }
249         if (pair.second.write_set) {
250           if (FD_ISSET(fd, write_fdset_ptr))
251             pair.second.write_is_set = true;
252         }
253         if (pair.second.error_set) {
254           if (FD_ISSET(fd, error_fdset_ptr))
255             pair.second.error_is_set = true;
256         }
257       }
258       break;
259     }
260   }
261   return error;
262 }
263