svm: change fifo pointers to offsets

[vpp.git] / src / svm / fifo_segment.c

diff --git a/src/svm/fifo_segment.c b/src/svm/fifo_segment.c
index 19fd052..008cca4 100644 (file)
--- a/src/svm/fifo_segment.c
+++ b/src/svm/fifo_segment.c
@@ -148,28 +148,30 @@ fss_chunk_fl_index_is_valid (fifo_segment_slice_t * fss, u32 fl_index)
 }
 
 static void
-fss_chunk_free_list_push (fifo_segment_slice_t * fss, u32 fl_index,
-                         svm_fifo_chunk_t * c)
+fss_chunk_free_list_push (fifo_segment_header_t *fsh,
+                         fifo_segment_slice_t *fss, u32 fl_index,
+                         svm_fifo_chunk_t *c)
 {
   fss_chunk_freelist_lock (fss);
   c->next = fss->free_chunks[fl_index];
-  fss->free_chunks[fl_index] = c;
+  fss->free_chunks[fl_index] = fs_chunk_sptr (fsh, c);
   fss_chunk_freelist_unlock (fss);
 }
 
 static void
-fss_chunk_free_list_push_list (fifo_segment_slice_t * fss, u32 fl_index,
-                              svm_fifo_chunk_t * head,
-                              svm_fifo_chunk_t * tail)
+fss_chunk_free_list_push_list (fifo_segment_header_t *fsh,
+                              fifo_segment_slice_t *fss, u32 fl_index,
+                              svm_fifo_chunk_t *head, svm_fifo_chunk_t *tail)
 {
   fss_chunk_freelist_lock (fss);
   tail->next = fss->free_chunks[fl_index];
-  fss->free_chunks[fl_index] = head;
+  fss->free_chunks[fl_index] = fs_chunk_sptr (fsh, head);
   fss_chunk_freelist_unlock (fss);
 }
 
 static svm_fifo_chunk_t *
-fss_chunk_free_list_pop (fifo_segment_slice_t * fss, u32 fl_index)
+fss_chunk_free_list_pop (fifo_segment_header_t *fsh, fifo_segment_slice_t *fss,
+                        u32 fl_index)
 {
   svm_fifo_chunk_t *c;
 
@@ -183,7 +185,7 @@ fss_chunk_free_list_pop (fifo_segment_slice_t * fss, u32 fl_index)
       return 0;
     }
 
-  c = fss->free_chunks[fl_index];
+  c = fs_chunk_ptr (fsh, fss->free_chunks[fl_index]);
   fss->free_chunks[fl_index] = c->next;
 
   fss_chunk_freelist_unlock (fss);
@@ -435,10 +437,10 @@ fs_try_alloc_multi_chunk (fifo_segment_header_t * fsh,
 
   while (req_bytes)
     {
-      c = fss_chunk_free_list_pop (fss, fl_index);
+      c = fss_chunk_free_list_pop (fsh, fss, fl_index);
       if (c)
        {
-         c->next = first;
+         c->next = fs_chunk_sptr (fsh, first);
          first = c;
          n_alloc += fl_size;
          req_bytes -= clib_min (fl_size, req_bytes);
@@ -453,8 +455,8 @@ fs_try_alloc_multi_chunk (fifo_segment_header_t * fsh,
              while (c)
                {
                  fl_index = fs_freelist_for_size (c->length);
-                 next = c->next;
-                 fss_chunk_free_list_push (fss, fl_index, c);
+                 next = fs_chunk_ptr (fsh, c->next);
+                 fss_chunk_free_list_push (fsh, fss, fl_index, c);
                  c = next;
                }
              n_alloc = 0;
@@ -464,7 +466,7 @@ fs_try_alloc_multi_chunk (fifo_segment_header_t * fsh,
              fl_index = fs_freelist_for_size (data_bytes) + 1;
              if (!fss_chunk_fl_index_is_valid (fss, fl_index))
                return 0;
-             first = fss_chunk_free_list_pop (fss, fl_index);
+             first = fss_chunk_free_list_pop (fsh, fss, fl_index);
              if (first)
                {
                  first->next = 0;
@@ -541,13 +543,13 @@ fsh_try_alloc_chunk_batch (fifo_segment_header_t * fsh,
     {
       c->start_byte = 0;
       c->length = rounded_data_size;
-      c->next = head;
+      c->next = fs_chunk_sptr (fsh, head);
       head = c;
       cmem += sizeof (*c) + rounded_data_size;
       c = (svm_fifo_chunk_t *) cmem;
     }
 
-  fss_chunk_free_list_push_list (fss, fl_index, head, tail);
+  fss_chunk_free_list_push_list (fsh, fss, fl_index, head, tail);
   fss->num_chunks[fl_index] += batch_size;
   fss_fl_chunk_bytes_add (fss, total_chunk_bytes);
   fsh_cached_bytes_add (fsh, total_chunk_bytes);
@@ -593,7 +595,7 @@ fsh_try_alloc_chunk (fifo_segment_header_t * fsh,
   fl_index = fs_freelist_for_size (data_bytes);
 
 free_list:
-  c = fss_chunk_free_list_pop (fss, fl_index);
+  c = fss_chunk_free_list_pop (fsh, fss, fl_index);
   if (c)
     {
       c->next = 0;
@@ -678,10 +680,10 @@ fs_try_alloc_fifo (fifo_segment_header_t *fsh, u32 slice_index, u32 data_bytes)
       return 0;
     }
 
-  sf->start_chunk = c;
+  sf->start_chunk = fs_chunk_sptr (fsh, c);
   while (c->next)
-    c = c->next;
-  sf->end_chunk = c;
+    c = fs_chunk_ptr (fsh, c->next);
+  sf->end_chunk = fs_chunk_sptr (fsh, c);
   sf->size = data_bytes;
   sf->slice_index = slice_index;
 
@@ -710,9 +712,9 @@ fsh_slice_collect_chunks (fifo_segment_header_t * fsh,
   while (c)
     {
       CLIB_MEM_UNPOISON (c, sizeof (*c));
-      next = c->next;
+      next = fs_chunk_ptr (fsh, c->next);
       fl_index = fs_freelist_for_size (c->length);
-      fss_chunk_free_list_push (fss, fl_index, c);
+      fss_chunk_free_list_push (fsh, fss, fl_index, c);
       n_collect += fs_freelist_index_to_size (fl_index);
       c = next;
     }
@@ -842,7 +844,7 @@ fifo_segment_free_fifo (fifo_segment_t * fs, svm_fifo_t * f)
   fss = fsh_slice_get (fsh, sf->slice_index);
 
   /* Free fifo chunks */
-  fsh_slice_collect_chunks (fsh, fss, sf->start_chunk);
+  fsh_slice_collect_chunks (fsh, fss, fs_chunk_ptr (fsh, f->shr->start_chunk));
 
   sf->start_chunk = sf->end_chunk = 0;
   sf->head_chunk = sf->tail_chunk = 0;
@@ -895,12 +897,12 @@ fifo_segment_detach_fifo (fifo_segment_t * fs, svm_fifo_t * f)
   if (f->flags & SVM_FIFO_F_LL_TRACKED)
     fss_fifo_del_active_list (fss, f);
 
-  c = f->shr->start_chunk;
+  c = fs_chunk_ptr (fs->h, f->shr->start_chunk);
   while (c)
     {
       fl_index = fs_freelist_for_size (c->length);
       clib_atomic_fetch_sub_rel (&fss->num_chunks[fl_index], 1);
-      c = c->next;
+      c = fs_chunk_ptr (fs->h, c->next);
     }
 }
 
@@ -918,12 +920,12 @@ fifo_segment_attach_fifo (fifo_segment_t * fs, svm_fifo_t * f,
   if (f->flags & SVM_FIFO_F_LL_TRACKED)
     fss_fifo_add_active_list (fss, f);
 
-  c = f->shr->start_chunk;
+  c = fs_chunk_ptr (fs->h, f->shr->start_chunk);
   while (c)
     {
       fl_index = fs_freelist_for_size (c->length);
       clib_atomic_fetch_add_rel (&fss->num_chunks[fl_index], 1);
-      c = c->next;
+      c = fs_chunk_ptr (fs->h, c->next);
     }
 }
 
@@ -1068,7 +1070,8 @@ fifo_segment_num_free_fifos (fifo_segment_t * fs)
 }
 
 static u32
-fs_slice_num_free_chunks (fifo_segment_slice_t * fss, u32 size)
+fs_slice_num_free_chunks (fifo_segment_header_t *fsh,
+                         fifo_segment_slice_t *fss, u32 size)
 {
   u32 count = 0, rounded_size, fl_index;
   svm_fifo_chunk_t *c;
@@ -1079,13 +1082,13 @@ fs_slice_num_free_chunks (fifo_segment_slice_t * fss, u32 size)
     {
       for (i = 0; i < FS_CHUNK_VEC_LEN; i++)
        {
-         c = fss->free_chunks[i];
+         c = fs_chunk_ptr (fsh, fss->free_chunks[i]);
          if (c == 0)
            continue;
 
          while (c)
            {
-             c = c->next;
+             c = fs_chunk_ptr (fsh, c->next);
              count++;
            }
        }
@@ -1098,13 +1101,13 @@ fs_slice_num_free_chunks (fifo_segment_slice_t * fss, u32 size)
   if (fl_index >= FS_CHUNK_VEC_LEN)
     return 0;
 
-  c = fss->free_chunks[fl_index];
+  c = fs_chunk_ptr (fsh, fss->free_chunks[fl_index]);
   if (c == 0)
     return 0;
 
   while (c)
     {
-      c = c->next;
+      c = fs_chunk_ptr (fsh, c->next);
       count++;
     }
   return count;
@@ -1121,7 +1124,7 @@ fifo_segment_num_free_chunks (fifo_segment_t * fs, u32 size)
   for (slice_index = 0; slice_index < fs->n_slices; slice_index++)
     {
       fss = fsh_slice_get (fsh, slice_index);
-      count += fs_slice_num_free_chunks (fss, size);
+      count += fs_slice_num_free_chunks (fsh, fss, size);
     }
   return count;
 }
@@ -1328,13 +1331,13 @@ format_fifo_segment (u8 * s, va_list * args)
       fss = fsh_slice_get (fsh, slice_index);
       for (i = 0; i < FS_CHUNK_VEC_LEN; i++)
        {
-         c = fss->free_chunks[i];
+         c = fs_chunk_ptr (fsh, fss->free_chunks[i]);
          if (c == 0 && fss->num_chunks[i] == 0)
            continue;
          count = 0;
          while (c)
            {
-             c = c->next;
+             c = fs_chunk_ptr (fsh, c->next);
              count++;
            }