2 * Copyright 2019 Philippe Proulx <pproulx@efficios.com>
4 * Permission is hereby granted, free of charge, to any person obtaining a copy
5 * of this software and associated documentation files (the "Software"), to deal
6 * in the Software without restriction, including without limitation the rights
7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 * copies of the Software, and to permit persons to whom the Software is
9 * furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23 #define BT_LOG_OUTPUT_LEVEL (ctfser->log_level)
24 #define BT_LOG_TAG "CTFSER"
25 #include "logging/log.h"
30 #include <sys/types.h>
33 #include "common/assert.h"
41 #include "common/macros.h"
42 #include "common/common.h"
43 #include "ctfser/ctfser.h"
44 #include "compat/unistd.h"
45 #include "compat/fcntl.h"
48 uint64_t get_packet_size_increment_bytes(struct bt_ctfser
*ctfser
)
50 return bt_common_get_page_size(ctfser
->log_level
) * 8;
54 void mmap_align_ctfser(struct bt_ctfser
*ctfser
)
56 ctfser
->base_mma
= mmap_align(ctfser
->cur_packet_size_bytes
,
57 PROT_READ
| PROT_WRITE
,
58 MAP_SHARED
, ctfser
->fd
, ctfser
->mmap_offset
, ctfser
->log_level
);
62 int _bt_ctfser_increase_cur_packet_size(struct bt_ctfser
*ctfser
)
67 BT_LOGD("Increasing stream file's current packet size: "
68 "path=\"%s\", fd=%d, "
69 "offset-in-cur-packet-bits=%" PRIu64
", "
70 "cur-packet-size-bytes=%" PRIu64
,
71 ctfser
->path
->str
, ctfser
->fd
,
72 ctfser
->offset_in_cur_packet_bits
,
73 ctfser
->cur_packet_size_bytes
);
74 ret
= munmap_align(ctfser
->base_mma
);
76 BT_LOGE_ERRNO("Failed to perform an aligned memory unmapping",
81 ctfser
->cur_packet_size_bytes
+= get_packet_size_increment_bytes(
85 ret
= bt_posix_fallocate(ctfser
->fd
, ctfser
->mmap_offset
,
86 ctfser
->cur_packet_size_bytes
);
87 } while (ret
== EINTR
);
90 BT_LOGE("Failed to preallocate memory space: ret=%d", ret
);
94 mmap_align_ctfser(ctfser
);
95 if (ctfser
->base_mma
== MAP_FAILED
) {
96 BT_LOGE_ERRNO("Failed to perform an aligned memory mapping",
102 BT_LOGD("Increased packet size: "
103 "path=\"%s\", fd=%d, "
104 "offset-in-cur-packet-bits=%" PRIu64
", "
105 "new-packet-size-bytes=%" PRIu64
,
106 ctfser
->path
->str
, ctfser
->fd
,
107 ctfser
->offset_in_cur_packet_bits
,
108 ctfser
->cur_packet_size_bytes
);
115 int bt_ctfser_init(struct bt_ctfser
*ctfser
, const char *path
, int log_level
)
120 memset(ctfser
, 0, sizeof(*ctfser
));
121 ctfser
->fd
= open(path
, O_RDWR
| O_CREAT
| O_TRUNC
,
122 S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IWGRP
);
123 ctfser
->log_level
= log_level
;
124 if (ctfser
->fd
< 0) {
125 BT_LOGW_ERRNO("Failed to open stream file for writing",
126 ": path=\"%s\", ret=%d",
132 ctfser
->path
= g_string_new(path
);
139 int bt_ctfser_fini(struct bt_ctfser
*ctfser
)
143 if (ctfser
->fd
== -1) {
148 * Truncate the stream file's size to the minimum required to
149 * fit the last packet as we might have grown it too much during
150 * the last memory map.
153 ret
= ftruncate(ctfser
->fd
, ctfser
->stream_size_bytes
);
154 } while (ret
== -1 && errno
== EINTR
);
157 BT_LOGE_ERRNO("Failed to truncate stream file",
158 ": ret=%d, size-bytes=%" PRIu64
,
159 ret
, ctfser
->stream_size_bytes
);
163 if (ctfser
->base_mma
) {
165 ret
= munmap_align(ctfser
->base_mma
);
167 BT_LOGE_ERRNO("Failed to unmap stream file",
168 ": ret=%d, size-bytes=%" PRIu64
,
169 ret
, ctfser
->stream_size_bytes
);
173 ctfser
->base_mma
= NULL
;
176 ret
= close(ctfser
->fd
);
178 BT_LOGE_ERRNO("Failed to close stream file",
187 g_string_free(ctfser
->path
, TRUE
);
196 int bt_ctfser_open_packet(struct bt_ctfser
*ctfser
)
200 BT_LOGD("Opening packet: path=\"%s\", fd=%d, "
201 "prev-packet-size-bytes=%" PRIu64
,
202 ctfser
->path
->str
, ctfser
->fd
,
203 ctfser
->prev_packet_size_bytes
);
205 if (ctfser
->base_mma
) {
206 /* Unmap old base (previous packet) */
207 ret
= munmap_align(ctfser
->base_mma
);
209 BT_LOGE_ERRNO("Failed to unmap stream file",
210 ": ret=%d, size-bytes=%" PRIu64
,
211 ret
, ctfser
->stream_size_bytes
);
215 ctfser
->base_mma
= NULL
;
219 * Add the previous packet's size to the memory map address
220 * offset to start writing immediately after it.
222 ctfser
->mmap_offset
+= ctfser
->prev_packet_size_bytes
;
223 ctfser
->prev_packet_size_bytes
= 0;
225 /* Make initial space for the current packet */
226 ctfser
->cur_packet_size_bytes
= get_packet_size_increment_bytes(
230 ret
= bt_posix_fallocate(ctfser
->fd
, ctfser
->mmap_offset
,
231 ctfser
->cur_packet_size_bytes
);
232 } while (ret
== EINTR
);
235 BT_LOGE("Failed to preallocate memory space: ret=%d", ret
);
239 /* Start writing at the beginning of the current packet */
240 ctfser
->offset_in_cur_packet_bits
= 0;
242 /* Get new base address */
243 mmap_align_ctfser(ctfser
);
244 if (ctfser
->base_mma
== MAP_FAILED
) {
245 BT_LOGE_ERRNO("Failed to perform an aligned memory mapping",
251 BT_LOGD("Opened packet: path=\"%s\", fd=%d, "
252 "cur-packet-size-bytes=%" PRIu64
,
253 ctfser
->path
->str
, ctfser
->fd
,
254 ctfser
->cur_packet_size_bytes
);
261 void bt_ctfser_close_current_packet(struct bt_ctfser
*ctfser
,
262 uint64_t packet_size_bytes
)
264 BT_LOGD("Closing packet: path=\"%s\", fd=%d, "
265 "offset-in-cur-packet-bits=%" PRIu64
266 "cur-packet-size-bytes=%" PRIu64
,
267 ctfser
->path
->str
, ctfser
->fd
,
268 ctfser
->offset_in_cur_packet_bits
,
269 ctfser
->cur_packet_size_bytes
);
272 * This will be used during the next call to
273 * bt_ctfser_open_packet(): we add
274 * `ctfser->prev_packet_size_bytes` to the current memory map
275 * address offset (first byte of _this_ packet), effectively
276 * making _this_ packet the required size.
278 ctfser
->prev_packet_size_bytes
= packet_size_bytes
;
279 ctfser
->stream_size_bytes
+= packet_size_bytes
;
280 BT_LOGD("Closed packet: path=\"%s\", fd=%d, "
281 "stream-file-size-bytes=%" PRIu64
,
282 ctfser
->path
->str
, ctfser
->fd
,
283 ctfser
->stream_size_bytes
);