ustd/lowlevel.c

   1 /* Copyright (C) 2009  Pierre-Marc Fournier
   2  *
   3  * This library is free software; you can redistribute it and/or
   4  * modify it under the terms of the GNU Lesser General Public
   5  * License as published by the Free Software Foundation; either
   6  * version 2.1 of the License, or (at your option) any later version.
   7  *
   8  * This library is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * Lesser General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU Lesser General Public
  14  * License along with this library; if not, write to the Free Software
  15  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  16  */
  17
  18 #include <assert.h>
  19
  20 #include "tracer.h"
  21 #include "ustd.h"
  22 #include "usterr.h"
  23
  24 /* This truncates to an offset in the buffer. */
  25 #define USTD_BUFFER_TRUNC(offset, bufinfo) \
  26         ((offset) & (~(((bufinfo)->subbuf_size*(bufinfo)->n_subbufs)-1)))
  27
  28 void finish_consuming_dead_subbuffer(struct buffer_info *buf)
  29 {
  30         struct ust_buffer *ustbuf = buf->bufstruct_mem;
  31
  32         long write_offset = local_read(&ustbuf->offset);
  33         long consumed_offset = atomic_long_read(&ustbuf->consumed);
  34
  35         long i_subbuf;
  36
  37         DBG("processing died buffer");
  38         DBG("consumed offset is %ld", consumed_offset);
  39         DBG("write offset is %ld", write_offset);
  40
  41         /* First subbuf that we need to consume now. It is not modulo'd.
  42          * Consumed_offset is the next byte to consume.  */
  43         long first_subbuf = consumed_offset / buf->subbuf_size;
  44         /* Last subbuf that we need to consume now. It is not modulo'd.
  45          * Write_offset is the next place to write so write_offset-1 is the
  46          * last place written. */
  47         long last_subbuf = (write_offset - 1) / buf->subbuf_size;
  48
  49         DBG("first_subbuf=%ld", first_subbuf);
  50         DBG("last_subbuf=%ld", last_subbuf);
  51
  52         if(last_subbuf - first_subbuf >= buf->n_subbufs) {
  53                 DBG("an overflow has occurred, nothing can be recovered");
  54                 return;
  55         }
  56
  57         /* Iterate on subbuffers to recover. */
  58         for(i_subbuf=first_subbuf; ; i_subbuf++, i_subbuf %= buf->n_subbufs) {
  59                 void *tmp;
  60                 /* commit_seq is the offset in the buffer of the end of the last sequential commit.
  61                  * Bytes beyond this limit cannot be recovered. This is a free-running counter. */
  62                 long commit_seq = local_read(&ustbuf->commit_seq[i_subbuf]);
  63
  64                 unsigned long valid_length = buf->subbuf_size;
  65                 long n_subbufs_order = get_count_order(buf->n_subbufs);
  66                 long commit_seq_mask = (~0UL >> n_subbufs_order);
  67
  68                 struct ltt_subbuffer_header *header = (struct ltt_subbuffer_header *)((char *)buf->mem+i_subbuf*buf->subbuf_size);
  69
  70                 if((commit_seq & commit_seq_mask) == 0) {
  71                         /* There is nothing to do. */
  72                         /* FIXME: is this needed? */
  73                         break;
  74                 }
  75
  76                 /* Check if subbuf was fully written. This is from Mathieu's algorithm/paper. */
  77                 if (((commit_seq - buf->subbuf_size) & commit_seq_mask)
  78                     - (USTD_BUFFER_TRUNC(consumed_offset, buf) >> n_subbufs_order)
  79                     == 0) {
  80                         /* If it was, we only check the lost_size. This is the lost padding at the end of
  81                          * the subbuffer. */
  82                         valid_length = (unsigned long)buf->subbuf_size - header->lost_size;
  83                 }
  84                 else {
  85                         /* If the subbuffer was not fully written, then we don't check lost_size because
  86                          * it hasn't been written yet. Instead we check commit_seq and use it to choose
  87                          * a value for lost_size. The viewer will need this value when parsing.
  88                          */
  89
  90                         valid_length = commit_seq & (buf->subbuf_size-1);
  91                         header->lost_size = buf->subbuf_size-valid_length;
  92                         assert(i_subbuf == (last_subbuf % buf->n_subbufs));
  93                 }
  94
  95
  96                 patient_write(buf->file_fd, buf->mem + i_subbuf * buf->subbuf_size, valid_length);
  97
  98                 /* pad with empty bytes */
  99                 tmp = malloc(buf->subbuf_size-valid_length);
 100                 memset(tmp, 0, buf->subbuf_size-valid_length);
 101                 patient_write(buf->file_fd, tmp, buf->subbuf_size-valid_length);
 102                 free(tmp);
 103
 104                 if(i_subbuf == last_subbuf % buf->n_subbufs)
 105                         break;
 106         }
 107 }
 108