1 /* Copyright (C) 2009 Pierre-Marc Fournier
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.
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.
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
27 /* This truncates to an offset in the buffer. */
28 #define USTD_BUFFER_TRUNC(offset, bufinfo) \
29 ((offset) & (~(((bufinfo)->subbuf_size*(bufinfo)->n_subbufs)-1)))
31 #define LTT_MAGIC_NUMBER 0x00D6B7ED
32 #define LTT_REV_MAGIC_NUMBER 0xEDB7D600
34 /* Returns the size of a subbuffer size. This is the size that
35 * will need to be written to disk.
37 * @subbuffer: pointer to the beginning of the subbuffer (the
38 * beginning of its header)
41 size_t subbuffer_data_size(void *subbuf
)
43 struct ltt_subbuffer_header
*header
= subbuf
;
47 if(header
->magic_number
== LTT_MAGIC_NUMBER
) {
50 else if(header
->magic_number
== LTT_REV_MAGIC_NUMBER
) {
57 data_size
= header
->sb_size
;
59 data_size
= bswap_32(data_size
);
65 void finish_consuming_dead_subbuffer(struct buffer_info
*buf
)
69 struct ust_buffer
*ustbuf
= buf
->bufstruct_mem
;
71 long write_offset
= uatomic_read(&ustbuf
->offset
);
72 long consumed_offset
= uatomic_read(&ustbuf
->consumed
);
76 DBG("processing dead buffer (%s)", buf
->name
);
77 DBG("consumed offset is %ld (%s)", consumed_offset
, buf
->name
);
78 DBG("write offset is %ld (%s)", write_offset
, buf
->name
);
80 /* First subbuf that we need to consume now. It is not modulo'd.
81 * Consumed_offset is the next byte to consume. */
82 long first_subbuf
= consumed_offset
/ buf
->subbuf_size
;
83 /* Last subbuf that we need to consume now. It is not modulo'd.
84 * Write_offset is the next place to write so write_offset-1 is the
85 * last place written. */
86 long last_subbuf
= (write_offset
- 1) / buf
->subbuf_size
;
88 DBG("first_subbuf=%ld", first_subbuf
);
89 DBG("last_subbuf=%ld", last_subbuf
);
91 if(last_subbuf
- first_subbuf
>= buf
->n_subbufs
) {
92 DBG("an overflow has occurred, nothing can be recovered");
96 /* Iterate on subbuffers to recover. */
97 for(i_subbuf
= first_subbuf
% buf
->n_subbufs
; ; i_subbuf
++, i_subbuf
%= buf
->n_subbufs
) {
99 /* commit_seq is the offset in the buffer of the end of the last sequential commit.
100 * Bytes beyond this limit cannot be recovered. This is a free-running counter. */
101 long commit_seq
= uatomic_read(&ustbuf
->commit_seq
[i_subbuf
]);
103 unsigned long valid_length
= buf
->subbuf_size
;
104 long n_subbufs_order
= get_count_order(buf
->n_subbufs
);
105 long commit_seq_mask
= (~0UL >> n_subbufs_order
);
107 struct ltt_subbuffer_header
*header
= (struct ltt_subbuffer_header
*)((char *)buf
->mem
+i_subbuf
*buf
->subbuf_size
);
111 if((commit_seq
& commit_seq_mask
) == 0) {
112 /* There is nothing to do. */
113 /* FIXME: is this needed? */
117 /* Check if subbuf was fully written. This is from Mathieu's algorithm/paper. */
118 /* FIXME: not sure data_size = 0xffffffff when the buffer is not full. It might
119 * take the value of the header size initially */
120 if (((commit_seq
- buf
->subbuf_size
) & commit_seq_mask
)
121 - (USTD_BUFFER_TRUNC(consumed_offset
, buf
) >> n_subbufs_order
) == 0
122 && header
->data_size
!= 0xffffffff && header
->sb_size
!= 0xffffffff) {
123 /* If it was, we only check the data_size. This is the amount of valid data at
124 * the beginning of the subbuffer. */
125 valid_length
= header
->data_size
;
126 DBG("writing full subbuffer (%d) with valid_length = %ld", i_subbuf
, valid_length
);
129 /* If the subbuffer was not fully written, then we don't check data_size because
130 * it hasn't been written yet. Instead we check commit_seq and use it to choose
131 * a value for data_size. The viewer will need this value when parsing.
134 valid_length
= commit_seq
& (buf
->subbuf_size
-1);
135 DBG("writing unfull subbuffer (%d) with valid_length = %ld", i_subbuf
, valid_length
);
136 header
->data_size
= valid_length
;
137 header
->sb_size
= PAGE_ALIGN(valid_length
);
138 assert(i_subbuf
== (last_subbuf
% buf
->n_subbufs
));
142 result
= patient_write(buf
->file_fd
, buf
->mem
+ i_subbuf
* buf
->subbuf_size
, valid_length
);
144 ERR("Error writing to buffer file");
148 /* pad with empty bytes */
149 pad_size
= PAGE_ALIGN(valid_length
)-valid_length
;
151 tmp
= malloc(pad_size
);
152 memset(tmp
, 0, pad_size
);
153 result
= patient_write(buf
->file_fd
, tmp
, pad_size
);
155 ERR("Error writing to buffer file");
161 if(i_subbuf
== last_subbuf
% buf
->n_subbufs
)
This page took 0.04214 seconds and 4 git commands to generate.