src/bin/lttng-relayd/tracefile-array.cpp

   1 /*
   2  * Copyright (C) 2015 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   3  *
   4  * SPDX-License-Identifier: GPL-2.0-only
   5  *
   6  */
   7
   8 #define _LGPL_SOURCE
   9 #include <common/common.h>
  10 #include <common/utils.h>
  11 #include <common/defaults.h>
  12
  13 #include "tracefile-array.h"
  14
  15 struct tracefile_array *tracefile_array_create(size_t count)
  16 {
  17         struct tracefile_array *tfa = NULL;
  18         int i;
  19
  20         tfa = (tracefile_array *) zmalloc(sizeof(*tfa));
  21         if (!tfa) {
  22                 goto error;
  23         }
  24         tfa->tf = (tracefile *) zmalloc(sizeof(*tfa->tf) * count);
  25         if (!tfa->tf) {
  26                 goto error;
  27         }
  28         tfa->count = count;
  29         for (i = 0; i < count; i++) {
  30                 tfa->tf[i].seq_head = -1ULL;
  31                 tfa->tf[i].seq_tail = -1ULL;
  32         }
  33         tfa->seq_head = -1ULL;
  34         tfa->seq_tail = -1ULL;
  35         return tfa;
  36
  37 error:
  38         if (tfa) {
  39                 free(tfa->tf);
  40         }
  41         free(tfa);
  42         return NULL;
  43 }
  44
  45 void tracefile_array_destroy(struct tracefile_array *tfa)
  46 {
  47         if (!tfa) {
  48                 return;
  49         }
  50         free(tfa->tf);
  51         free(tfa);
  52 }
  53
  54 void tracefile_array_reset(struct tracefile_array *tfa)
  55 {
  56         size_t count, i;
  57
  58         count = tfa->count;
  59         for (i = 0; i < count; i++) {
  60                 tfa->tf[i].seq_head = -1ULL;
  61                 tfa->tf[i].seq_tail = -1ULL;
  62         }
  63         tfa->seq_head = -1ULL;
  64         tfa->seq_tail = -1ULL;
  65         tfa->file_head_read = 0;
  66         tfa->file_head_write = 0;
  67         tfa->file_tail = 0;
  68 }
  69
  70 void tracefile_array_file_rotate(struct tracefile_array *tfa,
  71                 enum tracefile_rotate_type type)
  72 {
  73         uint64_t *headp, *tailp;
  74
  75         if (!tfa->count) {
  76                 /* Not in tracefile rotation mode. */
  77                 return;
  78         }
  79         switch (type) {
  80         case TRACEFILE_ROTATE_READ:
  81                 /*
  82                  * Rotate read head to write head position, thus allowing
  83                  * reader to consume the newly rotated head file.
  84                  */
  85                 tfa->file_head_read = tfa->file_head_write;
  86                 break;
  87         case TRACEFILE_ROTATE_WRITE:
  88                 /* Rotate write head to next file, pushing tail if needed.  */
  89                 tfa->file_head_write = (tfa->file_head_write + 1) % tfa->count;
  90                 if (tfa->file_head_write == tfa->file_tail) {
  91                         /* Move tail. */
  92                         tfa->file_tail = (tfa->file_tail + 1) % tfa->count;
  93                 }
  94                 headp = &tfa->tf[tfa->file_head_write].seq_head;
  95                 tailp = &tfa->tf[tfa->file_head_write].seq_tail;
  96                 /*
  97                  * If we overwrite a file with content, we need to push the tail
  98                  * to the position following the content we are overwriting.
  99                  */
 100                 if (*headp != -1ULL) {
 101                         tfa->seq_tail = tfa->tf[tfa->file_tail].seq_tail;
 102                 }
 103                 /* Reset this file head/tail (overwrite). */
 104                 *headp = -1ULL;
 105                 *tailp = -1ULL;
 106                 break;
 107         default:
 108                 abort();
 109         }
 110 }
 111
 112 void tracefile_array_commit_seq(struct tracefile_array *tfa,
 113                 uint64_t new_seq_head)
 114 {
 115         uint64_t *headp, *tailp;
 116
 117         /* Increment overall head. */
 118         tfa->seq_head = new_seq_head;
 119         /* If we are committing our first index overall, set tail to head. */
 120         if (tfa->seq_tail == -1ULL) {
 121                 tfa->seq_tail = new_seq_head;
 122         }
 123         if (!tfa->count) {
 124                 /* Not in tracefile rotation mode. */
 125                 return;
 126         }
 127         headp = &tfa->tf[tfa->file_head_write].seq_head;
 128         tailp = &tfa->tf[tfa->file_head_write].seq_tail;
 129         /* Update head tracefile seq_head. */
 130         *headp = tfa->seq_head;
 131         /*
 132          * If we are committing our first index in this packet, set tail
 133          * to this index seq count.
 134          */
 135         if (*tailp == -1ULL) {
 136                 *tailp = tfa->seq_head;
 137         }
 138 }
 139
 140 uint64_t tracefile_array_get_read_file_index_head(struct tracefile_array *tfa)
 141 {
 142         return tfa->file_head_read;
 143 }
 144
 145 uint64_t tracefile_array_get_seq_head(struct tracefile_array *tfa)
 146 {
 147         return tfa->seq_head;
 148 }
 149
 150 uint64_t tracefile_array_get_file_index_tail(struct tracefile_array *tfa)
 151 {
 152         return tfa->file_tail;
 153 }
 154
 155 uint64_t tracefile_array_get_seq_tail(struct tracefile_array *tfa)
 156 {
 157         return tfa->seq_tail;
 158 }
 159
 160 bool tracefile_array_seq_in_file(struct tracefile_array *tfa,
 161                 uint64_t file_index, uint64_t seq)
 162 {
 163         if (!tfa->count) {
 164                 /*
 165                  * Not in tracefile rotation mode; we are guaranteed to have the
 166                  * index in this file.
 167                  */
 168                 return true;
 169         }
 170         LTTNG_ASSERT(file_index < tfa->count);
 171         if (seq == -1ULL) {
 172                 return false;
 173         }
 174         if (seq >= tfa->tf[file_index].seq_tail
 175                         && seq <= tfa->tf[file_index].seq_head) {
 176                 return true;
 177         } else {
 178                 return false;
 179         }
 180 }