开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 代理服务器 > 查看源码
comm_select.c
资源名称：squid-2.2.devel3-src.tar.gz　[点击查看]
上传用户：liugui
上传日期：2007-01-04
资源大小：822k
文件大小：24k
源码类别：

代理服务器

开发平台：

Unix_Linux

comm_select.c：源码内容
  2. /*
  3.  * $Id: comm_select.c,v 1.29 1999/01/18 22:23:33 wessels Exp $
  4.  *
  5.  * DEBUG: section 5     Socket Functions
  6.  *
  7.  * SQUID Internet Object Cache  http://squid.nlanr.net/Squid/
  8.  * ----------------------------------------------------------
  9.  *
  10.  *  Squid is the result of efforts by numerous individuals from the
  11.  *  Internet community.  Development is led by Duane Wessels of the
  12.  *  National Laboratory for Applied Network Research and funded by the
  13.  *  National Science Foundation.  Squid is Copyrighted (C) 1998 by
  14.  *  Duane Wessels and the University of California San Diego.  Please
  15.  *  see the COPYRIGHT file for full details.  Squid incorporates
  16.  *  software developed and/or copyrighted by other sources.  Please see
  17.  *  the CREDITS file for full details.
  18.  *
  19.  *  This program is free software; you can redistribute it and/or modify
  20.  *  it under the terms of the GNU General Public License as published by
  21.  *  the Free Software Foundation; either version 2 of the License, or
  22.  *  (at your option) any later version.
  23.  *  
  24.  *  This program is distributed in the hope that it will be useful,
  25.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  26.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27.  *  GNU General Public License for more details.
  28.  *  
  29.  *  You should have received a copy of the GNU General Public License
  30.  *  along with this program; if not, write to the Free Software
  31.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  32.  *
  33.  */
  35. #include "squid.h"
  37. #if USE_ASYNC_IO
  38. #define MAX_POLL_TIME 10
  39. #else
  40. #define MAX_POLL_TIME 1000
  41. #endif
  43. #ifndef        howmany
  44. #define howmany(x, y)   (((x)+((y)-1))/(y))
  45. #endif
  46. #ifndef        NBBY
  47. #define        NBBY    8
  48. #endif
  49. #define FD_MASK_BYTES sizeof(fd_mask)
  50. #define FD_MASK_BITS (FD_MASK_BYTES*NBBY)
  52. /* STATIC */
  53. #if !HAVE_POLL
  54. static int examine_select(fd_set *, fd_set *);
  55. #endif
  56. static int fdIsHttp(int fd);
  57. static int fdIsIcp(int fd);
  58. static int commDeferRead(int fd);
  59. static void checkTimeouts(void);
  60. static OBJH commIncomingStats;
  61. #if HAVE_POLL
  62. static int comm_check_incoming_poll_handlers(int nfds, int *fds);
  63. #else
  64. static int comm_check_incoming_select_handlers(int nfds, int *fds);
  65. #endif
  67. static struct timeval zero_tv;
  68. static fd_set global_readfds;
  69. static fd_set global_writefds;
  70. static int nreadfds;
  71. static int nwritefds;
  73. /*
  74.  * Automatic tuning for incoming requests:
  75.  *
  76.  * INCOMING sockets are the ICP and HTTP ports.  We need to check these
  77.  * fairly regularly, but how often?  When the load increases, we
  78.  * want to check the incoming sockets more often.  If we have a lot
  79.  * of incoming ICP, then we need to check these sockets more than
  80.  * if we just have HTTP.
  81.  *
  82.  * The variables 'incoming_icp_interval' and 'incoming_http_interval' 
  83.  * determine how many normal I/O events to process before checking
  84.  * incoming sockets again.  Note we store the incoming_interval
  85.  * multipled by a factor of (2^INCOMING_FACTOR) to have some
  86.  * pseudo-floating point precision.
  87.  *
  88.  * The variable 'icp_io_events' and 'http_io_events' counts how many normal
  89.  * I/O events have been processed since the last check on the incoming
  90.  * sockets.  When io_events > incoming_interval, its time to check incoming
  91.  * sockets.
  92.  *
  93.  * Every time we check incoming sockets, we count how many new messages
  94.  * or connections were processed.  This is used to adjust the
  95.  * incoming_interval for the next iteration.  The new incoming_interval
  96.  * is calculated as the current incoming_interval plus what we would
  97.  * like to see as an average number of events minus the number of
  98.  * events just processed.
  99.  *
  100.  *  incoming_interval = incoming_interval + target_average - number_of_events_processed
  101.  *
  102.  * There are separate incoming_interval counters for both HTTP and ICP events
  103.  * 
  104.  * You can see the current values of the incoming_interval's, as well as
  105.  * a histogram of 'incoming_events' by asking the cache manager
  106.  * for 'comm_incoming', e.g.:
  107.  *
  108.  *      % ./client mgr:comm_incoming
  109.  *
  110.  * Caveats:
  111.  *
  112.  *      - We have MAX_INCOMING_INTEGER as a magic upper limit on
  113.  *        incoming_interval for both types of sockets.  At the
  114.  *        largest value the cache will effectively be idling.
  115.  *
  116.  *      - The higher the INCOMING_FACTOR, the slower the algorithm will
  117.  *        respond to load spikes/increases/decreases in demand. A value
  118.  *        between 3 and 8 is recommended.
  119.  */
  121. #define MAX_INCOMING_INTEGER 256
  122. #define INCOMING_FACTOR 5
  123. #define MAX_INCOMING_INTERVAL (MAX_INCOMING_INTEGER << INCOMING_FACTOR)
  124. static int icp_io_events = 0;
  125. static int http_io_events = 0;
  126. static int incoming_icp_interval = 16 << INCOMING_FACTOR;
  127. static int incoming_http_interval = 16 << INCOMING_FACTOR;
  128. #define commCheckICPIncoming (++icp_io_events > (incoming_icp_interval>> INCOMING_FACTOR))
  129. #define commCheckHTTPIncoming (++http_io_events > (incoming_http_interval>> INCOMING_FACTOR))
  131. static int
  132. commDeferRead(int fd)
  133. {
  134.     fde *F = &fd_table[fd];
  135.     if (F->defer_check == NULL)
  136. return 0;
  137.     return F->defer_check(fd, F->defer_data);
  138. }
  140. static int
  141. fdIsIcp(int fd)
  142. {
  143.     if (fd == theInIcpConnection)
  144. return 1;
  145.     if (fd == theOutIcpConnection)
  146. return 1;
  147.     return 0;
  148. }
  150. static int
  151. fdIsHttp(int fd)
  152. {
  153.     int j;
  154.     for (j = 0; j < NHttpSockets; j++) {
  155. if (fd == HttpSockets[j])
  156.     return 1;
  157.     }
  158.     return 0;
  159. }
  161. #if HAVE_POLL
  162. static int
  163. comm_check_incoming_poll_handlers(int nfds, int *fds)
  164. {
  165.     int i;
  166.     int fd;
  167.     int incame = 0;
  168.     PF *hdl = NULL;
  169.     int npfds;
  170.     struct pollfd pfds[3 + MAXHTTPPORTS];
  171.     for (i = npfds = 0; i < nfds; i++) {
  172. int events;
  173. fd = fds[i];
  174. events = 0;
  175. if (fd_table[fd].read_handler)
  176.     events |= POLLRDNORM;
  177. if (fd_table[fd].write_handler)
  178.     events |= POLLWRNORM;
  179. if (events) {
  180.     pfds[npfds].fd = fd;
  181.     pfds[npfds].events = events;
  182.     pfds[npfds].revents = 0;
  183.     npfds++;
  184. }
  185.     }
  186.     if (!nfds)
  187. return incame;
  188. #if !ALARM_UPDATES_TIME
  189.     getCurrentTime();
  190. #endif
  191.     Counter.syscalls.polls++;
  192.     if (poll(pfds, npfds, 0) < 1)
  193. return incame;
  194.     for (i = 0; i < npfds; i++) {
  195. int revents;
  196. if (((revents = pfds[i].revents) == 0) || ((fd = pfds[i].fd) == -1))
  197.     continue;
  198. if (revents & (POLLRDNORM | POLLIN | POLLHUP | POLLERR)) {
  199.     if ((hdl = fd_table[fd].read_handler)) {
  200. fd_table[fd].read_handler = NULL;
  201. hdl(fd, &incame);
  202.     } else
  203. debug(5, 1) ("comm_poll_incoming: NULL read handlern");
  204. }
  205. if (revents & (POLLWRNORM | POLLOUT | POLLHUP | POLLERR)) {
  206.     if ((hdl = fd_table[fd].write_handler)) {
  207. fd_table[fd].write_handler = NULL;
  208. hdl(fd, &incame);
  209.     } else
  210. debug(5, 1) ("comm_poll_incoming: NULL write handlern");
  211. }
  212.     }
  213.     return incame;
  214. }
  216. static void
  217. comm_poll_icp_incoming(void)
  218. {
  219.     int nfds = 0;
  220.     int fds[2];
  221.     int nevents;
  222.     icp_io_events = 0;
  223.     if (theInIcpConnection >= 0)
  224. fds[nfds++] = theInIcpConnection;
  225.     if (theInIcpConnection != theOutIcpConnection)
  226. if (theOutIcpConnection >= 0)
  227.     fds[nfds++] = theOutIcpConnection;
  228.     if (nfds == 0)
  229. return;
  230.     nevents = comm_check_incoming_poll_handlers(nfds, fds);
  231.     incoming_icp_interval += Config.comm_incoming.icp_average - nevents;
  232.     if (incoming_icp_interval < Config.comm_incoming.icp_min_poll)
  233. incoming_icp_interval = Config.comm_incoming.icp_min_poll;
  234.     if (incoming_icp_interval > MAX_INCOMING_INTERVAL)
  235. incoming_icp_interval = MAX_INCOMING_INTERVAL;
  236.     if (nevents > INCOMING_ICP_MAX)
  237. nevents = INCOMING_ICP_MAX;
  238.     statHistCount(&Counter.comm_icp_incoming, nevents);
  239. }
  241. static void
  242. comm_poll_http_incoming(void)
  243. {
  244.     int nfds = 0;
  245.     int fds[MAXHTTPPORTS];
  246.     int j;
  247.     int nevents;
  248.     http_io_events = 0;
  249.     for (j = 0; j < NHttpSockets; j++) {
  250. if (HttpSockets[j] < 0)
  251.     continue;
  252. if (commDeferRead(HttpSockets[j]))
  253.     continue;
  254. fds[nfds++] = HttpSockets[j];
  255.     }
  256.     nevents = comm_check_incoming_poll_handlers(nfds, fds);
  257.     incoming_http_interval = incoming_http_interval
  258. + Config.comm_incoming.http_average - nevents;
  259.     if (incoming_http_interval < Config.comm_incoming.http_min_poll)
  260. incoming_http_interval = Config.comm_incoming.http_min_poll;
  261.     if (incoming_http_interval > MAX_INCOMING_INTERVAL)
  262. incoming_http_interval = MAX_INCOMING_INTERVAL;
  263.     if (nevents > INCOMING_HTTP_MAX)
  264. nevents = INCOMING_HTTP_MAX;
  265.     statHistCount(&Counter.comm_http_incoming, nevents);
  266. }
  268. /* poll all sockets; call handlers for those that are ready. */
  269. int
  270. comm_poll(int msec)
  271. {
  272.     struct pollfd pfds[SQUID_MAXFD];
  273.     PF *hdl = NULL;
  274.     int fd;
  275.     int i;
  276.     int maxfd;
  277.     unsigned long nfds;
  278.     int num;
  279.     int callicp = 0, callhttp = 0;
  280.     static time_t last_timeout = 0;
  281.     double timeout = current_dtime + (msec / 1000.0);
  282.     double start;
  283.     do {
  284. #if !ALARM_UPDATES_TIME
  285. getCurrentTime();
  286. start = current_dtime;
  287. #endif
  288. #if USE_ASYNC_IO
  289. aioCheckCallbacks();
  290. #endif
  291. if (commCheckICPIncoming)
  292.     comm_poll_icp_incoming();
  293. if (commCheckHTTPIncoming)
  294.     comm_poll_http_incoming();
  295. callicp = callhttp = 0;
  296. nfds = 0;
  297. maxfd = Biggest_FD + 1;
  298. for (i = 0; i < maxfd; i++) {
  299.     int events;
  300.     events = 0;
  301.     /* Check each open socket for a handler. */
  302.     if (fd_table[i].read_handler && !commDeferRead(i))
  303. events |= POLLRDNORM;
  304.     if (fd_table[i].write_handler)
  305. events |= POLLWRNORM;
  306.     if (events) {
  307. pfds[nfds].fd = i;
  308. pfds[nfds].events = events;
  309. pfds[nfds].revents = 0;
  310. nfds++;
  311.     }
  312. }
  313. if (nfds == 0) {
  314.     assert(shutting_down);
  315.     return COMM_SHUTDOWN;
  316. }
  317. if (msec > MAX_POLL_TIME)
  318.     msec = MAX_POLL_TIME;
  319. for (;;) {
  320.     Counter.syscalls.polls++;
  321.     num = poll(pfds, nfds, msec);
  322.     Counter.select_loops++;
  323.     if (num >= 0)
  324. break;
  325.     if (ignoreErrno(errno))
  326. continue;
  327.     debug(5, 0) ("comm_poll: poll failure: %sn", xstrerror());
  328.     assert(errno != EINVAL);
  329.     return COMM_ERROR;
  330.     /* NOTREACHED */
  331. }
  332. debug(5, num ? 5 : 8) ("comm_poll: %d FDs readyn", num);
  333. statHistCount(&Counter.select_fds_hist, num);
  334. /* Check timeout handlers ONCE each second. */
  335. if (squid_curtime > last_timeout) {
  336.     last_timeout = squid_curtime;
  337.     checkTimeouts();
  338. }
  339. if (num == 0)
  340.     continue;
  341. /* scan each socket but the accept socket. Poll this 
  342.  * more frequently to minimize losses due to the 5 connect 
  343.  * limit in SunOS */
  344. for (i = 0; i < nfds; i++) {
  345.     fde *F;
  346.     int revents;
  347.     if (((revents = pfds[i].revents) == 0) || ((fd = pfds[i].fd) == -1))
  348. continue;
  349.     if (fdIsIcp(fd)) {
  350. callicp = 1;
  351. continue;
  352.     }
  353.     if (fdIsHttp(fd)) {
  354. callhttp = 1;
  355. continue;
  356.     }
  357.     F = &fd_table[fd];
  358.     if (revents & (POLLRDNORM | POLLIN | POLLHUP | POLLERR)) {
  359. debug(5, 6) ("comm_poll: FD %d ready for readingn", fd);
  360. if ((hdl = F->read_handler)) {
  361.     F->read_handler = NULL;
  362.     hdl(fd, F->read_data);
  363.     Counter.select_fds++;
  364. }
  365. if (commCheckICPIncoming)
  366.     comm_poll_icp_incoming();
  367. if (commCheckHTTPIncoming)
  368.     comm_poll_http_incoming();
  369.     }
  370.     if (revents & (POLLWRNORM | POLLOUT | POLLHUP | POLLERR)) {
  371. debug(5, 5) ("comm_poll: FD %d ready for writingn", fd);
  372. if ((hdl = F->write_handler)) {
  373.     F->write_handler = NULL;
  374.     hdl(fd, F->write_data);
  375.     Counter.select_fds++;
  376. }
  377. if (commCheckICPIncoming)
  378.     comm_poll_icp_incoming();
  379. if (commCheckHTTPIncoming)
  380.     comm_poll_http_incoming();
  381.     }
  382.     if (revents & POLLNVAL) {
  383. close_handler *ch;
  384. debug(5, 0) ("WARNING: FD %d has handlers, but it's invalid.n", fd);
  385. debug(5, 0) ("FD %d is a %sn", fd, fdTypeStr[F->type]);
  386. debug(5, 0) ("--> %sn", F->desc);
  387. debug(5, 0) ("tmout:%p read:%p write:%pn",
  388.     F->timeout_handler,
  389.     F->read_handler,
  390.     F->write_handler);
  391. for (ch = F->close_handler; ch; ch = ch->next)
  392.     debug(5, 0) (" close handler: %pn", ch->handler);
  393. if (F->close_handler) {
  394.     commCallCloseHandlers(fd);
  395. } else if (F->timeout_handler) {
  396.     debug(5, 0) ("comm_poll: Calling Timeout Handlern");
  397.     F->timeout_handler(fd, F->timeout_data);
  398. }
  399. F->close_handler = NULL;
  400. F->timeout_handler = NULL;
  401. F->read_handler = NULL;
  402. F->write_handler = NULL;
  403. if (F->flags.open)
  404.     fd_close(fd);
  405.     }
  406. }
  407. if (callicp)
  408.     comm_poll_icp_incoming();
  409. if (callhttp)
  410.     comm_poll_http_incoming();
  411. #if !ALARM_UPDATES_TIME
  412. getCurrentTime();
  413. Counter.select_time += (current_dtime - start);
  414. #endif
  415. return COMM_OK;
  416.     } while (timeout > current_dtime);
  417.     debug(5, 8) ("comm_poll: time out: %d.n", squid_curtime);
  418.     return COMM_TIMEOUT;
  419. }
  421. #else
  423. static int
  424. comm_check_incoming_select_handlers(int nfds, int *fds)
  425. {
  426.     int i;
  427.     int fd;
  428.     int incame = 0;
  429.     int maxfd = 0;
  430.     PF *hdl = NULL;
  431.     fd_set read_mask;
  432.     fd_set write_mask;
  433.     FD_ZERO(&read_mask);
  434.     FD_ZERO(&write_mask);
  435.     for (i = 0; i < nfds; i++) {
  436. fd = fds[i];
  437. if (fd_table[fd].read_handler) {
  438.     FD_SET(fd, &read_mask);
  439.     if (fd > maxfd)
  440. maxfd = fd;
  441. }
  442. if (fd_table[fd].write_handler) {
  443.     FD_SET(fd, &write_mask);
  444.     if (fd > maxfd)
  445. maxfd = fd;
  446. }
  447.     }
  448.     if (maxfd++ == 0)
  449. return incame;
  450. #if !ALARM_UPDATES_TIME
  451.     getCurrentTime();
  452. #endif
  453.     Counter.syscalls.selects++;
  454.     if (select(maxfd, &read_mask, &write_mask, NULL, &zero_tv) < 1)
  455. return incame;
  456.     for (i = 0; i < nfds; i++) {
  457. fd = fds[i];
  458. if (FD_ISSET(fd, &read_mask)) {
  459.     if ((hdl = fd_table[fd].read_handler) != NULL) {
  460. fd_table[fd].read_handler = NULL;
  461. commUpdateReadBits(fd, NULL);
  462. hdl(fd, &incame);
  463.     } else {
  464. debug(5, 1) ("comm_select_incoming: NULL read handlern");
  465.     }
  466. }
  467. if (FD_ISSET(fd, &write_mask)) {
  468.     if ((hdl = fd_table[fd].write_handler) != NULL) {
  469. fd_table[fd].write_handler = NULL;
  470. commUpdateWriteBits(fd, NULL);
  471. hdl(fd, &incame);
  472.     } else {
  473. debug(5, 1) ("comm_select_incoming: NULL write handlern");
  474.     }
  475. }
  476.     }
  477.     return incame;
  478. }
  480. static void
  481. comm_select_icp_incoming(void)
  482. {
  483.     int nfds = 0;
  484.     int fds[2];
  485.     int nevents;
  486.     icp_io_events = 0;
  487.     if (theInIcpConnection >= 0)
  488. fds[nfds++] = theInIcpConnection;
  489.     if (theInIcpConnection != theOutIcpConnection)
  490. if (theOutIcpConnection >= 0)
  491.     fds[nfds++] = theOutIcpConnection;
  492.     if (nfds == 0)
  493. return;
  494.     nevents = comm_check_incoming_select_handlers(nfds, fds);
  495.     incoming_icp_interval += Config.comm_incoming.icp_average - nevents;
  496.     if (incoming_icp_interval < 0)
  497. incoming_icp_interval = 0;
  498.     if (incoming_icp_interval > MAX_INCOMING_INTERVAL)
  499. incoming_icp_interval = MAX_INCOMING_INTERVAL;
  500.     if (nevents > INCOMING_ICP_MAX)
  501. nevents = INCOMING_ICP_MAX;
  502.     statHistCount(&Counter.comm_icp_incoming, nevents);
  503. }
  505. static void
  506. comm_select_http_incoming(void)
  507. {
  508.     int nfds = 0;
  509.     int fds[MAXHTTPPORTS];
  510.     int j;
  511.     int nevents;
  512.     http_io_events = 0;
  513.     for (j = 0; j < NHttpSockets; j++) {
  514. if (HttpSockets[j] < 0)
  515.     continue;
  516. if (commDeferRead(HttpSockets[j]))
  517.     continue;
  518. fds[nfds++] = HttpSockets[j];
  519.     }
  520.     nevents = comm_check_incoming_select_handlers(nfds, fds);
  521.     incoming_http_interval += Config.comm_incoming.http_average - nevents;
  522.     if (incoming_http_interval < 0)
  523. incoming_http_interval = 0;
  524.     if (incoming_http_interval > MAX_INCOMING_INTERVAL)
  525. incoming_http_interval = MAX_INCOMING_INTERVAL;
  526.     if (nevents > INCOMING_HTTP_MAX)
  527. nevents = INCOMING_HTTP_MAX;
  528.     statHistCount(&Counter.comm_http_incoming, nevents);
  529. }
  531. #define DEBUG_FDBITS 0
  532. /* Select on all sockets; call handlers for those that are ready. */
  533. int
  534. comm_select(int msec)
  535. {
  536.     fd_set readfds;
  537.     fd_set writefds;
  538.     PF *hdl = NULL;
  539.     int fd;
  540.     int maxfd;
  541.     int num;
  542.     int callicp = 0, callhttp = 0;
  543.     int maxindex;
  544.     int k;
  545.     int j;
  546. #if DEBUG_FDBITS
  547.     int i;
  548. #endif
  549.     fd_mask *fdsp;
  550.     fd_mask tmask;
  551.     static time_t last_timeout = 0;
  552.     struct timeval poll_time;
  553.     double timeout = current_dtime + (msec / 1000.0);
  554.     fde *F;
  555.     do {
  556. #if !ALARM_UPDATES_TIME
  557. getCurrentTime();
  558. #endif
  559. #if USE_ASYNC_IO
  560. aioCheckCallbacks();
  561. #endif
  562. if (commCheckICPIncoming)
  563.     comm_select_icp_incoming();
  564. if (commCheckHTTPIncoming)
  565.     comm_select_http_incoming();
  566. callicp = callhttp = 0;
  567. maxfd = Biggest_FD + 1;
  568. xmemcpy(&readfds, &global_readfds,
  569.     howmany(maxfd, FD_MASK_BITS) * FD_MASK_BYTES);
  570. xmemcpy(&writefds, &global_writefds,
  571.     howmany(maxfd, FD_MASK_BITS) * FD_MASK_BYTES);
  572. /* remove stalled FDs */
  573. maxindex = howmany(maxfd, FD_MASK_BITS);
  574. fdsp = (fd_mask *) & readfds;
  575. for (j = 0; j < maxindex; j++) {
  576.     if ((tmask = fdsp[j]) == 0)
  577. continue; /* no bits here */
  578.     for (k = 0; k < FD_MASK_BITS; k++) {
  579. if (!EBIT_TEST(tmask, k))
  580.     continue;
  581. /* Found a set bit */
  582. fd = (j * FD_MASK_BITS) + k;
  583. if (commDeferRead(fd))
  584.     FD_CLR(fd, &readfds);
  585.     }
  586. }
  587. #if DEBUG_FDBITS
  588. for (i = 0; i < maxfd; i++) {
  589.     /* Check each open socket for a handler. */
  590.     if (fd_table[i].read_handler && !commDeferRead(i)) {
  591. assert(FD_ISSET(i, &readfds));
  592.     }
  593.     if (fd_table[i].write_handler) {
  594. assert(FD_ISSET(i, &writefds));
  595.     }
  596. }
  597. #endif
  598. if (nreadfds + nwritefds == 0) {
  599.     assert(shutting_down);
  600.     return COMM_SHUTDOWN;
  601. }
  602. if (msec > MAX_POLL_TIME)
  603.     msec = MAX_POLL_TIME;
  604. #ifdef _SQUID_OS2_
  605. if (msec < 0)
  606.     msec = MAX_POLL_TIME;
  607. #endif
  608. for (;;) {
  609.     poll_time.tv_sec = msec / 1000;
  610.     poll_time.tv_usec = (msec % 1000) * 1000;
  611.     Counter.syscalls.selects++;
  612.     num = select(maxfd, &readfds, &writefds, NULL, &poll_time);
  613.     Counter.select_loops++;
  614.     if (num >= 0)
  615. break;
  616.     if (ignoreErrno(errno))
  617. break;
  618.     debug(50, 0) ("comm_select: select failure: %sn",
  619. xstrerror());
  620.     examine_select(&readfds, &writefds);
  621.     return COMM_ERROR;
  622.     /* NOTREACHED */
  623. }
  624. if (num < 0)
  625.     continue;
  626. debug(5, num ? 5 : 8) ("comm_select: %d FDs ready at %dn",
  627.     num, (int) squid_curtime);
  628. statHistCount(&Counter.select_fds_hist, num);
  629. /* Check lifetime and timeout handlers ONCE each second.
  630.  * Replaces brain-dead check every time through the loop! */
  631. if (squid_curtime > last_timeout) {
  632.     last_timeout = squid_curtime;
  633.     checkTimeouts();
  634. }
  635. if (num == 0)
  636.     continue;
  637. /* Scan return fd masks for ready descriptors */
  638. fdsp = (fd_mask *) & readfds;
  639. maxindex = howmany(maxfd, FD_MASK_BITS);
  640. for (j = 0; j < maxindex; j++) {
  641.     if ((tmask = fdsp[j]) == 0)
  642. continue; /* no bits here */
  643.     for (k = 0; k < FD_MASK_BITS; k++) {
  644. if (!EBIT_TEST(tmask, k))
  645.     continue;
  646. /* Found a set bit */
  647. fd = (j * FD_MASK_BITS) + k;
  648. #if DEBUG_FDBITS
  649. debug(5, 9) ("FD %d bit set for readingn", fd);
  650. assert(FD_ISSET(fd, &readfds));
  651. #endif
  652. if (fdIsIcp(fd)) {
  653.     callicp = 1;
  654.     continue;
  655. }
  656. if (fdIsHttp(fd)) {
  657.     callhttp = 1;
  658.     continue;
  659. }
  660. F = &fd_table[fd];
  661. debug(5, 6) ("comm_select: FD %d ready for readingn", fd);
  662. if (F->read_handler) {
  663.     hdl = F->read_handler;
  664.     F->read_handler = NULL;
  665.     commUpdateReadBits(fd, NULL);
  666.     hdl(fd, F->read_data);
  667.     Counter.select_fds++;
  668. }
  669. if (commCheckICPIncoming)
  670.     comm_select_icp_incoming();
  671. if (commCheckHTTPIncoming)
  672.     comm_select_http_incoming();
  673. EBIT_CLR(tmask, k); /* this bit is done */
  674. if (tmask == 0)
  675.     break; /* and no more bits left */
  676.     }
  677. }
  678. fdsp = (fd_mask *) & writefds;
  679. for (j = 0; j < maxindex; j++) {
  680.     if ((tmask = fdsp[j]) == 0)
  681. continue; /* no bits here */
  682.     for (k = 0; k < FD_MASK_BITS; k++) {
  683. if (!EBIT_TEST(tmask, k))
  684.     continue;
  685. /* Found a set bit */
  686. fd = (j * FD_MASK_BITS) + k;
  687. #if DEBUG_FDBITS
  688. debug(5, 9) ("FD %d bit set for writingn", fd);
  689. assert(FD_ISSET(fd, &writefds));
  690. #endif
  691. if (fdIsIcp(fd)) {
  692.     callicp = 1;
  693.     continue;
  694. }
  695. if (fdIsHttp(fd)) {
  696.     callhttp = 1;
  697.     continue;
  698. }
  699. F = &fd_table[fd];
  700. debug(5, 5) ("comm_select: FD %d ready for writingn", fd);
  701. if (F->write_handler) {
  702.     hdl = F->write_handler;
  703.     F->write_handler = NULL;
  704.     commUpdateWriteBits(fd, NULL);
  705.     hdl(fd, F->write_data);
  706.     Counter.select_fds++;
  707. }
  708. if (commCheckICPIncoming)
  709.     comm_select_icp_incoming();
  710. if (commCheckHTTPIncoming)
  711.     comm_select_http_incoming();
  712. EBIT_CLR(tmask, k); /* this bit is done */
  713. if (tmask == 0)
  714.     break; /* and no more bits left */
  715.     }
  716. }
  717. if (callicp)
  718.     comm_select_icp_incoming();
  719. if (callhttp)
  720.     comm_select_http_incoming();
  721. return COMM_OK;
  722.     } while (timeout > current_dtime);
  723.     debug(5, 8) ("comm_select: time out: %dn", (int) squid_curtime);
  724.     return COMM_TIMEOUT;
  725. }
  726. #endif
  728. void
  729. comm_select_init(void)
  730. {
  731.     zero_tv.tv_sec = 0;
  732.     zero_tv.tv_usec = 0;
  733.     cachemgrRegister("comm_incoming",
  734. "comm_incoming() stats",
  735. commIncomingStats, 0, 1);
  736.     FD_ZERO(&global_readfds);
  737.     FD_ZERO(&global_writefds);
  738.     nreadfds = nwritefds = 0;
  739. }
  741. #if !HAVE_POLL
  742. /*
  743.  * examine_select - debug routine.
  744.  *
  745.  * I spend the day chasing this core dump that occurs when both the client
  746.  * and the server side of a cache fetch simultaneoulsy abort the
  747.  * connection.  While I haven't really studied the code to figure out how
  748.  * it happens, the snippet below may prevent the cache from exitting:
  749.  * 
  750.  * Call this from where the select loop fails.
  751.  */
  752. static int
  753. examine_select(fd_set * readfds, fd_set * writefds)
  754. {
  755.     int fd = 0;
  756.     fd_set read_x;
  757.     fd_set write_x;
  758.     struct timeval tv;
  759.     close_handler *ch = NULL;
  760.     fde *F = NULL;
  761.     struct stat sb;
  762.     debug(5, 0) ("examine_select: Examining open file descriptors...n");
  763.     for (fd = 0; fd < Squid_MaxFD; fd++) {
  764. FD_ZERO(&read_x);
  765. FD_ZERO(&write_x);
  766. tv.tv_sec = tv.tv_usec = 0;
  767. if (FD_ISSET(fd, readfds))
  768.     FD_SET(fd, &read_x);
  769. else if (FD_ISSET(fd, writefds))
  770.     FD_SET(fd, &write_x);
  771. else
  772.     continue;
  773. Counter.syscalls.selects++;
  774. errno = 0;
  775. if (!fstat(fd, &sb)) {
  776.     debug(5, 5) ("FD %d is valid.n", fd);
  777.     continue;
  778. }
  779. F = &fd_table[fd];
  780. debug(5, 0) ("FD %d: %sn", fd, xstrerror());
  781. debug(5, 0) ("WARNING: FD %d has handlers, but it's invalid.n", fd);
  782. debug(5, 0) ("FD %d is a %s called '%s'n",
  783.     fd,
  784.     fdTypeStr[F->type],
  785.     F->desc);
  786. debug(5, 0) ("tmout:%p read:%p write:%pn",
  787.     F->timeout_handler,
  788.     F->read_handler,
  789.     F->write_handler);
  790. for (ch = F->close_handler; ch; ch = ch->next)
  791.     debug(5, 0) (" close handler: %pn", ch->handler);
  792. if (F->close_handler) {
  793.     commCallCloseHandlers(fd);
  794. } else if (F->timeout_handler) {
  795.     debug(5, 0) ("examine_select: Calling Timeout Handlern");
  796.     F->timeout_handler(fd, F->timeout_data);
  797. }
  798. F->close_handler = NULL;
  799. F->timeout_handler = NULL;
  800. F->read_handler = NULL;
  801. F->write_handler = NULL;
  802. FD_CLR(fd, readfds);
  803. FD_CLR(fd, writefds);
  804.     }
  805.     return 0;
  806. }
  807. #endif
  809. static void
  810. checkTimeouts(void)
  811. {
  812.     int fd;
  813.     fde *F = NULL;
  814.     PF *callback;
  815.     for (fd = 0; fd <= Biggest_FD; fd++) {
  816. F = &fd_table[fd];
  817. if (!F->flags.open)
  818.     continue;
  819. if (F->timeout == 0)
  820.     continue;
  821. if (F->timeout > squid_curtime)
  822.     continue;
  823. debug(5, 5) ("checkTimeouts: FD %d Expiredn", fd);
  824. if (F->timeout_handler) {
  825.     debug(5, 5) ("checkTimeouts: FD %d: Call timeout handlern", fd);
  826.     callback = F->timeout_handler;
  827.     F->timeout_handler = NULL;
  828.     callback(fd, F->timeout_data);
  829. } else {
  830.     debug(5, 5) ("checkTimeouts: FD %d: Forcing comm_close()n", fd);
  831.     comm_close(fd);
  832. }
  833.     }
  834. }
  836. static void
  837. commIncomingStats(StoreEntry * sentry)
  838. {
  839.     StatCounters *f = &Counter;
  840.     storeAppendPrintf(sentry, "Current incoming_icp_interval: %dn",
  841. incoming_icp_interval >> INCOMING_FACTOR);
  842.     storeAppendPrintf(sentry, "Current incoming_http_interval: %dn",
  843. incoming_http_interval >> INCOMING_FACTOR);
  844.     storeAppendPrintf(sentry, "n");
  845.     storeAppendPrintf(sentry, "Histogram of events per incoming socket typen");
  846. #ifdef HAVE_POLL
  847.     storeAppendPrintf(sentry, "ICP Messages handled per comm_poll_icp_incoming() call:n");
  848. #else
  849.     storeAppendPrintf(sentry, "ICP Messages handled per comm_select_icp_incoming() call:n");
  850. #endif
  851.     statHistDump(&f->comm_icp_incoming, sentry, statHistIntDumper);
  852. #ifdef HAVE_POLL
  853.     storeAppendPrintf(sentry, "HTTP Messages handled per comm_poll_http_incoming() call:n");
  854. #else
  855.     storeAppendPrintf(sentry, "HTTP Messages handled per comm_select_http_incoming() call:n");
  856. #endif
  857.     statHistDump(&f->comm_http_incoming, sentry, statHistIntDumper);
  858. }
  860. void
  861. commUpdateReadBits(int fd, PF * handler)
  862. {
  863.     if (handler && !FD_ISSET(fd, &global_readfds)) {
  864. FD_SET(fd, &global_readfds);
  865. nreadfds++;
  866.     } else if (!handler && FD_ISSET(fd, &global_readfds)) {
  867. FD_CLR(fd, &global_readfds);
  868. nreadfds--;
  869.     }
  870. }
  872. void
  873. commUpdateWriteBits(int fd, PF * handler)
  874. {
  875.     if (handler && !FD_ISSET(fd, &global_writefds)) {
  876. FD_SET(fd, &global_writefds);
  877. nwritefds++;
  878.     } else if (!handler && FD_ISSET(fd, &global_writefds)) {
  879. FD_CLR(fd, &global_writefds);
  880. nwritefds--;
  881.     }
  882. }