]>
Commit | Line | Data |
---|---|---|
f740a279 | 1 | |
429fdbec | 2 | /* |
262a0e14 | 3 | * $Id$ |
429fdbec | 4 | * |
99cce4cb | 5 | * DEBUG: section 2 Unlink Daemon |
429fdbec | 6 | * AUTHOR: Duane Wessels |
7 | * | |
2b6662ba | 8 | * SQUID Web Proxy Cache http://www.squid-cache.org/ |
e25c139f | 9 | * ---------------------------------------------------------- |
429fdbec | 10 | * |
2b6662ba | 11 | * Squid is the result of efforts by numerous individuals from |
12 | * the Internet community; see the CONTRIBUTORS file for full | |
13 | * details. Many organizations have provided support for Squid's | |
14 | * development; see the SPONSORS file for full details. Squid is | |
15 | * Copyrighted (C) 2001 by the Regents of the University of | |
16 | * California; see the COPYRIGHT file for full details. Squid | |
17 | * incorporates software developed and/or copyrighted by other | |
18 | * sources; see the CREDITS file for full details. | |
429fdbec | 19 | * |
20 | * This program is free software; you can redistribute it and/or modify | |
21 | * it under the terms of the GNU General Public License as published by | |
22 | * the Free Software Foundation; either version 2 of the License, or | |
23 | * (at your option) any later version. | |
26ac0430 | 24 | * |
429fdbec | 25 | * This program is distributed in the hope that it will be useful, |
26 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
27 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
28 | * GNU General Public License for more details. | |
26ac0430 | 29 | * |
429fdbec | 30 | * You should have received a copy of the GNU General Public License |
31 | * along with this program; if not, write to the Free Software | |
cbdec147 | 32 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. |
e25c139f | 33 | * |
429fdbec | 34 | */ |
35 | ||
6b8e7481 | 36 | #include "squid.h" |
5c3c8c03 | 37 | #include "SquidTime.h" |
528b2c61 | 38 | #include "fde.h" |
9ece7c7c | 39 | #include "xusleep.h" |
528b2c61 | 40 | |
429fdbec | 41 | /* This code gets linked to Squid */ |
42 | ||
06f8f350 | 43 | static int unlinkd_wfd = -1; |
44 | static int unlinkd_rfd = -1; | |
429fdbec | 45 | |
b5d712b5 | 46 | static void * hIpc; |
5c3c8c03 | 47 | static pid_t pid; |
48 | ||
9bc73deb | 49 | #define UNLINKD_QUEUE_LIMIT 20 |
50 | ||
429fdbec | 51 | void |
52 | unlinkdUnlink(const char *path) | |
53 | { | |
9bc73deb | 54 | char buf[MAXPATHLEN]; |
429fdbec | 55 | int l; |
e053c141 | 56 | int bytes_written; |
9bc73deb | 57 | static int queuelen = 0; |
62e76326 | 58 | |
06f8f350 | 59 | if (unlinkd_wfd < 0) { |
62e76326 | 60 | debug_trap("unlinkdUnlink: unlinkd_wfd < 0"); |
61 | safeunlink(path, 0); | |
62 | return; | |
429fdbec | 63 | } |
62e76326 | 64 | |
9bc73deb | 65 | /* |
9ece7c7c | 66 | * If the queue length is greater than our limit, then we pause |
67 | * for a small amount of time, hoping that unlinkd has some | |
68 | * feedback for us. Maybe it just needs a slice of the CPU's | |
69 | * time. | |
70 | */ | |
9bc73deb | 71 | if (queuelen >= UNLINKD_QUEUE_LIMIT) { |
9ece7c7c | 72 | #if defined(USE_EPOLL) || defined(USE_KQUEUE) |
26ac0430 AJ |
73 | /* |
74 | * DPW 2007-04-23 | |
75 | * We can't use fd_set when using epoll() or kqueue(). In | |
76 | * these cases we block for 10 ms. | |
77 | */ | |
78 | xusleep(10000); | |
9ece7c7c | 79 | #else |
26ac0430 AJ |
80 | /* |
81 | * DPW 2007-04-23 | |
82 | * When we can use select, block for up to 100 ms. | |
83 | */ | |
e7a67ff1 | 84 | struct timeval to; |
85 | fd_set R; | |
86 | FD_ZERO(&R); | |
87 | FD_SET(unlinkd_rfd, &R); | |
88 | to.tv_sec = 0; | |
89 | to.tv_usec = 100000; | |
90 | select(unlinkd_rfd + 1, &R, NULL, NULL, &to); | |
9ece7c7c | 91 | #endif |
9bc73deb | 92 | } |
62e76326 | 93 | |
9bc73deb | 94 | /* |
62e76326 | 95 | * If there is at least one outstanding unlink request, then |
96 | * try to read a response. If there's nothing to read we'll | |
97 | * get an EWOULDBLOCK or whatever. If we get a response, then | |
98 | * decrement the queue size by the number of newlines read. | |
99 | */ | |
9bc73deb | 100 | if (queuelen > 0) { |
e053c141 | 101 | int bytes_read; |
62e76326 | 102 | int i; |
103 | char rbuf[512]; | |
e053c141 | 104 | bytes_read = read(unlinkd_rfd, rbuf, 511); |
62e76326 | 105 | |
e053c141 FC |
106 | if (bytes_read > 0) { |
107 | rbuf[bytes_read] = '\0'; | |
62e76326 | 108 | |
e053c141 | 109 | for (i = 0; i < bytes_read; i++) |
62e76326 | 110 | if ('\n' == rbuf[i]) |
111 | queuelen--; | |
112 | ||
113 | assert(queuelen >= 0); | |
114 | } | |
9bc73deb | 115 | } |
62e76326 | 116 | |
9bc73deb | 117 | l = strlen(path); |
118 | assert(l < MAXPATHLEN); | |
119 | xstrncpy(buf, path, MAXPATHLEN); | |
120 | buf[l++] = '\n'; | |
e053c141 | 121 | bytes_written = write(unlinkd_wfd, buf, l); |
62e76326 | 122 | |
e053c141 | 123 | if (bytes_written < 0) { |
bf8fe701 | 124 | debugs(2, 1, "unlinkdUnlink: write FD " << unlinkd_wfd << " failed: " << xstrerror()); |
62e76326 | 125 | safeunlink(path, 0); |
126 | return; | |
e053c141 FC |
127 | } else if (bytes_written != l) { |
128 | debugs(2, 1, "unlinkdUnlink: FD " << unlinkd_wfd << " only wrote " << bytes_written << " of " << l << " bytes"); | |
62e76326 | 129 | safeunlink(path, 0); |
130 | return; | |
9bc73deb | 131 | } |
62e76326 | 132 | |
83704487 | 133 | statCounter.unlink.requests++; |
5f0c8452 | 134 | /* |
62e76326 | 135 | * Increment this syscalls counter here, even though the syscall |
136 | * is executed by the helper process. We try to be consistent | |
137 | * in counting unlink operations. | |
138 | */ | |
3077778c | 139 | statCounter.syscalls.disk.unlinks++; |
9bc73deb | 140 | queuelen++; |
429fdbec | 141 | } |
142 | ||
143 | void | |
144 | unlinkdClose(void) | |
5c3c8c03 | 145 | #ifdef _SQUID_MSWIN_ |
146 | { | |
147 | ||
26ac0430 | 148 | if (unlinkd_wfd > -1) { |
5c3c8c03 | 149 | debugs(2, 1, "Closing unlinkd pipe on FD " << unlinkd_wfd); |
150 | shutdown(unlinkd_wfd, SD_BOTH); | |
151 | comm_close(unlinkd_wfd); | |
152 | ||
153 | if (unlinkd_wfd != unlinkd_rfd) | |
154 | comm_close(unlinkd_rfd); | |
155 | ||
156 | unlinkd_wfd = -1; | |
157 | ||
158 | unlinkd_rfd = -1; | |
159 | } else | |
160 | debugs(2, 0, "unlinkdClose: WARNING: unlinkd_wfd is " << unlinkd_wfd); | |
161 | ||
26ac0430 | 162 | if (hIpc) { |
5c3c8c03 | 163 | if (WaitForSingleObject(hIpc, 5000) != WAIT_OBJECT_0) { |
164 | getCurrentTime(); | |
165 | debugs(2, 1, "unlinkdClose: WARNING: (unlinkd," << pid << "d) didn't exit in 5 seconds"); | |
166 | } | |
167 | ||
168 | CloseHandle(hIpc); | |
169 | } | |
170 | } | |
171 | #else | |
429fdbec | 172 | { |
5c3c8c03 | 173 | |
3502d32f | 174 | if (unlinkd_wfd < 0) |
62e76326 | 175 | return; |
176 | ||
5c3c8c03 | 177 | debugs(2, 1, "Closing unlinkd pipe on FD " << unlinkd_wfd); |
62e76326 | 178 | |
06f8f350 | 179 | file_close(unlinkd_wfd); |
62e76326 | 180 | |
18e72ae1 | 181 | if (unlinkd_wfd != unlinkd_rfd) |
62e76326 | 182 | file_close(unlinkd_rfd); |
183 | ||
06f8f350 | 184 | unlinkd_wfd = -1; |
62e76326 | 185 | |
06f8f350 | 186 | unlinkd_rfd = -1; |
429fdbec | 187 | } |
188 | ||
5c3c8c03 | 189 | #endif |
190 | ||
429fdbec | 191 | void |
192 | unlinkdInit(void) | |
193 | { | |
a2c963ae | 194 | const char *args[2]; |
b7ac5457 | 195 | Ip::Address localhost; |
62e76326 | 196 | |
06f8f350 | 197 | args[0] = "(unlinkd)"; |
198 | args[1] = NULL; | |
cc192b50 | 199 | localhost.SetLocalhost(); |
200 | ||
b5d712b5 | 201 | pid = ipcCreate( |
1b3db6d9 | 202 | #if USE_POLL && defined(_SQUID_OSF_) |
b5d712b5 | 203 | /* pipes and poll() don't get along on DUNIX -DW */ |
204 | IPC_STREAM, | |
205 | #elif defined(_SQUID_MSWIN_) | |
26ac0430 AJ |
206 | /* select() will fail on a pipe */ |
207 | IPC_TCP_SOCKET, | |
2b9a692c | 208 | #else |
26ac0430 AJ |
209 | /* We currently need to use FIFO.. see below */ |
210 | IPC_FIFO, | |
2b9a692c | 211 | #endif |
b5d712b5 | 212 | Config.Program.unlinkd, |
213 | args, | |
214 | "unlinkd", | |
cc192b50 | 215 | localhost, |
b5d712b5 | 216 | &unlinkd_rfd, |
217 | &unlinkd_wfd, | |
218 | &hIpc); | |
62e76326 | 219 | |
5c3c8c03 | 220 | if (pid < 0) |
62e76326 | 221 | fatal("Failed to create unlinkd subprocess"); |
b5d712b5 | 222 | |
9ece7c7c | 223 | xusleep(250000); |
b5d712b5 | 224 | |
06f8f350 | 225 | fd_note(unlinkd_wfd, "squid -> unlinkd"); |
b5d712b5 | 226 | |
06f8f350 | 227 | fd_note(unlinkd_rfd, "unlinkd -> squid"); |
b5d712b5 | 228 | |
06f8f350 | 229 | commSetTimeout(unlinkd_rfd, -1, NULL, NULL); |
b5d712b5 | 230 | |
06f8f350 | 231 | commSetTimeout(unlinkd_wfd, -1, NULL, NULL); |
b5d712b5 | 232 | |
9bc73deb | 233 | /* |
62e76326 | 234 | * unlinkd_rfd should already be non-blocking because of |
235 | * ipcCreate. We change unlinkd_wfd to blocking mode because | |
236 | * we never want to lose an unlink request, and we don't have | |
237 | * code to retry if we get EWOULDBLOCK. Unfortunately, we can | |
238 | * do this only for the IPC_FIFO case. | |
239 | */ | |
7e3ce7b9 | 240 | assert(fd_table[unlinkd_rfd].flags.nonblocking); |
b5d712b5 | 241 | |
7e3ce7b9 | 242 | if (FD_PIPE == fd_table[unlinkd_wfd].type) |
62e76326 | 243 | commUnsetNonBlocking(unlinkd_wfd); |
b5d712b5 | 244 | |
bf8fe701 | 245 | debugs(2, 1, "Unlinkd pipe opened on FD " << unlinkd_wfd); |
5c3c8c03 | 246 | |
247 | #ifdef _SQUID_MSWIN_ | |
248 | ||
4a7a3d56 | 249 | debugs(2, 4, "Unlinkd handle: 0x" << std::hex << hIpc << std::dec << ", PID: " << pid); |
5c3c8c03 | 250 | |
251 | #endif | |
252 | ||
429fdbec | 253 | } |