Line data    Source code

       1             : /*
       2             :  * Circular buffer implementation.
       3             :  * Copyright (C) 2017 Cumulus Networks
       4             :  * Quentin Young
       5             :  *
       6             :  * This program is free software; you can redistribute it and/or modify it
       7             :  * under the terms of the GNU General Public License as published by the Free
       8             :  * Software Foundation; either version 2 of the License, or (at your option)
       9             :  * any later version.
      10             :  *
      11             :  * This program is distributed in the hope that it will be useful, but WITHOUT
      12             :  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13             :  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
      14             :  * more details.
      15             :  *
      16             :  * You should have received a copy of the GNU General Public License along
      17             :  * with this program; see the file COPYING; if not, write to the Free Software
      18             :  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
      19             :  */
      20             : #include <zebra.h>
      21             : 
      22             : #include "ringbuf.h"
      23             : #include "memory.h"
      24             : 
      25          18 : DEFINE_MTYPE_STATIC(LIB, RINGBUFFER, "Ring buffer");
      26             : 
      27          10 : struct ringbuf *ringbuf_new(size_t size)
      28             : {
      29          10 :         struct ringbuf *buf = XCALLOC(MTYPE_RINGBUFFER, sizeof(struct ringbuf));
      30          10 :         buf->data = XCALLOC(MTYPE_RINGBUFFER, size);
      31          10 :         buf->size = size;
      32          10 :         buf->empty = true;
      33          10 :         return buf;
      34             : }
      35             : 
      36          10 : void ringbuf_del(struct ringbuf *buf)
      37             : {
      38          10 :         XFREE(MTYPE_RINGBUFFER, buf->data);
      39          10 :         XFREE(MTYPE_RINGBUFFER, buf);
      40          10 : }
      41             : 
      42         341 : size_t ringbuf_remain(struct ringbuf *buf)
      43             : {
      44         341 :         ssize_t diff = buf->end - buf->start;
      45         341 :         diff += ((diff == 0) && !buf->empty) ? buf->size : 0;
      46         341 :         diff += (diff < 0) ? buf->size : 0;
      47         341 :         return (size_t)diff;
      48             : }
      49             : 
      50          81 : size_t ringbuf_space(struct ringbuf *buf)
      51             : {
      52          81 :         return buf->size - ringbuf_remain(buf);
      53             : }
      54             : 
      55          27 : size_t ringbuf_put(struct ringbuf *buf, const void *data, size_t size)
      56             : {
      57          27 :         const uint8_t *dp = data;
      58          27 :         size_t space = ringbuf_space(buf);
      59          27 :         size_t copysize = MIN(size, space);
      60          27 :         size_t tocopy = copysize;
      61          27 :         if (tocopy >= buf->size - buf->end) {
      62           0 :                 size_t ts = buf->size - buf->end;
      63           0 :                 memcpy(buf->data + buf->end, dp, ts);
      64           0 :                 buf->end = 0;
      65           0 :                 tocopy -= ts;
      66           0 :                 dp += ts;
      67             :         }
      68          27 :         memcpy(buf->data + buf->end, dp, tocopy);
      69          27 :         buf->end += tocopy;
      70          27 :         buf->empty = (buf->start == buf->end) && (buf->empty && !copysize);
      71          27 :         return copysize;
      72             : }
      73             : 
      74          33 : size_t ringbuf_get(struct ringbuf *buf, void *data, size_t size)
      75             : {
      76          33 :         uint8_t *dp = data;
      77          33 :         size_t remain = ringbuf_remain(buf);
      78          33 :         size_t copysize = MIN(remain, size);
      79          33 :         size_t tocopy = copysize;
      80          33 :         if (tocopy >= buf->size - buf->start) {
      81           0 :                 size_t ts = buf->size - buf->start;
      82           0 :                 memcpy(dp, buf->data + buf->start, ts);
      83           0 :                 buf->start = 0;
      84           0 :                 tocopy -= ts;
      85           0 :                 dp += ts;
      86             :         }
      87          33 :         memcpy(dp, buf->data + buf->start, tocopy);
      88          33 :         buf->start = buf->start + tocopy;
      89          33 :         buf->empty = (buf->start == buf->end) && (buf->empty || copysize);
      90          33 :         return copysize;
      91             : }
      92             : 
      93         134 : size_t ringbuf_peek(struct ringbuf *buf, size_t offset, void *data, size_t size)
      94             : {
      95         134 :         uint8_t *dp = data;
      96         134 :         size_t remain = ringbuf_remain(buf);
      97         134 :         if (offset >= remain)
      98             :                 return 0;
      99         132 :         size_t copysize = MAX(MIN(remain - offset, size), (size_t)0);
     100         132 :         size_t tocopy = copysize;
     101         132 :         size_t cstart = (buf->start + offset) % buf->size;
     102         132 :         if (tocopy >= buf->size - cstart) {
     103           0 :                 size_t ts = buf->size - cstart;
     104           0 :                 memcpy(dp, buf->data + cstart, ts);
     105           0 :                 cstart = 0;
     106           0 :                 tocopy -= ts;
     107           0 :                 dp += ts;
     108             :         }
     109         132 :         memcpy(dp, buf->data + cstart, tocopy);
     110         132 :         return copysize;
     111             : }
     112             : 
     113           2 : size_t ringbuf_copy(struct ringbuf *to, struct ringbuf *from, size_t size)
     114             : {
     115           2 :         size_t tocopy = MIN(ringbuf_space(to), size);
     116           2 :         uint8_t *cbuf = XCALLOC(MTYPE_TMP, tocopy);
     117           2 :         tocopy = ringbuf_peek(from, 0, cbuf, tocopy);
     118           2 :         size_t put = ringbuf_put(to, cbuf, tocopy);
     119           2 :         XFREE(MTYPE_TMP, cbuf);
     120           2 :         return put;
     121             : }
     122             : 
     123          23 : void ringbuf_reset(struct ringbuf *buf)
     124             : {
     125          23 :         buf->start = buf->end = 0;
     126          23 :         buf->empty = true;
     127          23 : }
     128             : 
     129          23 : void ringbuf_wipe(struct ringbuf *buf)
     130             : {
     131          23 :         memset(buf->data, 0x00, buf->size);
     132          23 :         ringbuf_reset(buf);
     133          23 : }