dist/ntp/libntp/recvbuff.c

   1 /*      $NetBSD: recvbuff.c,v 1.6 2007/08/18 13:18:23 kardel Exp $      */
   2
   3 #ifdef HAVE_CONFIG_H
   4 # include <config.h>
   5 #endif
   6
   7 #include <stdio.h>
   8 #include "ntp_machine.h"
   9 #include "ntp_fp.h"
  10 #include "ntp_syslog.h"
  11 #include "ntp_stdlib.h"
  12 #include "ntp_io.h"
  13 #include "recvbuff.h"
  14 #include "iosignal.h"
  15
  16 #include <isc/list.h>
  17 /*
  18  * Memory allocation
  19  */
  20 static u_long volatile full_recvbufs;   /* number of recvbufs on fulllist */
  21 static u_long volatile free_recvbufs;   /* number of recvbufs on freelist */
  22 static u_long volatile total_recvbufs;  /* total recvbufs currently in use */
  23 static u_long volatile lowater_adds;    /* number of times we have added memory */
  24 static u_long volatile buffer_shortfall;/* number of missed free receive buffers
  25                                            between replenishments */
  26
  27 static ISC_LIST(recvbuf_t)      full_recv_list; /* Currently used recv buffers */
  28 static ISC_LIST(recvbuf_t)      free_recv_list; /* Currently unused buffers */
  29
  30 #if defined(SYS_WINNT)
  31
  32 /*
  33  * For Windows we need to set up a lock to manipulate the
  34  * recv buffers to prevent corruption. We keep it lock for as
  35  * short a time as possible
  36  */
  37 static CRITICAL_SECTION RecvLock;
  38 # define LOCK()         EnterCriticalSection(&RecvLock)
  39 # define UNLOCK()       LeaveCriticalSection(&RecvLock)
  40 #else
  41 # define LOCK()
  42 # define UNLOCK()
  43 #endif
  44
  45 u_long
  46 free_recvbuffs (void)
  47 {
  48         return free_recvbufs;
  49 }
  50
  51 u_long
  52 full_recvbuffs (void)
  53 {
  54         return full_recvbufs;
  55 }
  56
  57 u_long
  58 total_recvbuffs (void)
  59 {
  60         return total_recvbufs;
  61 }
  62
  63 u_long
  64 lowater_additions(void)
  65 {
  66         return lowater_adds;
  67 }
  68
  69 static void
  70 initialise_buffer(recvbuf_t *buff)
  71 {
  72         memset((char *) buff, 0, sizeof(recvbuf_t));
  73
  74 #if defined SYS_WINNT
  75         buff->wsabuff.len = RX_BUFF_SIZE;
  76         buff->wsabuff.buf = (char *) buff->recv_buffer;
  77 #endif
  78 }
  79
  80 static void
  81 create_buffers(int nbufs)
  82 {
  83         register recvbuf_t *bufp;
  84         int i, abuf;
  85
  86         abuf = nbufs + buffer_shortfall;
  87         buffer_shortfall = 0;
  88
  89         bufp = (recvbuf_t *) emalloc(abuf*sizeof(recvbuf_t));
  90
  91         for (i = 0; i < abuf; i++)
  92         {
  93                 memset((char *) bufp, 0, sizeof(recvbuf_t));
  94                 ISC_LIST_APPEND(free_recv_list, bufp, link);
  95                 bufp++;
  96                 free_recvbufs++;
  97                 total_recvbufs++;
  98         }
  99         lowater_adds++;
 100 }
 101
 102 void
 103 init_recvbuff(int nbufs)
 104 {
 105
 106         /*
 107          * Init buffer free list and stat counters
 108          */
 109         ISC_LIST_INIT(full_recv_list);
 110         ISC_LIST_INIT(free_recv_list);
 111         free_recvbufs = total_recvbufs = 0;
 112         full_recvbufs = lowater_adds = 0;
 113
 114         create_buffers(nbufs);
 115
 116 #if defined(SYS_WINNT)
 117         InitializeCriticalSection(&RecvLock);
 118 #endif
 119
 120 }
 121
 122 /*
 123  * freerecvbuf - make a single recvbuf available for reuse
 124  */
 125 void
 126 freerecvbuf(recvbuf_t *rb)
 127 {
 128         if (rb == NULL) {
 129                 msyslog(LOG_ERR, "freerecvbuff received NULL buffer");
 130                 return;
 131         }
 132
 133         LOCK();
 134         (rb->used)--;
 135         if (rb->used != 0)
 136                 msyslog(LOG_ERR, "******** freerecvbuff non-zero usage: %d *******", rb->used);
 137         ISC_LIST_APPEND(free_recv_list, rb, link);
 138 #if defined SYS_WINNT
 139         rb->wsabuff.len = RX_BUFF_SIZE;
 140         rb->wsabuff.buf = (char *) rb->recv_buffer;
 141 #endif
 142         free_recvbufs++;
 143         UNLOCK();
 144 }
 145
 146
 147 void
 148 add_full_recv_buffer(recvbuf_t *rb)
 149 {
 150         if (rb == NULL) {
 151                 msyslog(LOG_ERR, "add_full_recv_buffer received NULL buffer");
 152                 return;
 153         }
 154         LOCK();
 155         ISC_LIST_APPEND(full_recv_list, rb, link);
 156         full_recvbufs++;
 157         UNLOCK();
 158 }
 159
 160 recvbuf_t *
 161 get_free_recv_buffer(void)
 162 {
 163         recvbuf_t * buffer = NULL;
 164         LOCK();
 165         buffer = ISC_LIST_HEAD(free_recv_list);
 166         if (buffer != NULL)
 167         {
 168                 ISC_LIST_DEQUEUE(free_recv_list, buffer, link);
 169                 free_recvbufs--;
 170                 initialise_buffer(buffer);
 171                 (buffer->used)++;
 172         }
 173         else
 174         {
 175                 buffer_shortfall++;
 176         }
 177         UNLOCK();
 178         return (buffer);
 179 }
 180
 181 #ifdef HAVE_IO_COMPLETION_PORT
 182 recvbuf_t *
 183 get_free_recv_buffer_alloc(void)
 184 {
 185         recvbuf_t * buffer = get_free_recv_buffer();
 186         if (buffer == NULL)
 187         {
 188                 create_buffers(RECV_INC);
 189                 buffer = get_free_recv_buffer();
 190         }
 191         return (buffer);
 192 }
 193 #endif
 194
 195 recvbuf_t *
 196 get_full_recv_buffer(void)
 197 {
 198         recvbuf_t *rbuf;
 199         LOCK();
 200
 201 #ifdef HAVE_SIGNALED_IO
 202         /*
 203          * make sure there are free buffers when we
 204          * wander off to do lengthy paket processing with
 205          * any buffer we grab from the full list.
 206          *
 207          * fixes malloc() interrupted by SIGIO risk
 208          * (Bug 889)
 209          */
 210         rbuf = ISC_LIST_HEAD(free_recv_list);
 211         if (rbuf == NULL || buffer_shortfall > 0) {
 212                 /*
 213                  * try to get us some more buffers
 214                  */
 215                 create_buffers(RECV_INC);
 216         }
 217 #endif
 218
 219         /*
 220          * try to grab a full buffer
 221          */
 222         rbuf = ISC_LIST_HEAD(full_recv_list);
 223         if (rbuf != NULL)
 224         {
 225                 ISC_LIST_DEQUEUE(full_recv_list, rbuf, link);
 226                 --full_recvbufs;
 227         }
 228         else
 229         {
 230                 /*
 231                  * Make sure we reset the full count to 0
 232                  */
 233                 full_recvbufs = 0;
 234         }
 235         UNLOCK();
 236         return (rbuf);
 237 }
 238
 239 /*
 240  * Checks to see if there are buffers to process
 241  */
 242 isc_boolean_t has_full_recv_buffer(void)
 243 {
 244         if (ISC_LIST_HEAD(full_recv_list) != NULL)
 245                 return (ISC_TRUE);
 246         else
 247                 return (ISC_FALSE);
 248 }