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_file_rotate(struct tracefile_array *tfa)
  66 {
  67         uint64_t *headp, *tailp;
  68
  69         if (!tfa->count) {
  70                 /* Not in tracefile rotation mode. */
  71                 return;
  72         }
  73         /* Rotate to next file.  */
  74         tfa->file_head = (tfa->file_head + 1) % tfa->count;
  75         if (tfa->file_head == tfa->file_tail) {
  76                 /* Move tail. */
  77                 tfa->file_tail = (tfa->file_tail + 1) % tfa->count;
  78         }
  79         headp = &tfa->tf[tfa->file_head].seq_head;
  80         tailp = &tfa->tf[tfa->file_head].seq_tail;
  81         /*
  82          * If we overwrite a file with content, we need to push the tail
  83          * to the position following the content we are overwriting.
  84          */
  85         if (*headp != -1ULL) {
  86                 tfa->seq_tail = tfa->tf[tfa->file_tail].seq_tail;
  87         }
  88         /* Reset this file head/tail (overwrite). */
  89         *headp = -1ULL;
  90         *tailp = -1ULL;
  91 }
  92
  93 void tracefile_array_commit_seq(struct tracefile_array *tfa)
  94 {
  95         uint64_t *headp, *tailp;
  96
  97         /* Increment overall head. */
  98         tfa->seq_head++;
  99         /* If we are committing our first index overall, set tail to 0. */
 100         if (tfa->seq_tail == -1ULL) {
 101                 tfa->seq_tail = 0;
 102         }
 103         if (!tfa->count) {
 104                 /* Not in tracefile rotation mode. */
 105                 return;
 106         }
 107         headp = &tfa->tf[tfa->file_head].seq_head;
 108         tailp = &tfa->tf[tfa->file_head].seq_tail;
 109         /* Update head tracefile seq_head. */
 110         *headp = tfa->seq_head;
 111         /*
 112          * If we are committing our first index in this packet, set tail
 113          * to this index seq count.
 114          */
 115         if (*tailp == -1ULL) {
 116                 *tailp = tfa->seq_head;
 117         }
 118 }
 119
 120 uint64_t tracefile_array_get_file_index_head(struct tracefile_array *tfa)
 121 {
 122         return tfa->file_head;
 123 }
 124
 125 uint64_t tracefile_array_get_seq_head(struct tracefile_array *tfa)
 126 {
 127         return tfa->seq_head;
 128 }
 129
 130 uint64_t tracefile_array_get_file_index_tail(struct tracefile_array *tfa)
 131 {
 132         return tfa->file_tail;
 133 }
 134
 135 uint64_t tracefile_array_get_seq_tail(struct tracefile_array *tfa)
 136 {
 137         return tfa->seq_tail;
 138 }
 139
 140 bool tracefile_array_seq_in_file(struct tracefile_array *tfa,
 141                 uint64_t file_index, uint64_t seq)
 142 {
 143         if (!tfa->count) {
 144                 /*
 145                  * Not in tracefile rotation mode; we are guaranteed to have the
 146                  * index in this file.
 147                  */
 148                 return true;
 149         }
 150         assert(file_index < tfa->count);
 151         if (seq == -1ULL) {
 152                 return false;
 153         }
 154         if (seq >= tfa->tf[file_index].seq_tail
 155                         && seq <= tfa->tf[file_index].seq_head) {
 156                 return true;
 157         } else {
 158                 return false;
 159         }
 160 }