| 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 | |