src/fd.cc

   1
   2 /*
   3  * $Id$
   4  *
   5  * DEBUG: section 51    Filedescriptor Functions
   6  * AUTHOR: Duane Wessels
   7  *
   8  * SQUID Web Proxy Cache          http://www.squid-cache.org/
   9  * ----------------------------------------------------------
  10  *
  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.
  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.
  24  *
  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.
  29  *
  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
  32  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  33  *
  34  */
  35
  36 #include "squid.h"
  37 #include "fde.h"
  38 #include "SquidTime.h"
  39 #include "Debug.h"
  40
  41 int default_read_method(int, char *, int);
  42 int default_write_method(int, const char *, int);
  43 #ifdef _SQUID_MSWIN_
  44 int socket_read_method(int, char *, int);
  45 int socket_write_method(int, const char *, int);
  46 int file_read_method(int, char *, int);
  47 int file_write_method(int, const char *, int);
  48 #endif
  49
  50 const char *fdTypeStr[] = {
  51     "None",
  52     "Log",
  53     "File",
  54     "Socket",
  55     "Pipe",
  56     "Unknown"
  57 };
  58
  59 static void fdUpdateBiggest(int fd, int);
  60
  61 static void
  62 fdUpdateBiggest(int fd, int opening)
  63 {
  64     if (fd < Biggest_FD)
  65         return;
  66
  67     assert(fd < Squid_MaxFD);
  68
  69     if (fd > Biggest_FD) {
  70         /*
  71          * assert that we are not closing a FD bigger than
  72          * our known biggest FD
  73          */
  74         assert(opening);
  75         Biggest_FD = fd;
  76         return;
  77     }
  78
  79     /* if we are here, then fd == Biggest_FD */
  80     /*
  81      * assert that we are closing the biggest FD; we can't be
  82      * re-opening it
  83      */
  84     assert(!opening);
  85
  86     while (Biggest_FD >= 0 && !fd_table[Biggest_FD].flags.open)
  87         Biggest_FD--;
  88 }
  89
  90 void
  91 fd_close(int fd)
  92 {
  93     fde *F = &fd_table[fd];
  94
  95     if (F->type == FD_FILE) {
  96         assert(F->read_handler == NULL);
  97         assert(F->write_handler == NULL);
  98     }
  99
 100     debugs(51, 3, "fd_close FD " << fd << " " << F->desc);
 101     commSetSelect(fd, COMM_SELECT_READ, NULL, NULL, 0);
 102     commSetSelect(fd, COMM_SELECT_WRITE, NULL, NULL, 0);
 103     F->flags.open = 0;
 104     fdUpdateBiggest(fd, 0);
 105     Number_FD--;
 106     *F = fde();
 107 }
 108
 109 #ifdef _SQUID_MSWIN_
 110
 111 int
 112 socket_read_method(int fd, char *buf, int len)
 113 {
 114     int i;
 115     PROF_start(recv);
 116     i = recv(fd, (void *) buf, len, 0);
 117     PROF_stop(recv);
 118     return i;
 119 }
 120
 121 int
 122 file_read_method(int fd, char *buf, int len)
 123 {
 124     int i;
 125     PROF_start(read);
 126     i = _read(fd, buf, len);
 127     PROF_stop(read);
 128     return i;
 129 }
 130
 131 int
 132 socket_write_method(int fd, const char *buf, int len)
 133 {
 134     int i;
 135     PROF_start(send);
 136     i = send(fd, (const void *) buf, len, 0);
 137     PROF_stop(send);
 138     return i;
 139 }
 140
 141 int
 142 file_write_method(int fd, const char *buf, int len)
 143 {
 144     int i;
 145     PROF_start(write);
 146     i = (_write(fd, buf, len));
 147     PROF_stop(write);
 148     return i;
 149 }
 150
 151 #else
 152 int
 153 default_read_method(int fd, char *buf, int len)
 154 {
 155     int i;
 156     PROF_start(read);
 157     i = read(fd, buf, len);
 158     PROF_stop(read);
 159     return i;
 160 }
 161
 162 int
 163 default_write_method(int fd, const char *buf, int len)
 164 {
 165     int i;
 166     PROF_start(write);
 167     i = write(fd, buf, len);
 168     PROF_stop(write);
 169     return i;
 170 }
 171
 172 #endif
 173
 174 void
 175 fd_open(int fd, unsigned int type, const char *desc)
 176 {
 177     fde *F;
 178     assert(fd >= 0);
 179     F = &fd_table[fd];
 180
 181     if (F->flags.open) {
 182         debugs(51, 1, "WARNING: Closing open FD " << std::setw(4) << fd);
 183         fd_close(fd);
 184     }
 185
 186     assert(!F->flags.open);
 187     debugs(51, 3, "fd_open() FD " << fd << " " << desc);
 188     F->type = type;
 189     F->flags.open = 1;
 190     F->epoll_state = 0;
 191 #ifdef _SQUID_MSWIN_
 192
 193     F->win32.handle = _get_osfhandle(fd);
 194
 195     switch (type) {
 196
 197     case FD_SOCKET:
 198
 199     case FD_PIPE:
 200         F->read_method = &socket_read_method;
 201         F->write_method = &socket_write_method;
 202         break;
 203
 204     case FD_FILE:
 205
 206     case FD_LOG:
 207         F->read_method = &file_read_method;
 208         F->write_method = &file_write_method;
 209         break;
 210
 211     default:
 212         fatalf("fd_open(): unknown FD type - FD#: %i, type: %u, desc %s\n", fd, type, desc);
 213     }
 214
 215 #else
 216     F->read_method = &default_read_method;
 217
 218     F->write_method = &default_write_method;
 219
 220 #endif
 221
 222     fdUpdateBiggest(fd, 1);
 223
 224     if (desc)
 225         xstrncpy(F->desc, desc, FD_DESC_SZ);
 226
 227     Number_FD++;
 228 }
 229
 230 void
 231 fd_note(int fd, const char *s)
 232 {
 233     fde *F = &fd_table[fd];
 234     xstrncpy(F->desc, s, FD_DESC_SZ);
 235 }
 236
 237 void
 238 fd_bytes(int fd, int len, unsigned int type)
 239 {
 240     fde *F = &fd_table[fd];
 241
 242     if (len < 0)
 243         return;
 244
 245     assert(type == FD_READ || type == FD_WRITE);
 246
 247     if (type == FD_READ)
 248         F->bytes_read += len;
 249     else
 250         F->bytes_written += len;
 251 }
 252
 253 void
 254 fdDumpOpen(void)
 255 {
 256     int i;
 257     fde *F;
 258
 259     for (i = 0; i < Squid_MaxFD; i++) {
 260         F = &fd_table[i];
 261
 262         if (!F->flags.open)
 263             continue;
 264
 265         if (i == fileno(debug_log))
 266             continue;
 267
 268         debugs(51, 1, "Open FD "<< std::left<< std::setw(10) <<
 269                (F->bytes_read && F->bytes_written ? "READ/WRITE" :
 270                 F->bytes_read ? "READING" : F->bytes_written ? "WRITING" :
 271                 "UNSTARTED")  <<
 272                " "<< std::right << std::setw(4) << i  << " " << F->desc);
 273     }
 274 }
 275
 276 int
 277 fdNFree(void)
 278 {
 279     return Squid_MaxFD - Number_FD - Opening_FD;
 280 }
 281
 282 int
 283 fdUsageHigh(void)
 284 {
 285     int nrfree = fdNFree();
 286
 287     if (nrfree < (RESERVED_FD << 1))
 288         return 1;
 289
 290     if (nrfree < (Number_FD >> 2))
 291         return 1;
 292
 293     return 0;
 294 }
 295
 296 /* Called when we runs out of file descriptors */
 297 void
 298 fdAdjustReserved(void)
 299 {
 300     int newReserve;
 301     int x;
 302     static time_t last = 0;
 303     /*
 304      * don't update too frequently
 305      */
 306
 307     if (last + 5 > squid_curtime)
 308         return;
 309
 310     /*
 311      * Calculate a new reserve, based on current usage and a small extra
 312      */
 313     newReserve = Squid_MaxFD - Number_FD + XMIN(25, Squid_MaxFD / 16);
 314
 315     if (newReserve <= RESERVED_FD)
 316         return;
 317
 318     x = Squid_MaxFD - 20 - XMIN(25, Squid_MaxFD / 16);
 319
 320     if (newReserve > x) {
 321         /* perhaps this should be fatal()? -DW */
 322         debugs(51, 0, "WARNING: This machine has a serious shortage of filedescriptors.");
 323         newReserve = x;
 324     }
 325
 326     if (Squid_MaxFD - newReserve < XMIN(256, Squid_MaxFD / 2))
 327         fatalf("Too few filedescriptors available in the system (%d usable of %d).\n", Squid_MaxFD - newReserve, Squid_MaxFD);
 328
 329     debugs(51, 0, "Reserved FD adjusted from " << RESERVED_FD << " to " << newReserve << " due to failures");
 330     RESERVED_FD = newReserve;
 331 }