tcp_bufs.c

用于嵌入式系统的TCP/IP协议栈

void NetRstBuf(NetBuf *buf)
{
  /*lint -save -e416 -specific(-e416) */
  buf->ip_pkt = buf->app_data = buf->data + NIMHLEN;
  buf->ip_data = buf->data + NIMHLEN + IPMHLEN;
  /*lint -restore */
  buf->length = buf->app_len = buf->app_len2 = 0;
  buf->order = 0;
}

/***********************************************************************/
/*   tcpRetBuf: Free previously allocated TCP/IP buffer                */
/*                                                                     */
/*       Input: ptr = pointer to pointer to buffer being returned      */
/*                                                                     */
/*        Note: Assigns NULL to specified buffer pointer               */
/*        Note: Prepends buffer to appropriate free buffer list        */
/*                                                                     */
/***********************************************************************/
void tcpRetBuf(void *ptr)
{
  NetBuf *buf = *(NetBuf **)ptr;

  /*-------------------------------------------------------------------*/
  /* Mask interrupts because critical section follows.                 */
  /*-------------------------------------------------------------------*/
  isrMask();

  /*-------------------------------------------------------------------*/
  /* Check if returning a big buffer.                                  */
  /*-------------------------------------------------------------------*/
  if (buf >= &BufBig[0].hdr && buf <= &BufBig[TCP_BIG_BUFS - 1].hdr)
  {
    if (--BigHead == -1)
      BigHead = TCP_BIG_BUFS - 1;
    BigBufs[BigHead] = buf;
    ++NumFreeBig;
    TcpAssert(NumFreeBig <= TCP_BIG_BUFS);
  }

  /*-------------------------------------------------------------------*/
  /* Otherwise, returning small or medium buffer.                      */
  /*-------------------------------------------------------------------*/
  else
  {
    /*-----------------------------------------------------------------*/
    /* Check for buffer being returned twice.                          */
    /*-----------------------------------------------------------------*/
    TcpAssert(buf->type != TYPE_IN);

    /*-----------------------------------------------------------------*/
    /* Check if returning a small buffer.                              */
    /*-----------------------------------------------------------------*/
    if (buf >= &BufSml[0].hdr && buf <= &BufSml[TCP_SML_BUFS - 1].hdr)
    {
      if (--SmlHead == -1)
        SmlHead = TCP_SML_BUFS - 1;
      SmlBufs[SmlHead] = buf;
      ++NumFreeSml;
      TcpAssert(NumFreeSml <= TCP_SML_BUFS);
    }

    /*-----------------------------------------------------------------*/
    /* Else returning a medium buffer.                                 */
    /*-----------------------------------------------------------------*/
    else
    {
      TcpAssert((buf >= &BufMed[0].hdr) &&
                (buf <= &BufMed[TCP_MED_BUFS - 1].hdr));
      if (--MedHead == -1)
        MedHead = TCP_MED_BUFS - 1;
      MedBufs[MedHead] = buf;
      ++NumFreeMed;
      TcpAssert(NumFreeMed <= TCP_MED_BUFS);
    }
  }

  /*-------------------------------------------------------------------*/
  /* Mark buffer as having been returned.                              */
  /*-------------------------------------------------------------------*/
  buf->type = TYPE_IN;

  /*-------------------------------------------------------------------*/
  /* Ensure pointers to socket and segment record entry are clear.     */
  /*-------------------------------------------------------------------*/
  buf->flush = NULL;
  buf->seg_record = NULL;

  /*-------------------------------------------------------------------*/
  /* Assign NULL to buffer pointer and unmask interrupts.              */
  /*-------------------------------------------------------------------*/
  *(NetBuf **)ptr = NULL;
  isrUnmask();
}

/***********************************************************************/
/* tcpRetRcvBuf: Free previously allocated TCP receive buffer          */
/*                                                                     */
/*       Input: buf = pointer to buffer being returned                 */
/*                                                                     */
/*        Note: Appends buffer to appropriate free buffer list         */
/*                                                                     */
/***********************************************************************/
void tcpRetRcvBuf(NetBuf *buf)
{
  /*-------------------------------------------------------------------*/
  /* Check for buffer being returned twice and mark as returned.       */
  /*-------------------------------------------------------------------*/
  TcpAssert(buf->type != TYPE_IN);
  buf->type = TYPE_IN;

  /*-------------------------------------------------------------------*/
  /* Check if appending a medium buffer.                               */
  /*-------------------------------------------------------------------*/
  if (buf >= &BufMed[0].hdr && buf <= &BufMed[TCP_MED_BUFS - 1].hdr)
  {
    MedBufs[MedTail] = buf;
    if (++MedTail == TCP_MED_BUFS)
      MedTail = 0;
    ++NumFreeMed;
    TcpAssert(NumFreeMed <= TCP_MED_BUFS);
  }

  /*-------------------------------------------------------------------*/
  /* Else check if appending a small buffer.                           */
  /*-------------------------------------------------------------------*/
  else if (buf >= &BufSml[0].hdr && buf <= &BufSml[TCP_SML_BUFS - 1].hdr)
  {
    SmlBufs[SmlTail] = buf;
    if (++SmlTail == TCP_SML_BUFS)
      SmlTail = 0;
    ++NumFreeSml;
    TcpAssert(NumFreeSml <= TCP_SML_BUFS);
  }

  /*-------------------------------------------------------------------*/
  /* Else appending a big buffer.                                      */
  /*-------------------------------------------------------------------*/
  else
  {
    TcpAssert((buf >= &BufBig[0].hdr) &&
              (buf <= &BufBig[TCP_BIG_BUFS - 1].hdr));
    BigBufs[BigTail] = buf;
    if (++BigTail == TCP_BIG_BUFS)
      BigTail = 0;
    ++NumFreeBig;
    TcpAssert(NumFreeBig <= TCP_BIG_BUFS);
  }
}

/***********************************************************************/
/* NetQueryBuf: Display buffer and socket use statistics               */
/*                                                                     */
/***********************************************************************/
void NetQueryBuf(void)
{
  int i, sk_free, sk_min, sk_use, sk_max;
  int s_free, s_min, s_use, s_max;
  int m_free, m_min, m_use, m_max;
  int b_free, b_min, b_use, b_max;

  /*-------------------------------------------------------------------*/
  /* Instantaneously grab the number free and the free low-water mark. */
  /*-------------------------------------------------------------------*/
  isrMask();
  s_free = NumFreeSml;
  s_min  = LowMarkSml;
  m_free = NumFreeMed;
  m_min  = LowMarkMed;
  b_free = NumFreeBig;
  b_min  = LowMarkBig;
  sk_free = Net.SockCount;
  sk_min  = Net.SockMin;
  isrUnmask();

  /*-------------------------------------------------------------------*/
  /* Calculate the number in-use and the in-use high-water mark.       */
  /*-------------------------------------------------------------------*/
  s_use  = TCP_SML_BUFS - s_free;
  s_max  = TCP_SML_BUFS - s_min;
  m_use  = TCP_MED_BUFS - m_free;
  m_max  = TCP_MED_BUFS - m_min;
  b_use  = TCP_BIG_BUFS - b_free;
  b_max  = TCP_BIG_BUFS - b_min;
  sk_use = MAX_NUM_SOCKETS - sk_free;
  sk_max = MAX_NUM_SOCKETS - sk_min;

  /*-------------------------------------------------------------------*/
  /* Now print these values.                                           */
  /*-------------------------------------------------------------------*/
  printf("   Size   Free (min)   In Use (max)\n");
  printf("   ====   ==========   ============\n");
  i = printf("%7u %5u (%u)", TCP_SML_SIZE, s_free, s_min);
  while (++i < 21) putchar(' ');
  printf("%7u (%u)\n", s_use, s_max);

  i = printf("%7u %5u (%u)", TCP_MED_SIZE, m_free, m_min);
  while (++i < 21) putchar(' ');
  printf("%7u (%u)\n", m_use, m_max);

  i = printf("%7u %5u (%u)", TCP_BIG_SIZE, b_free, b_min);
  while (++i < 21) putchar(' ');
  printf("%7u (%u)\n", b_use, b_max);

  i = printf("   sock %5u (%u)", sk_free, sk_min);
  while (++i < 21) putchar(' ');
  printf("%7u (%u)\n", sk_use, sk_max);
}