buffers.h

Go to the documentation of this file.

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
/* This file provides the definitions for handling Buffers */
 
#include <constants.h>   // Added 3-22-12, dciliske
 
#ifndef _NB_BUFFERS_H
#define _NB_BUFFERS_H
 
#ifdef _DEBUG
#define BUFFER_DIAG
#endif
 
#include <basictypes.h>
#include <nbrtos.h>
 
struct pool_buffer; /*Forward declaration*/
typedef struct pool_buffer *PoolPtr;
typedef volatile PoolPtr VPoolPtr;
 
#define BO_UNUSED 0   
#define BO_SOFTWARE 1 
#define BO_PRX 2      
#define BO_PTXF 3     
#define BO_PTXS 4     
#define BS_PHY_BCAST 1    
#define BS_IP_BCAST 2     
#define BS_IP_LOCAL_NET 4 
#define BS_TCP_PUSH 8     
#define BS_PHY_802_3 0x10 
#define BS_VLAN 0x20      
#define BS_DBG_LOG 0x80   
#ifdef BUFFER_DIAG
#define BUFFER_DIAG_WORD_COUNT 4
#else
#define BUFFER_DIAG_WORD_COUNT 0
#endif
#ifdef NET_SHIFT16
#define BUF_PREDATA_SENTINAL_LEN (8)
#define BUF_PREDATA_PADLEN 8
#define BUF_POSTDATA_PADLEN 3
#define BUF_POSTDATA_SENTINAL_LEN (11 - BUFFER_DIAG_WORD_COUNT)
#else
#define BUF_PREDATA_SENTINAL_LEN (8)
#define BUF_PREDATA_PADLEN 6
#define BUF_POSTDATA_PADLEN 3
#define BUF_POSTDATA_SENTINAL_LEN (12 - BUFFER_DIAG_WORD_COUNT)
#endif
 
struct pool_buffer : public OS_FIFO_EL
{
    //      puint8_t pBufQueuePointer;          /* For the OS FIFO list stuff */
    uint32_t PreSentinal[BUF_PREDATA_SENTINAL_LEN];
 
    VPoolPtr pPoolNext;    
    VPoolPtr pPoolPrev;    
    vuint32_t dwTime;      
    vuint32_t dwTimeFraction; 
    vuint16_t usedsize;    
    uint8_t bBuffer_state; 
    uint8_t bBufferFlag;   
    uint8_t bUsageCount;   
    uint8_t bInterfaceNumber; 
    uint8_t bAlignmentPad[BUF_PREDATA_PADLEN];
    uint8_t pData[ETHER_BUFFER_SIZE]; 
    uint8_t bPostAlignmentPad[BUF_POSTDATA_PADLEN];
    uint32_t PostSentinal[BUF_POSTDATA_SENTINAL_LEN];
 
#ifdef BUFFER_DIAG
    PCSTR m_fAlloc;
    uint32_t m_fline;
    uint32_t m_fill;
    uint32_t m_fill2;
#endif /* BUFFER_DIAG */
};
 
inline uint8_t OSPoolFifoPost(OS_FIFO *pFifo, PoolPtr pToPost)
{
    return pFifo->Post(pToPost);
}
 
inline uint8_t OSPoolFifoPostFirst(OS_FIFO *pFifo, PoolPtr pToPost)
{
    return pFifo->PostFirst(pToPost);
}
 
inline PoolPtr OSPoolFifoPend(OS_FIFO *pFifo, uint16_t timeout)
{
    return static_cast<PoolPtr>(pFifo->Pend(timeout));
}
 
inline PoolPtr OSPoolFifoPend(OS_FIFO *pFifo, TickTimeout timeout)
{
    return static_cast<PoolPtr>(pFifo->Pend(timeout));
}
 
 
inline PoolPtr OSPoolFifoPendNoWait(OS_FIFO *pFifo)
{
    return static_cast<PoolPtr>(pFifo->PendNoWait());
}
 
/*Buffer operations*/
 
#ifdef BUFFER_DIAG
void ShowBuffers();
void ShowBuffers_Web(int sockfd);
PoolPtr GetBufferX(PCSTR file, int line);
#define GetBuffer() GetBufferX(__FILE__, __LINE__)
#ifdef FAST_BUFFERS
PoolPtr GetFastBufferX(PCSTR file, int line);
#define GetFastBuffer() GetFastBufferX(__FILE__, __LINE__)
#else /* #ifdef FAST_BUFFERS */
#define GetFastBuffer() GetBufferX(__FILE__, __LINE__)
#endif                                                /* #ifdef FAST_BUFFERS */
void FreeBufferX(PoolPtr nbuf, PCSTR file, int line);
#define FreeBuffer(x) FreeBufferX(x, __FILE__, __LINE__)
 
void ChangeOwnerX(PoolPtr nbuf, PCSTR file, int line);
#define ChangeOwner(x) ChangeOwnerX(x, __FILE__, __LINE__)
#else
PoolPtr GetBuffer();
#ifdef FAST_BUFFERS
PoolPtr GetFastBuffer();
#else /* #ifdef FAST_BUFFERS */
#define GetFastBuffer() GetBuffer()
#endif /* #ifdef FAST_BUFFERS */
void FreeBuffer(PoolPtr nbuf);
#define ChangeOwner(x)
#endif
 
#ifdef BUFFER_DIAG_LOG
#include <syslog.h>
extern uint32_t bufLogID;
#define LOG_DEST AsciiToIp("10.1.1.3")
#define SET_LOG_DEST                  \
    {                                 \
        extern IPADDR SysLogAddress; \
        SysLogAddress = LOG_DEST;     \
    }
#define LOG_INTF 2
#define BuffLog_GetFmt "%0.8lu)  GET    - P: %p, L: %0.4d, F: %s\r\n"
#define BuffLog_FreeFmt "%0.8lu)  FREE   - P: %p, L: %0.4d, F: %s\r\n"
#define BuffLog_GetLF(p, l, f) SysLogVia(LOG_INTF, BuffLog_GetFmt, bufLogID++, p, l, f)
#define BuffLog_FreeLF(p, l, f) SysLogVia(LOG_INTF, BuffLog_FreeFmt, bufLogID++, p, l, f)
#define BuffLog_Get(p) BuffLog_GetLF(p, __LINE__, __FILE__)
#define BuffLog_Free(p) BuffLog_FreeLF(p, __LINE__, __FILE__)
#define BuffLog_Write(p) SysLogVia(LOG_INTF, "WRITE  - P: %p, L: %0.4d, F: %s\r\n", p, __LINE__, __FILE__)
#define BuffLog_Read(p) SysLogVia(LOG_INTF, "READ   - P: %p, L: %0.4d, F: %s\r\n", p, __LINE__, __FILE__)
#else
#define BuffLog_Get(p)
#define BuffLog_Free(p)
#define BuffLog_Write(p)
#define BuffLog_Read(p)
#endif
void FreeBufferList(PoolPtr nbuf);
 
void IncUsageCount(PoolPtr pp);
 
uint16_t GetFreeCount();
      
#ifdef BUFFER_WATERMARK 
uint16_t GetMinFreeCount();
 
uint16_t GetMaxFreeCount();
#endif
 
void InitBuffers();
 
void ShowBuffer(PoolPtr p);
 
class buffer_list
{
   public:
    PoolPtr m_Head;        
    PoolPtr m_Tail;        
#ifdef BUFFER_WATERMARK 
    uint16_t m_wMaxElements; 
    uint16_t m_wMinElements; 
#endif
    uint16_t m_wElements;  
    
    void InsertHead(PoolPtr buffer);
    
    void InsertTail(PoolPtr buffer);
    
    void InsertBefore(PoolPtr buf2insert, PoolPtr b4buffer);
    
    void InsertAfter(PoolPtr buf2insert, PoolPtr after_buffer);
    
    void Remove(PoolPtr buffer);
    
    PoolPtr RemoveHead();
    
    PoolPtr RemoveTail();
    
    buffer_list()
    {
        m_Head = 0;
        m_Tail = 0;
        m_wElements = 0;
#ifdef BUFFER_WATERMARK 
     m_wMaxElements=0;
     m_wMinElements=0;
#endif
 
    }
    
    uint16_t GetCount() { return m_wElements; };
#ifdef BUFFER_WATERMARK 
    uint16_t GetMaxCount() { return m_wMaxElements; };
    
    uint16_t GetMinCount() { return m_wMinElements; };
#endif
};
 
class fifo_buffer_storage
{
   private:
    PoolPtr m_Head;
    PoolPtr m_Tail;
    OS_CRIT m_critical_section;
    int m_BytesStored;
    uint32_t m_startOffset;
    uint32_t m_maxChunkLen;
    uint8_t m_Segments_Stored;
    uint8_t m_MaxSegments; /*Stores the max number of segments allowed fore this buffer*/
    bool m_checksumWrites;
    uint8_t m_buffer_pool;
 
    // storage access/update functions to be used by BufPtr.
    // DO NOT CALL WITHOUT LOCKING STRUCT FIRST
    uint8_t *GetWritePtr(uint32_t *remLen);
    void WriteDone(uint32_t bytesCopied);
 
    uint8_t *GetReadPtr(uint32_t *remLen);
    void ReadDone(uint32_t bytesCopied);
 
   public:
    class WriteBufPtr
    {
        WriteBufPtr();
        fifo_buffer_storage &m_fifo;
        uint8_t *pBuf;
        uint32_t bufLen;
        uint32_t copied;
 
       public:
        WriteBufPtr(fifo_buffer_storage &fifo) : m_fifo(fifo), copied(0)
        {
            m_fifo.m_critical_section.Enter();
            pBuf = m_fifo.GetWritePtr(&bufLen);
        }
        ~WriteBufPtr()
        {
            m_fifo.WriteDone(copied);
            m_fifo.m_critical_section.Leave();
        }
 
        inline uint8_t *buf() { return pBuf + copied; }
        inline uint32_t len() { return bufLen - copied; }
        void ByteCopyDone(uint32_t bytesCopied) { copied += (bytesCopied <= (bufLen - copied)) ? bytesCopied : (bufLen - copied); }
    };
    class ReadBufPtr
    {
        ReadBufPtr();
        fifo_buffer_storage &m_fifo;
        uint8_t *pBuf;
        uint32_t bufLen;
        uint32_t copied;
 
       public:
        ReadBufPtr(fifo_buffer_storage &fifo) : m_fifo(fifo), copied(0)
        {
            m_fifo.m_critical_section.Enter();
            pBuf = m_fifo.GetReadPtr(&bufLen);
        }
        ~ReadBufPtr()
        {
            m_fifo.ReadDone(copied);
            m_fifo.m_critical_section.Leave();
        }
 
        inline uint8_t *buf() { return pBuf + copied; }
        inline uint32_t len() { return bufLen - copied; }
        void ByteCopyDone(uint32_t bytesCopied) { copied += (bytesCopied <= (bufLen - copied)) ? bytesCopied : (bufLen - copied); }
    };
    class PeekIterator
    {
        PeekIterator();
        fifo_buffer_storage &m_fifo;
        PoolPtr pCurrPP;
        uint8_t *peekPtr;
        bool locked;
 
        PeekIterator(const PeekIterator &rhs)
            : m_fifo(rhs.m_fifo), pCurrPP(rhs.pCurrPP), peekPtr(rhs.peekPtr), locked(false)
        {
            if (pCurrPP)
            {
                m_fifo.m_critical_section.Enter();
                locked = true;
            }
        }
 
       public:
        PeekIterator(fifo_buffer_storage &fifo, bool begin = true) : m_fifo(fifo), pCurrPP(NULL), peekPtr(NULL), locked(false)
        {
            if (begin)
            {
                m_fifo.m_critical_section.Enter();
                locked = true;
                pCurrPP = m_fifo.m_Head;
                if (pCurrPP) { peekPtr = pCurrPP->pAsBytePtr; }
            }
        }
        ~PeekIterator() { if (locked) m_fifo.m_critical_section.Leave(); }
 
        PeekIterator &operator++();     // preincrement
        PeekIterator operator++(int);   // postincrement
        uint8_t operator*();            // dereference
        int32_t operator-(const PeekIterator &rhs);
        PeekIterator &operator+=(int);
 
        operator uint16_t() const;
        operator uint32_t() const;
 
        inline bool operator==(const PeekIterator &rhs)
        {
            return ((&m_fifo == &(rhs.m_fifo)) && (pCurrPP == rhs.pCurrPP) && (peekPtr == rhs.peekPtr));
        }
        bool operator!=(const PeekIterator &rhs) { return !(*this == rhs); }
    };
 
    friend class WriteBufPtr;
    friend class ReadBufPtr;
    friend class PeekIterator;
 
    uint32_t LongSpaceAvail();
 
    uint16_t SpaceAvail();
    
    uint16_t SpaceUsed();
 
    int ReadData(puint8_t pCopyTo, int max_bytes);
 
    uint8_t PeekData(int idx = -1);
 
    int ReadDatawSum(puint8_t pCopyTo, int max_bytes, uint32_t &csum);
 
    int SkipData(int skip);
 
    int ReadTerminatedData(puint8_t pCopyTo, int max_bytes, uint8_t term_char);
 
    /* Advanced functions for no-copy buffer usage */
    int PushBuffer(PoolPtr pp, int dataLen, int startOffset);
    PoolPtr PullBuffer();
    PoolPtr PullBuffer(uint32_t &csum);
    inline PoolPtr PeekBuffer() { return m_Head; }
    void SetFifoLock(bool locked);
 
    int WriteData(puint8_t pCopyFrom, int num_bytes);
 
    void RemoveLast();
 
    PeekIterator Peek_Begin();
    
    PeekIterator Peek_End();
 
    BOOL Empty();
 
    BOOL Full();
 
    fifo_buffer_storage(uint8_t max_buffers = 0, uint8_t use_fromisr = 1, uint8_t use_fast_buffs = 1);
    
    ~fifo_buffer_storage();
 
    void Reset(uint8_t max_buffers);
 
    void SetMaxBuffers(uint8_t max_buffers);
    inline void SetMaxChunkLen(uint32_t maxStorage)
    {
        m_maxChunkLen = (maxStorage > (ETHER_BUFFER_SIZE - m_startOffset)) ? (ETHER_BUFFER_SIZE - m_startOffset) : maxStorage;
    }
    inline void SetStartOffset(uint32_t offset)
    {
        m_startOffset = offset;
        SetMaxChunkLen(m_maxChunkLen);
    }
    inline uint32_t GetMaxBuffers()  { return m_MaxSegments; }
    inline uint32_t GetMaxChunkLen() { return m_maxChunkLen; }
    inline uint32_t GetStartOffset() { return m_startOffset; }
    inline void SetWriteChecksum(bool summingOn) { m_checksumWrites = summingOn; }
    inline uint32_t GetMinimumFullSize(int maxSegments = -1)
        {
            if (maxSegments < 0)
                maxSegments = m_MaxSegments;
            return (m_maxChunkLen * (maxSegments-1))+1;
        }
 
    void Init(uint8_t max_buffers, uint8_t use_fromisr = 1, uint8_t use_fast_buffs = 1);
} __attribute__((packed));
 
class SMPoolPtr
{
    PoolPtr m_pp;
 
   public:
    SMPoolPtr()
    {
        m_pp = GetBuffer();
        BuffLog_Get(m_pp);
    }
    
    SMPoolPtr(const PoolPtr pp) { m_pp = pp; }
    
    SMPoolPtr(const SMPoolPtr &pp) { m_pp = pp.m_pp; }
    
    ~SMPoolPtr()
    {
        if (m_pp)
        {
            FreeBuffer(m_pp);
            BuffLog_Free(m_pp);
        }
    }
 
    inline const SMPoolPtr &operator=(const PoolPtr pp)
    {
        m_pp = pp;
        return *this;
    }
    inline const SMPoolPtr &operator=(const SMPoolPtr &pp)
    {
        m_pp = pp.m_pp;
        return *this;
    }
    inline pool_buffer &operator*() { return *m_pp; }
    inline PoolPtr &operator->() { return m_pp; }
    explicit operator PoolPtr() { return m_pp; }
    inline bool operator!()         { return !m_pp; }
};
 
#endif