]>
Commit | Line | Data |
---|---|---|
d892b155 | 1 | /* |
bbc27441 | 2 | * Copyright (C) 1996-2014 The Squid Software Foundation and contributors |
e25c139f | 3 | * |
bbc27441 AJ |
4 | * Squid software is distributed under GPLv2+ license and includes |
5 | * contributions from numerous individuals and organizations. | |
6 | * Please see the COPYING and CONTRIBUTORS files for details. | |
d892b155 | 7 | */ |
bbc27441 AJ |
8 | |
9 | /* DEBUG: section 51 Filedescriptor Functions */ | |
d892b155 | 10 | |
582c2af2 | 11 | #include "squid.h" |
d841c88d | 12 | #include "comm/Loops.h" |
582c2af2 | 13 | #include "Debug.h" |
ed6e9fb9 | 14 | #include "fatal.h" |
c4ad1349 | 15 | #include "fd.h" |
528b2c61 | 16 | #include "fde.h" |
582c2af2 FC |
17 | #include "globals.h" |
18 | #include "profiler/Profiler.h" | |
985c86bc | 19 | #include "SquidTime.h" |
a7870688 | 20 | |
2a857320 AR |
21 | // Solaris and possibly others lack MSG_NOSIGNAL optimization |
22 | // TODO: move this into compat/? Use a dedicated compat file to avoid dragging | |
9a90d1dd | 23 | // sys/socket.h into the rest of Squid?? |
2a857320 AR |
24 | #ifndef MSG_NOSIGNAL |
25 | #define MSG_NOSIGNAL 0 | |
26 | #endif | |
27 | ||
1f7c9178 | 28 | int default_read_method(int, char *, int); |
29 | int default_write_method(int, const char *, int); | |
7aa9bb3e | 30 | #if _SQUID_WINDOWS_ |
0f15e632 | 31 | int socket_read_method(int, char *, int); |
32 | int socket_write_method(int, const char *, int); | |
33 | int file_read_method(int, char *, int); | |
34 | int file_write_method(int, const char *, int); | |
1bac0258 AR |
35 | #else |
36 | int msghdr_read_method(int, char *, int); | |
37 | int msghdr_write_method(int, const char *, int); | |
0f15e632 | 38 | #endif |
1f7c9178 | 39 | |
26ac0430 AJ |
40 | const char *fdTypeStr[] = { |
41 | "None", | |
42 | "Log", | |
43 | "File", | |
44 | "Socket", | |
45 | "Pipe", | |
1bac0258 | 46 | "MsgHdr", |
26ac0430 AJ |
47 | "Unknown" |
48 | }; | |
22f5d1ca | 49 | |
60c0b5a2 | 50 | static void fdUpdateBiggest(int fd, int); |
a7870688 | 51 | |
52 | static void | |
60c0b5a2 | 53 | fdUpdateBiggest(int fd, int opening) |
a7870688 | 54 | { |
55 | if (fd < Biggest_FD) | |
62e76326 | 56 | return; |
57 | ||
edd1e84c | 58 | assert(fd < Squid_MaxFD); |
62e76326 | 59 | |
a7870688 | 60 | if (fd > Biggest_FD) { |
62e76326 | 61 | /* |
62 | * assert that we are not closing a FD bigger than | |
63 | * our known biggest FD | |
64 | */ | |
65 | assert(opening); | |
66 | Biggest_FD = fd; | |
67 | return; | |
a7870688 | 68 | } |
62e76326 | 69 | |
a7870688 | 70 | /* if we are here, then fd == Biggest_FD */ |
60c0b5a2 | 71 | /* |
72 | * assert that we are closing the biggest FD; we can't be | |
73 | * re-opening it | |
74 | */ | |
75 | assert(!opening); | |
62e76326 | 76 | |
a8214fc7 | 77 | while (Biggest_FD >= 0 && !fd_table[Biggest_FD].flags.open) |
5e263176 | 78 | --Biggest_FD; |
a7870688 | 79 | } |
80 | ||
81 | void | |
4f92c80c | 82 | fd_close(int fd) |
a7870688 | 83 | { |
76f87348 | 84 | fde *F = &fd_table[fd]; |
62e76326 | 85 | |
78611e17 | 86 | assert(fd >= 0); |
be4d35dc | 87 | assert(F->flags.open); |
78611e17 | 88 | |
76f87348 | 89 | if (F->type == FD_FILE) { |
62e76326 | 90 | assert(F->read_handler == NULL); |
91 | assert(F->write_handler == NULL); | |
9e4ad609 | 92 | } |
62e76326 | 93 | |
bf8fe701 | 94 | debugs(51, 3, "fd_close FD " << fd << " " << F->desc); |
d841c88d AJ |
95 | Comm::SetSelect(fd, COMM_SELECT_READ, NULL, NULL, 0); |
96 | Comm::SetSelect(fd, COMM_SELECT_WRITE, NULL, NULL, 0); | |
be4d35dc | 97 | F->flags.open = false; |
60c0b5a2 | 98 | fdUpdateBiggest(fd, 0); |
5e263176 | 99 | --Number_FD; |
bf81adb4 | 100 | *F = fde(); |
a7870688 | 101 | } |
102 | ||
7aa9bb3e | 103 | #if _SQUID_WINDOWS_ |
0f15e632 | 104 | |
105 | int | |
106 | socket_read_method(int fd, char *buf, int len) | |
107 | { | |
fe86a3bf | 108 | int i; |
0242b721 | 109 | PROF_start(recv); |
fe86a3bf | 110 | i = recv(fd, (void *) buf, len, 0); |
0242b721 | 111 | PROF_stop(recv); |
fe86a3bf | 112 | return i; |
0f15e632 | 113 | } |
114 | ||
115 | int | |
116 | file_read_method(int fd, char *buf, int len) | |
117 | { | |
fe86a3bf | 118 | int i; |
119 | PROF_start(read); | |
ce8db2ee | 120 | i = _read(fd, buf, len); |
fe86a3bf | 121 | PROF_stop(read); |
122 | return i; | |
0f15e632 | 123 | } |
124 | ||
125 | int | |
126 | socket_write_method(int fd, const char *buf, int len) | |
127 | { | |
fe86a3bf | 128 | int i; |
129 | PROF_start(send); | |
130 | i = send(fd, (const void *) buf, len, 0); | |
131 | PROF_stop(send); | |
132 | return i; | |
0f15e632 | 133 | } |
134 | ||
135 | int | |
136 | file_write_method(int fd, const char *buf, int len) | |
137 | { | |
0242b721 | 138 | int i; |
139 | PROF_start(write); | |
140 | i = (_write(fd, buf, len)); | |
141 | PROF_stop(write); | |
142 | return i; | |
0f15e632 | 143 | } |
62e76326 | 144 | |
0f15e632 | 145 | #else |
1f7c9178 | 146 | int |
147 | default_read_method(int fd, char *buf, int len) | |
148 | { | |
fe86a3bf | 149 | int i; |
150 | PROF_start(read); | |
151 | i = read(fd, buf, len); | |
152 | PROF_stop(read); | |
153 | return i; | |
1f7c9178 | 154 | } |
155 | ||
156 | int | |
157 | default_write_method(int fd, const char *buf, int len) | |
158 | { | |
fe86a3bf | 159 | int i; |
160 | PROF_start(write); | |
161 | i = write(fd, buf, len); | |
162 | PROF_stop(write); | |
163 | return i; | |
1f7c9178 | 164 | } |
62e76326 | 165 | |
1bac0258 AR |
166 | int |
167 | msghdr_read_method(int fd, char *buf, int len) | |
168 | { | |
169 | PROF_start(read); | |
170 | const int i = recvmsg(fd, reinterpret_cast<msghdr*>(buf), MSG_DONTWAIT); | |
171 | PROF_stop(read); | |
172 | return i; | |
173 | } | |
174 | ||
175 | int | |
176 | msghdr_write_method(int fd, const char *buf, int len) | |
177 | { | |
178 | PROF_start(write); | |
179 | const int i = sendmsg(fd, reinterpret_cast<const msghdr*>(buf), MSG_NOSIGNAL); | |
180 | PROF_stop(write); | |
181 | return i > 0 ? len : i; // len is imprecise but the caller expects a match | |
182 | } | |
183 | ||
0f15e632 | 184 | #endif |
1f7c9178 | 185 | |
a7870688 | 186 | void |
187 | fd_open(int fd, unsigned int type, const char *desc) | |
188 | { | |
4bc3a4cd | 189 | fde *F; |
ceab4c00 | 190 | assert(fd >= 0); |
4bc3a4cd | 191 | F = &fd_table[fd]; |
62e76326 | 192 | |
7197b20d | 193 | if (F->flags.open) { |
e0236918 | 194 | debugs(51, DBG_IMPORTANT, "WARNING: Closing open FD " << std::setw(4) << fd); |
62e76326 | 195 | fd_close(fd); |
6cf028ab | 196 | } |
62e76326 | 197 | |
60c0b5a2 | 198 | assert(!F->flags.open); |
cc192b50 | 199 | debugs(51, 3, "fd_open() FD " << fd << " " << desc); |
76f87348 | 200 | F->type = type; |
be4d35dc | 201 | F->flags.open = true; |
751406fe | 202 | F->epoll_state = 0; |
7aa9bb3e | 203 | #if _SQUID_WINDOWS_ |
62e76326 | 204 | |
629b5f75 | 205 | F->win32.handle = _get_osfhandle(fd); |
206 | ||
0f15e632 | 207 | switch (type) { |
62e76326 | 208 | |
0f15e632 | 209 | case FD_SOCKET: |
62e76326 | 210 | |
0f15e632 | 211 | case FD_PIPE: |
62e76326 | 212 | F->read_method = &socket_read_method; |
213 | F->write_method = &socket_write_method; | |
214 | break; | |
215 | ||
0f15e632 | 216 | case FD_FILE: |
62e76326 | 217 | |
0f15e632 | 218 | case FD_LOG: |
62e76326 | 219 | F->read_method = &file_read_method; |
220 | F->write_method = &file_write_method; | |
221 | break; | |
222 | ||
0f15e632 | 223 | default: |
62e76326 | 224 | fatalf("fd_open(): unknown FD type - FD#: %i, type: %u, desc %s\n", fd, type, desc); |
0f15e632 | 225 | } |
62e76326 | 226 | |
0f15e632 | 227 | #else |
1bac0258 | 228 | switch (type) { |
62e76326 | 229 | |
1bac0258 AR |
230 | case FD_MSGHDR: |
231 | F->read_method = &msghdr_read_method; | |
232 | F->write_method = &msghdr_write_method; | |
233 | break; | |
234 | ||
235 | default: | |
236 | F->read_method = &default_read_method; | |
237 | F->write_method = &default_write_method; | |
238 | break; | |
239 | } | |
62e76326 | 240 | |
0f15e632 | 241 | #endif |
62e76326 | 242 | |
60c0b5a2 | 243 | fdUpdateBiggest(fd, 1); |
62e76326 | 244 | |
a7870688 | 245 | if (desc) |
62e76326 | 246 | xstrncpy(F->desc, desc, FD_DESC_SZ); |
247 | ||
95dc7ff4 | 248 | ++Number_FD; |
a7870688 | 249 | } |
250 | ||
251 | void | |
252 | fd_note(int fd, const char *s) | |
253 | { | |
76f87348 | 254 | fde *F = &fd_table[fd]; |
255 | xstrncpy(F->desc, s, FD_DESC_SZ); | |
a7870688 | 256 | } |
4f92c80c | 257 | |
258 | void | |
259 | fd_bytes(int fd, int len, unsigned int type) | |
260 | { | |
76f87348 | 261 | fde *F = &fd_table[fd]; |
62e76326 | 262 | |
4f92c80c | 263 | if (len < 0) |
62e76326 | 264 | return; |
265 | ||
365e5b34 | 266 | assert(type == FD_READ || type == FD_WRITE); |
62e76326 | 267 | |
4f92c80c | 268 | if (type == FD_READ) |
62e76326 | 269 | F->bytes_read += len; |
4f92c80c | 270 | else |
62e76326 | 271 | F->bytes_written += len; |
4f92c80c | 272 | } |
f17936ab | 273 | |
9e4ad609 | 274 | void |
275 | fdDumpOpen(void) | |
276 | { | |
277 | int i; | |
76f87348 | 278 | fde *F; |
62e76326 | 279 | |
95dc7ff4 | 280 | for (i = 0; i < Squid_MaxFD; ++i) { |
62e76326 | 281 | F = &fd_table[i]; |
282 | ||
283 | if (!F->flags.open) | |
284 | continue; | |
285 | ||
286 | if (i == fileno(debug_log)) | |
287 | continue; | |
288 | ||
e0236918 | 289 | debugs(51, DBG_IMPORTANT, "Open FD "<< std::left<< std::setw(10) << |
bf8fe701 | 290 | (F->bytes_read && F->bytes_written ? "READ/WRITE" : |
26ac0430 | 291 | F->bytes_read ? "READING" : F->bytes_written ? "WRITING" : |
86905e1f | 292 | "UNSTARTED") << |
bf8fe701 | 293 | " "<< std::right << std::setw(4) << i << " " << F->desc); |
9e4ad609 | 294 | } |
f17936ab | 295 | } |
22f5d1ca | 296 | |
297 | int | |
298 | fdNFree(void) | |
299 | { | |
b6a2f15e | 300 | return Squid_MaxFD - Number_FD - Opening_FD; |
22f5d1ca | 301 | } |
4b23e114 | 302 | |
a1ca9253 | 303 | int |
304 | fdUsageHigh(void) | |
305 | { | |
306 | int nrfree = fdNFree(); | |
307 | ||
308 | if (nrfree < (RESERVED_FD << 1)) | |
309 | return 1; | |
310 | ||
311 | if (nrfree < (Number_FD >> 2)) | |
312 | return 1; | |
313 | ||
314 | return 0; | |
315 | } | |
316 | ||
4b23e114 | 317 | /* Called when we runs out of file descriptors */ |
318 | void | |
319 | fdAdjustReserved(void) | |
320 | { | |
e6ccf245 | 321 | int newReserve; |
4b23e114 | 322 | int x; |
323 | static time_t last = 0; | |
324 | /* | |
325 | * don't update too frequently | |
326 | */ | |
62e76326 | 327 | |
4b23e114 | 328 | if (last + 5 > squid_curtime) |
62e76326 | 329 | return; |
330 | ||
4b23e114 | 331 | /* |
332 | * Calculate a new reserve, based on current usage and a small extra | |
333 | */ | |
d85c3078 | 334 | newReserve = Squid_MaxFD - Number_FD + min(25, Squid_MaxFD / 16); |
62e76326 | 335 | |
e6ccf245 | 336 | if (newReserve <= RESERVED_FD) |
62e76326 | 337 | return; |
338 | ||
d85c3078 | 339 | x = Squid_MaxFD - 20 - min(25, Squid_MaxFD / 16); |
62e76326 | 340 | |
e6ccf245 | 341 | if (newReserve > x) { |
62e76326 | 342 | /* perhaps this should be fatal()? -DW */ |
fa84c01d | 343 | debugs(51, DBG_CRITICAL, "WARNING: This machine has a serious shortage of filedescriptors."); |
62e76326 | 344 | newReserve = x; |
4b23e114 | 345 | } |
62e76326 | 346 | |
d85c3078 | 347 | if (Squid_MaxFD - newReserve < min(256, Squid_MaxFD / 2)) |
26ac0430 | 348 | fatalf("Too few filedescriptors available in the system (%d usable of %d).\n", Squid_MaxFD - newReserve, Squid_MaxFD); |
375295eb | 349 | |
62a48c90 AJ |
350 | debugs(51, DBG_CRITICAL, "Reserved FD adjusted from " << RESERVED_FD << " to " << newReserve << |
351 | " due to failures (" << (Squid_MaxFD - newReserve) << "/" << Squid_MaxFD << " file descriptors available)"); | |
e6ccf245 | 352 | RESERVED_FD = newReserve; |
4b23e114 | 353 | } |
f53969cc | 354 |