vppinfra: add vec_foreach_pointer macro

[vpp.git] / src / vppinfra / serialize.c

diff --git a/src/vppinfra/serialize.c b/src/vppinfra/serialize.c
index fe2146a..ceda617 100644 (file)
--- a/src/vppinfra/serialize.c
+++ b/src/vppinfra/serialize.c
@@ -160,7 +160,7 @@ unserialize_f32 (serialize_main_t * m, va_list * va)
   *x = y.f;
 }
 
-void
+__clib_export void
 serialize_cstring (serialize_main_t * m, char *s)
 {
   u32 len = s ? strlen (s) : 0;
@@ -170,11 +170,11 @@ serialize_cstring (serialize_main_t * m, char *s)
   if (len > 0)
     {
       p = serialize_get (m, len);
-      clib_memcpy (p, s, len);
+      clib_memcpy_fast (p, s, len);
     }
 }
 
-void
+__clib_export void
 unserialize_cstring (serialize_main_t * m, char **s)
 {
   char *p, *r = 0;
@@ -191,7 +191,7 @@ unserialize_cstring (serialize_main_t * m, char **s)
     {
       r = vec_new (char, len + 1);
       p = unserialize_get (m, len);
-      clib_memcpy (r, p, len);
+      clib_memcpy_fast (r, p, len);
 
       /* Null terminate. */
       r[len] = 0;
@@ -206,7 +206,7 @@ serialize_vec_8 (serialize_main_t * m, va_list * va)
   u8 *s = va_arg (*va, u8 *);
   u32 n = va_arg (*va, u32);
   u8 *p = serialize_get (m, n * sizeof (u8));
-  clib_memcpy (p, s, n * sizeof (u8));
+  clib_memcpy_fast (p, s, n * sizeof (u8));
 }
 
 void
@@ -215,7 +215,7 @@ unserialize_vec_8 (serialize_main_t * m, va_list * va)
   u8 *s = va_arg (*va, u8 *);
   u32 n = va_arg (*va, u32);
   u8 *p = unserialize_get (m, n);
-  clib_memcpy (s, p, n);
+  clib_memcpy_fast (s, p, n);
 }
 
 #define _(n_bits)                                                      \
@@ -279,7 +279,7 @@ _(64);
 
 #define SERIALIZE_VECTOR_CHUNK_SIZE 64
 
-void
+__clib_export void
 serialize_vector (serialize_main_t * m, va_list * va)
 {
   void *vec = va_arg (*va, void *);
@@ -308,13 +308,16 @@ unserialize_vector_ha (serialize_main_t * m,
 {
   void *v, *p;
   u32 l;
+  vec_attr_t va = { .align = align,
+                   .elt_sz = elt_bytes,
+                   .hdr_sz = header_bytes };
 
   unserialize_integer (m, &l, sizeof (l));
   if (l > max_length)
     serialize_error (&m->header,
                     clib_error_create ("bad vector length %d", l));
-  p = v = _vec_resize (0, l, (uword) l * elt_bytes, header_bytes,
-                      /* align */ align);
+
+  p = v = _vec_alloc_internal (l, &va);
 
   while (l != 0)
     {
@@ -341,7 +344,7 @@ unserialize_aligned_vector (serialize_main_t * m, va_list * va)
                                f);
 }
 
-void
+__clib_export void
 unserialize_vector (serialize_main_t * m, va_list * va)
 {
   void **vec = va_arg (*va, void **);
@@ -437,6 +440,9 @@ unserialize_pool_helper (serialize_main_t * m,
   void *v;
   u32 i, l, lo, hi;
   pool_header_t *p;
+  vec_attr_t va = { .align = align,
+                   .elt_sz = elt_bytes,
+                   .hdr_sz = sizeof (pool_header_t) };
 
   unserialize_integer (m, &l, sizeof (l));
   if (l == 0)
@@ -444,7 +450,7 @@ unserialize_pool_helper (serialize_main_t * m,
       return 0;
     }
 
-  v = _vec_resize (0, l, (uword) l * elt_bytes, sizeof (p[0]), align);
+  v = _vec_alloc_internal (l, &va);
   p = pool_header (v);
 
   vec_unserialize (m, &p->free_indices, unserialize_vec_32);
@@ -571,7 +577,7 @@ unserialize_heap (serialize_main_t * m, va_list * va)
       return;
     }
 
-  memset (&h, 0, sizeof (h));
+  clib_memset (&h, 0, sizeof (h));
 #define _(f) unserialize_integer (m, &h.f, sizeof (h.f));
   foreach_serialize_heap_header_integer;
 #undef _
@@ -626,7 +632,7 @@ serialize_magic (serialize_main_t * m, void *magic, u32 magic_bytes)
   void *p;
   serialize_integer (m, magic_bytes, sizeof (magic_bytes));
   p = serialize_get (m, magic_bytes);
-  clib_memcpy (p, magic, magic_bytes);
+  clib_memcpy_fast (p, magic, magic_bytes);
 }
 
 void
@@ -646,7 +652,7 @@ unserialize_check_magic (serialize_main_t * m, void *magic, u32 magic_bytes)
     goto bad;
 }
 
-clib_error_t *
+__clib_export clib_error_t *
 va_serialize (serialize_main_t * sm, va_list * va)
 {
   serialize_main_header_t *m = &sm->header;
@@ -667,7 +673,7 @@ va_serialize (serialize_main_t * sm, va_list * va)
   return error;
 }
 
-clib_error_t *
+__clib_export clib_error_t *
 serialize (serialize_main_t * m, ...)
 {
   clib_error_t *error;
@@ -679,7 +685,7 @@ serialize (serialize_main_t * m, ...)
   return error;
 }
 
-clib_error_t *
+__clib_export clib_error_t *
 unserialize (serialize_main_t * m, ...)
 {
   clib_error_t *error;
@@ -709,12 +715,12 @@ serialize_write_not_inline (serialize_main_header_t * m,
       if (n_left_o > 0 && n_left_b > 0)
        {
          uword n = clib_min (n_left_b, n_left_o);
-         clib_memcpy (s->buffer + cur_bi, s->overflow_buffer, n);
+         clib_memcpy_fast (s->buffer + cur_bi, s->overflow_buffer, n);
          cur_bi += n;
          n_left_b -= n;
          n_left_o -= n;
          if (n_left_o == 0)
-           _vec_len (s->overflow_buffer) = 0;
+           vec_set_len (s->overflow_buffer, 0);
          else
            vec_delete (s->overflow_buffer, n, 0);
        }
@@ -735,6 +741,7 @@ serialize_write_not_inline (serialize_main_header_t * m,
   if (n_left_o > 0 || n_left_b < n_bytes_to_write)
     {
       u8 *r;
+      s->current_buffer_index = cur_bi;
       vec_add2 (s->overflow_buffer, r, n_bytes_to_write);
       return r;
     }
@@ -771,7 +778,7 @@ serialize_read_not_inline (serialize_main_header_t * m,
   if (n_left_o == 0 && s->overflow_buffer)
     {
       s->current_overflow_index = 0;
-      _vec_len (s->overflow_buffer) = 0;
+      vec_set_len (s->overflow_buffer, 0);
     }
 
   n_left_to_read = n_bytes_to_read;
@@ -837,7 +844,7 @@ serialize_read_not_inline (serialize_main_header_t * m,
   return vec_elt_at_index (s->overflow_buffer, cur_oi);
 }
 
-void *
+__clib_export void *
 serialize_read_write_not_inline (serialize_main_header_t * m,
                                 serialize_stream_t * s,
                                 uword n_bytes, uword flags)
@@ -865,28 +872,28 @@ serialize_read_write_close (serialize_main_header_t * m,
   vec_free (s->overflow_buffer);
 }
 
-void
+__clib_export void
 serialize_close (serialize_main_t * m)
 {
   serialize_read_write_close (&m->header, &m->stream,
                              SERIALIZE_FLAG_IS_WRITE);
 }
 
-void
+__clib_export void
 unserialize_close (serialize_main_t * m)
 {
   serialize_read_write_close (&m->header, &m->stream, SERIALIZE_FLAG_IS_READ);
 }
 
-void
+__clib_export void
 serialize_open_data (serialize_main_t * m, u8 * data, uword n_data_bytes)
 {
-  memset (m, 0, sizeof (m[0]));
+  clib_memset (m, 0, sizeof (m[0]));
   m->stream.buffer = data;
   m->stream.n_buffer_bytes = n_data_bytes;
 }
 
-void
+__clib_export void
 unserialize_open_data (serialize_main_t * m, u8 * data, uword n_data_bytes)
 {
   serialize_open_data (m, data, n_data_bytes);
@@ -904,17 +911,17 @@ serialize_vector_write (serialize_main_header_t * m, serialize_stream_t * s)
     }
 }
 
-void
+__clib_export void
 serialize_open_vector (serialize_main_t * m, u8 * vector)
 {
-  memset (m, 0, sizeof (m[0]));
+  clib_memset (m, 0, sizeof (m[0]));
   m->header.data_function = serialize_vector_write;
   m->stream.buffer = vector;
   m->stream.current_buffer_index = 0;
   m->stream.n_buffer_bytes = vec_len (vector);
 }
 
-void *
+__clib_export void *
 serialize_close_vector (serialize_main_t * m)
 {
   serialize_stream_t *s = &m->stream;
@@ -923,15 +930,15 @@ serialize_close_vector (serialize_main_t * m)
   serialize_close (m);         /* frees overflow buffer */
 
   if (s->buffer)
-    _vec_len (s->buffer) = s->current_buffer_index;
+    vec_set_len (s->buffer, s->current_buffer_index);
   result = s->buffer;
-  memset (m, 0, sizeof (m[0]));
+  clib_memset (m, 0, sizeof (m[0]));
   return result;
 }
 
-void
-serialize_multiple_1 (serialize_main_t * m,
-                     void *data, uword data_stride, uword n_data)
+__clib_export void
+serialize_multiple_1 (serialize_main_t *m, void *data, uword data_stride,
+                     uword n_data)
 {
   u8 *d = data;
   u8 *p;
@@ -961,9 +968,9 @@ serialize_multiple_1 (serialize_main_t * m,
     }
 }
 
-void
-serialize_multiple_2 (serialize_main_t * m,
-                     void *data, uword data_stride, uword n_data)
+__clib_export void
+serialize_multiple_2 (serialize_main_t *m, void *data, uword data_stride,
+                     uword n_data)
 {
   void *d = data;
   u16 *p;
@@ -998,9 +1005,9 @@ serialize_multiple_2 (serialize_main_t * m,
     }
 }
 
-void
-serialize_multiple_4 (serialize_main_t * m,
-                     void *data, uword data_stride, uword n_data)
+__clib_export void
+serialize_multiple_4 (serialize_main_t *m, void *data, uword data_stride,
+                     uword n_data)
 {
   void *d = data;
   u32 *p;
@@ -1035,9 +1042,9 @@ serialize_multiple_4 (serialize_main_t * m,
     }
 }
 
-void
-unserialize_multiple_1 (serialize_main_t * m,
-                       void *data, uword data_stride, uword n_data)
+__clib_export void
+unserialize_multiple_1 (serialize_main_t *m, void *data, uword data_stride,
+                       uword n_data)
 {
   u8 *d = data;
   u8 *p;
@@ -1067,9 +1074,9 @@ unserialize_multiple_1 (serialize_main_t * m,
     }
 }
 
-void
-unserialize_multiple_2 (serialize_main_t * m,
-                       void *data, uword data_stride, uword n_data)
+__clib_export void
+unserialize_multiple_2 (serialize_main_t *m, void *data, uword data_stride,
+                       uword n_data)
 {
   void *d = data;
   u16 *p;
@@ -1104,9 +1111,9 @@ unserialize_multiple_2 (serialize_main_t * m,
     }
 }
 
-void
-unserialize_multiple_4 (serialize_main_t * m,
-                       void *data, uword data_stride, uword n_data)
+__clib_export void
+unserialize_multiple_4 (serialize_main_t *m, void *data, uword data_stride,
+                       uword n_data)
 {
   void *d = data;
   u32 *p;
@@ -1161,7 +1168,7 @@ clib_file_write (serialize_main_header_t * m, serialize_stream_t * s)
        serialize_error (m, clib_error_return_unix (0, "write"));
     }
   if (n == s->current_buffer_index)
-    _vec_len (s->buffer) = 0;
+    vec_set_len (s->buffer, 0);
   else
     vec_delete (s->buffer, n, 0);
   s->current_buffer_index = vec_len (s->buffer);
@@ -1191,26 +1198,26 @@ static void
 serialize_open_clib_file_descriptor_helper (serialize_main_t * m, int fd,
                                            uword is_read)
 {
-  memset (m, 0, sizeof (m[0]));
+  clib_memset (m, 0, sizeof (m[0]));
   vec_resize (m->stream.buffer, 4096);
 
   if (!is_read)
     {
       m->stream.n_buffer_bytes = vec_len (m->stream.buffer);
-      _vec_len (m->stream.buffer) = 0;
+      vec_set_len (m->stream.buffer, 0);
     }
 
   m->header.data_function = is_read ? clib_file_read : clib_file_write;
   m->stream.data_function_opaque = fd;
 }
 
-void
+__clib_export void
 serialize_open_clib_file_descriptor (serialize_main_t * m, int fd)
 {
   serialize_open_clib_file_descriptor_helper (m, fd, /* is_read */ 0);
 }
 
-void
+__clib_export void
 unserialize_open_clib_file_descriptor (serialize_main_t * m, int fd)
 {
   serialize_open_clib_file_descriptor_helper (m, fd, /* is_read */ 1);
@@ -1231,13 +1238,13 @@ serialize_open_clib_file_helper (serialize_main_t * m, char *file,
   return 0;
 }
 
-clib_error_t *
+__clib_export clib_error_t *
 serialize_open_clib_file (serialize_main_t * m, char *file)
 {
   return serialize_open_clib_file_helper (m, file, /* is_read */ 0);
 }
 
-clib_error_t *
+__clib_export clib_error_t *
 unserialize_open_clib_file (serialize_main_t * m, char *file)
 {
   return serialize_open_clib_file_helper (m, file, /* is_read */ 1);