rnglib.c

环行buffer的实现以及操作函数,主要包括环行buffer的内存申请,释放,读取数据和写入数据,还有返回该buffer的一些属性参数

#include "rngLib.h"

typedef struct 
{
	int 	pToBuf;
	int 	pFromBuf;
	int 	bufSize;
	char    *buf;
}RING;
typedef RING *RING_ID;

/
RING_ID rngCreate
    (
    int nbytes          /* number of bytes in ring buffer */
    )
    {
    char *buffer;
    RING_ID ringId = (RING_ID) kmalloc (sizeof (RING),GFP_KERNEL);

    if (ringId == NULL)
	return (NULL);

    /* bump number of bytes requested because ring buffer algorithm
     * always leaves at least one empty byte in buffer */

    buffer = (char *) kmalloc ((unsigned) ++nbytes,GFP_KERNEL);

    if (buffer == NULL)
	{
	kfree ((char *)ringId);
	return (NULL);
	}

    ringId->bufSize = nbytes;
    ringId->buf	    = buffer;

    rngFlush (ringId);

    return (ringId);
    }


void rngDelete
    (
     RING_ID ringId         /* ring buffer to delete */
    )
    {
    kfree (ringId->buf);
    kfree ((char *)ringId);
    }


void rngFlush
    (
     RING_ID ringId         /* ring buffer to initialize */
    )
    {
    ringId->pToBuf   = 0;
    ringId->pFromBuf = 0;
    }


int rngBufGet
    (
     RING_ID rngId,         /* ring buffer to get data from      */
    char *buffer,               /* pointer to buffer to receive data */
    int maxbytes                /* maximum number of bytes to get    */
    )
    {
     int bytesgot = 0;
    int pToBuf = rngId->pToBuf;
    int bytes2;
    int pRngTmp = 0;

    if (pToBuf >= rngId->pFromBuf)
	{
	/* pToBuf has not wrapped around */

	bytesgot = min (maxbytes, pToBuf - rngId->pFromBuf);
	/*bcopy (&rngId->buf [rngId->pFromBuf], buffer, bytesgot);*/
	memcpy(buffer,&rngId->buf [rngId->pFromBuf],bytesgot);
	rngId->pFromBuf += bytesgot;
	}
    else
	{
	/* pToBuf has wrapped around.  Grab chars up to the end of the
	 * buffer, then wrap around if we need to. */

	bytesgot = min (maxbytes, rngId->bufSize - rngId->pFromBuf);
	/*bcopy (&rngId->buf [rngId->pFromBuf], buffer, bytesgot);*/
	memcpy(buffer,&rngId->buf [rngId->pFromBuf],bytesgot);
	pRngTmp = rngId->pFromBuf + bytesgot;

	/* If pFromBuf is equal to bufSize, we've read the entire buffer,
	 * and need to wrap now.  If bytesgot < maxbytes, copy some more chars
	 * in now. */

	if (pRngTmp == rngId->bufSize)
	    {
	    bytes2 = min (maxbytes - bytesgot, pToBuf);
	    /*bcopy (rngId->buf, buffer + bytesgot, bytes2);*/
	    memcpy(buffer + bytesgot,rngId->buf,bytes2);
	    rngId->pFromBuf = bytes2;
	    bytesgot += bytes2;
	    }
	else
	    rngId->pFromBuf = pRngTmp;
	}
    return (bytesgot);
    }


int rngBufPut
    (
     RING_ID rngId,         /* ring buffer to put data into  */
    char *buffer,               /* buffer to get data from       */
    int nbytes                  /* number of bytes to try to put */
    )
    {
    	
    int bytesput = 0;
    int pFromBuf = rngId->pFromBuf;
    int bytes2;
    int pRngTmp = 0;
//printk("3\n");
    if (pFromBuf > rngId->pToBuf)
	{
	/* pFromBuf is ahead of pToBuf.  We can fill up to two bytes
	 * before it */
	
	bytesput = min (nbytes, pFromBuf - rngId->pToBuf - 1);
	/*bcopy (buffer, &rngId->buf [rngId->pToBuf], bytesput);*/
	memcpy(&rngId->buf [rngId->pToBuf],buffer,bytesput);
	rngId->pToBuf += bytesput;
	}
    else if (pFromBuf == 0)
	{
	/* pFromBuf is at the beginning of the buffer.  We can fill till
	 * the next-to-last element */

	bytesput = min (nbytes, rngId->bufSize - rngId->pToBuf - 1);
	/*bcopy (buffer, &rngId->buf [rngId->pToBuf], bytesput);*/
	memcpy(&rngId->buf[rngId->pToBuf],buffer,bytesput);
	rngId->pToBuf += bytesput;
	}
    else
	{
	/* pFromBuf has wrapped around, and its not 0, so we can fill
	 * at least to the end of the ring buffer.  Do so, then see if
	 * we need to wrap and put more at the beginning of the buffer. */

	bytesput = min (nbytes, rngId->bufSize - rngId->pToBuf);
	/*bcopy (buffer, &rngId->buf [rngId->pToBuf], bytesput);*/
	memcpy(&rngId->buf [rngId->pToBuf],buffer,bytesput);
	pRngTmp = rngId->pToBuf + bytesput;

	if (pRngTmp == rngId->bufSize)
	    {
	    /* We need to wrap, and perhaps put some more chars */

	    bytes2 = min (nbytes - bytesput, pFromBuf - 1);
	    /*bcopy (buffer + bytesput, rngId->buf, bytes2);*/
	    memcpy(rngId->buf,buffer + bytesput,bytes2);
	    rngId->pToBuf = bytes2;
	    bytesput += bytes2;
	    }
	else
	    rngId->pToBuf = pRngTmp;
	}
	//printk("4\n");
    return (bytesput);
    }


int rngIsEmpty
    (
    RING_ID ringId      /* ring buffer to test */
    )
    {
    	if (ringId->pToBuf == ringId->pFromBuf)
    		return 1;
    	else
    		return 0;    	
    }


int rngIsFull
    (
     RING_ID ringId         /* ring buffer to test */
    )
    {
    int n = ringId->pToBuf - ringId->pFromBuf + 1;
	if ((n == 0) || (n == ringId->bufSize))
		return 0;
	else
		return -1;
    }


int rngFreeBytes
    (
     RING_ID ringId         /* ring buffer to examine */
    )
    {
     int n = ringId->pFromBuf - ringId->pToBuf - 1;

    if (n < 0)
	n += ringId->bufSize;

    return (n);
    }


int rngNBytes
    (
     RING_ID ringId         /* ring buffer to be enumerated */
    )
    {
     int n = ringId->pToBuf - ringId->pFromBuf;

    if (n < 0)
	n += ringId->bufSize;

    return (n);
    }


void rngPutAhead
    (
     RING_ID ringId,   /* ring buffer to put byte in    */
    char byte,             /* byte to be put in ring        */
    int offset             /* offset beyond next input byte where to put byte */
    )
    {
     int n = ringId->pToBuf + offset;

    if (n >= ringId->bufSize)
	n -= ringId->bufSize;

    *(ringId->buf + n) = byte;
    }

void rngMoveAhead
    (
     RING_ID ringId,  /* ring buffer to be advanced                  */
     int n            /* number of bytes ahead to move input pointer */
    )
    {
    n += ringId->pToBuf;

    if (n >= ringId->bufSize)
	n -= ringId->bufSize;

    ringId->pToBuf = n;
    }