ceph/src/spdk/dpdk/lib/librte_cmdline/cmdline_cirbuf.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation.
   3  * Copyright (c) 2009, Olivier MATZ <zer0@droids-corp.org>
   4  * All rights reserved.
   5  */
   6
   7 #include <string.h>
   8 #include <errno.h>
   9 #include <stdio.h>
  10
  11 #include "cmdline_cirbuf.h"
  12
  13
  14 int
  15 cirbuf_init(struct cirbuf *cbuf, char *buf, unsigned int start, unsigned int maxlen)
  16 {
  17         if (!cbuf || !buf)
  18                 return -EINVAL;
  19         cbuf->maxlen = maxlen;
  20         cbuf->len = 0;
  21         cbuf->start = start;
  22         cbuf->end = start;
  23         cbuf->buf = buf;
  24         return 0;
  25 }
  26
  27 /* multiple add */
  28
  29 int
  30 cirbuf_add_buf_head(struct cirbuf *cbuf, const char *c, unsigned int n)
  31 {
  32         unsigned int e;
  33
  34         if (!cbuf || !c || !n || n > CIRBUF_GET_FREELEN(cbuf))
  35                 return -EINVAL;
  36
  37         e = CIRBUF_IS_EMPTY(cbuf) ? 1 : 0;
  38
  39         if (n < cbuf->start + e) {
  40                 dprintf("s[%d] -> d[%d] (%d)\n", 0, cbuf->start - n + e, n);
  41                 memcpy(cbuf->buf + cbuf->start - n + e, c, n);
  42         }
  43         else {
  44                 dprintf("s[%d] -> d[%d] (%d)\n", + n - (cbuf->start + e), 0,
  45                         cbuf->start + e);
  46                 dprintf("s[%d] -> d[%d] (%d)\n", cbuf->maxlen - n +
  47                         (cbuf->start + e), 0, n - (cbuf->start + e));
  48                 memcpy(cbuf->buf, c  + n - (cbuf->start + e) , cbuf->start + e);
  49                 memcpy(cbuf->buf + cbuf->maxlen - n + (cbuf->start + e), c,
  50                        n - (cbuf->start + e));
  51         }
  52         cbuf->len += n;
  53         cbuf->start += (cbuf->maxlen - n + e);
  54         cbuf->start %= cbuf->maxlen;
  55         return n;
  56 }
  57
  58 /* multiple add */
  59
  60 int
  61 cirbuf_add_buf_tail(struct cirbuf *cbuf, const char *c, unsigned int n)
  62 {
  63         unsigned int e;
  64
  65         if (!cbuf || !c || !n || n > CIRBUF_GET_FREELEN(cbuf))
  66                 return -EINVAL;
  67
  68         e = CIRBUF_IS_EMPTY(cbuf) ? 1 : 0;
  69
  70         if (n < cbuf->maxlen - cbuf->end - 1 + e) {
  71                 dprintf("s[%d] -> d[%d] (%d)\n", 0, cbuf->end + !e, n);
  72                 memcpy(cbuf->buf + cbuf->end + !e, c, n);
  73         }
  74         else {
  75                 dprintf("s[%d] -> d[%d] (%d)\n", cbuf->end + !e, 0,
  76                         cbuf->maxlen - cbuf->end - 1 + e);
  77                 dprintf("s[%d] -> d[%d] (%d)\n", cbuf->maxlen - cbuf->end - 1 +
  78                         e, 0, n - cbuf->maxlen + cbuf->end + 1 - e);
  79                 memcpy(cbuf->buf + cbuf->end + !e, c, cbuf->maxlen -
  80                        cbuf->end - 1 + e);
  81                 memcpy(cbuf->buf, c + cbuf->maxlen - cbuf->end - 1 + e,
  82                        n - cbuf->maxlen + cbuf->end + 1 - e);
  83         }
  84         cbuf->len += n;
  85         cbuf->end += n - e;
  86         cbuf->end %= cbuf->maxlen;
  87         return n;
  88 }
  89
  90 /* add at head */
  91
  92 static inline void
  93 __cirbuf_add_head(struct cirbuf * cbuf, char c)
  94 {
  95         if (!CIRBUF_IS_EMPTY(cbuf)) {
  96                 cbuf->start += (cbuf->maxlen - 1);
  97                 cbuf->start %= cbuf->maxlen;
  98         }
  99         cbuf->buf[cbuf->start] = c;
 100         cbuf->len ++;
 101 }
 102
 103 int
 104 cirbuf_add_head_safe(struct cirbuf * cbuf, char c)
 105 {
 106         if (cbuf && !CIRBUF_IS_FULL(cbuf)) {
 107                 __cirbuf_add_head(cbuf, c);
 108                 return 0;
 109         }
 110         return -EINVAL;
 111 }
 112
 113 void
 114 cirbuf_add_head(struct cirbuf * cbuf, char c)
 115 {
 116         __cirbuf_add_head(cbuf, c);
 117 }
 118
 119 /* add at tail */
 120
 121 static inline void
 122 __cirbuf_add_tail(struct cirbuf * cbuf, char c)
 123 {
 124         if (!CIRBUF_IS_EMPTY(cbuf)) {
 125                 cbuf->end ++;
 126                 cbuf->end %= cbuf->maxlen;
 127         }
 128         cbuf->buf[cbuf->end] = c;
 129         cbuf->len ++;
 130 }
 131
 132 int
 133 cirbuf_add_tail_safe(struct cirbuf * cbuf, char c)
 134 {
 135         if (cbuf && !CIRBUF_IS_FULL(cbuf)) {
 136                 __cirbuf_add_tail(cbuf, c);
 137                 return 0;
 138         }
 139         return -EINVAL;
 140 }
 141
 142 void
 143 cirbuf_add_tail(struct cirbuf * cbuf, char c)
 144 {
 145         __cirbuf_add_tail(cbuf, c);
 146 }
 147
 148
 149 static inline void
 150 __cirbuf_shift_left(struct cirbuf *cbuf)
 151 {
 152         unsigned int i;
 153         char tmp = cbuf->buf[cbuf->start];
 154
 155         for (i=0 ; i<cbuf->len ; i++) {
 156                 cbuf->buf[(cbuf->start+i)%cbuf->maxlen] =
 157                         cbuf->buf[(cbuf->start+i+1)%cbuf->maxlen];
 158         }
 159         cbuf->buf[(cbuf->start-1+cbuf->maxlen)%cbuf->maxlen] = tmp;
 160         cbuf->start += (cbuf->maxlen - 1);
 161         cbuf->start %= cbuf->maxlen;
 162         cbuf->end += (cbuf->maxlen - 1);
 163         cbuf->end %= cbuf->maxlen;
 164 }
 165
 166 static inline void
 167 __cirbuf_shift_right(struct cirbuf *cbuf)
 168 {
 169         unsigned int i;
 170         char tmp = cbuf->buf[cbuf->end];
 171
 172         for (i=0 ; i<cbuf->len ; i++) {
 173                 cbuf->buf[(cbuf->end+cbuf->maxlen-i)%cbuf->maxlen] =
 174                         cbuf->buf[(cbuf->end+cbuf->maxlen-i-1)%cbuf->maxlen];
 175         }
 176         cbuf->buf[(cbuf->end+1)%cbuf->maxlen] = tmp;
 177         cbuf->start += 1;
 178         cbuf->start %= cbuf->maxlen;
 179         cbuf->end += 1;
 180         cbuf->end %= cbuf->maxlen;
 181 }
 182
 183 /* XXX we could do a better algorithm here... */
 184 int
 185 cirbuf_align_left(struct cirbuf * cbuf)
 186 {
 187         if (!cbuf)
 188                 return -EINVAL;
 189
 190         if (cbuf->start < cbuf->maxlen/2) {
 191                 while (cbuf->start != 0) {
 192                         __cirbuf_shift_left(cbuf);
 193                 }
 194         }
 195         else {
 196                 while (cbuf->start != 0) {
 197                         __cirbuf_shift_right(cbuf);
 198                 }
 199         }
 200
 201         return 0;
 202 }
 203
 204 /* XXX we could do a better algorithm here... */
 205 int
 206 cirbuf_align_right(struct cirbuf * cbuf)
 207 {
 208         if (!cbuf)
 209                 return -EINVAL;
 210
 211         if (cbuf->start >= cbuf->maxlen/2) {
 212                 while (cbuf->end != cbuf->maxlen-1) {
 213                         __cirbuf_shift_left(cbuf);
 214                 }
 215         }
 216         else {
 217                 while (cbuf->start != cbuf->maxlen-1) {
 218                         __cirbuf_shift_right(cbuf);
 219                 }
 220         }
 221
 222         return 0;
 223 }
 224
 225 /* buffer del */
 226
 227 int
 228 cirbuf_del_buf_head(struct cirbuf *cbuf, unsigned int size)
 229 {
 230         if (!cbuf || !size || size > CIRBUF_GET_LEN(cbuf))
 231                 return -EINVAL;
 232
 233         cbuf->len -= size;
 234         if (CIRBUF_IS_EMPTY(cbuf)) {
 235                 cbuf->start += size - 1;
 236                 cbuf->start %= cbuf->maxlen;
 237         }
 238         else {
 239                 cbuf->start += size;
 240                 cbuf->start %= cbuf->maxlen;
 241         }
 242         return 0;
 243 }
 244
 245 /* buffer del */
 246
 247 int
 248 cirbuf_del_buf_tail(struct cirbuf *cbuf, unsigned int size)
 249 {
 250         if (!cbuf || !size || size > CIRBUF_GET_LEN(cbuf))
 251                 return -EINVAL;
 252
 253         cbuf->len -= size;
 254         if (CIRBUF_IS_EMPTY(cbuf)) {
 255                 cbuf->end  += (cbuf->maxlen - size + 1);
 256                 cbuf->end %= cbuf->maxlen;
 257         }
 258         else {
 259                 cbuf->end  += (cbuf->maxlen - size);
 260                 cbuf->end %= cbuf->maxlen;
 261         }
 262         return 0;
 263 }
 264
 265 /* del at head */
 266
 267 static inline void
 268 __cirbuf_del_head(struct cirbuf * cbuf)
 269 {
 270         cbuf->len --;
 271         if (!CIRBUF_IS_EMPTY(cbuf)) {
 272                 cbuf->start ++;
 273                 cbuf->start %= cbuf->maxlen;
 274         }
 275 }
 276
 277 int
 278 cirbuf_del_head_safe(struct cirbuf * cbuf)
 279 {
 280         if (cbuf && !CIRBUF_IS_EMPTY(cbuf)) {
 281                 __cirbuf_del_head(cbuf);
 282                 return 0;
 283         }
 284         return -EINVAL;
 285 }
 286
 287 void
 288 cirbuf_del_head(struct cirbuf * cbuf)
 289 {
 290         __cirbuf_del_head(cbuf);
 291 }
 292
 293 /* del at tail */
 294
 295 static inline void
 296 __cirbuf_del_tail(struct cirbuf * cbuf)
 297 {
 298         cbuf->len --;
 299         if (!CIRBUF_IS_EMPTY(cbuf)) {
 300                 cbuf->end  += (cbuf->maxlen - 1);
 301                 cbuf->end %= cbuf->maxlen;
 302         }
 303 }
 304
 305 int
 306 cirbuf_del_tail_safe(struct cirbuf * cbuf)
 307 {
 308         if (cbuf && !CIRBUF_IS_EMPTY(cbuf)) {
 309                 __cirbuf_del_tail(cbuf);
 310                 return 0;
 311         }
 312         return -EINVAL;
 313 }
 314
 315 void
 316 cirbuf_del_tail(struct cirbuf * cbuf)
 317 {
 318         __cirbuf_del_tail(cbuf);
 319 }
 320
 321 /* convert to buffer */
 322
 323 int
 324 cirbuf_get_buf_head(struct cirbuf *cbuf, char *c, unsigned int size)
 325 {
 326         unsigned int n;
 327
 328         if (!cbuf || !c)
 329                 return -EINVAL;
 330
 331         n = (size < CIRBUF_GET_LEN(cbuf)) ? size : CIRBUF_GET_LEN(cbuf);
 332
 333         if (!n)
 334                 return 0;
 335
 336         if (cbuf->start <= cbuf->end) {
 337                 dprintf("s[%d] -> d[%d] (%d)\n", cbuf->start, 0, n);
 338                 memcpy(c, cbuf->buf + cbuf->start , n);
 339         }
 340         else {
 341                 /* check if we need to go from end to the beginning */
 342                 if (n <= cbuf->maxlen - cbuf->start) {
 343                         dprintf("s[%d] -> d[%d] (%d)\n", 0, cbuf->start, n);
 344                         memcpy(c, cbuf->buf + cbuf->start , n);
 345                 }
 346                 else {
 347                         dprintf("s[%d] -> d[%d] (%d)\n", cbuf->start, 0,
 348                                 cbuf->maxlen - cbuf->start);
 349                         dprintf("s[%d] -> d[%d] (%d)\n", 0, cbuf->maxlen - cbuf->start,
 350                                 n - cbuf->maxlen + cbuf->start);
 351                         memcpy(c, cbuf->buf + cbuf->start , cbuf->maxlen - cbuf->start);
 352                         memcpy(c + cbuf->maxlen - cbuf->start, cbuf->buf,
 353                                    n - cbuf->maxlen + cbuf->start);
 354                 }
 355         }
 356         return n;
 357 }
 358
 359 /* convert to buffer */
 360
 361 int
 362 cirbuf_get_buf_tail(struct cirbuf *cbuf, char *c, unsigned int size)
 363 {
 364         unsigned int n;
 365
 366         if (!cbuf || !c)
 367                 return -EINVAL;
 368
 369         n = (size < CIRBUF_GET_LEN(cbuf)) ? size : CIRBUF_GET_LEN(cbuf);
 370
 371         if (!n)
 372                 return 0;
 373
 374         if (cbuf->start <= cbuf->end) {
 375                 dprintf("s[%d] -> d[%d] (%d)\n", cbuf->end - n + 1, 0, n);
 376                 memcpy(c, cbuf->buf + cbuf->end - n + 1, n);
 377         }
 378         else {
 379                 /* check if we need to go from end to the beginning */
 380                 if (n <= cbuf->end + 1) {
 381                         dprintf("s[%d] -> d[%d] (%d)\n", 0, cbuf->end - n + 1, n);
 382                         memcpy(c, cbuf->buf + cbuf->end - n + 1, n);
 383                 }
 384                 else {
 385                         dprintf("s[%d] -> d[%d] (%d)\n", 0,
 386                                 cbuf->maxlen - cbuf->start, cbuf->end + 1);
 387                         dprintf("s[%d] -> d[%d] (%d)\n",
 388                                 cbuf->maxlen - n + cbuf->end + 1, 0, n - cbuf->end - 1);
 389                         memcpy(c + cbuf->maxlen - cbuf->start,
 390                                                cbuf->buf, cbuf->end + 1);
 391                         memcpy(c, cbuf->buf + cbuf->maxlen - n + cbuf->end +1,
 392                                    n - cbuf->end - 1);
 393                 }
 394         }
 395         return n;
 396 }
 397
 398 /* get head or get tail */
 399
 400 char
 401 cirbuf_get_head(struct cirbuf * cbuf)
 402 {
 403         return cbuf->buf[cbuf->start];
 404 }
 405
 406 /* get head or get tail */
 407
 408 char
 409 cirbuf_get_tail(struct cirbuf * cbuf)
 410 {
 411         return cbuf->buf[cbuf->end];
 412 }