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

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