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"
40 #include "common/macros.h"
41 #include "common/common.h"
42 #include "ctfser/ctfser.h"
43 #include "compat/unistd.h"
44 #include "compat/fcntl.h"
47 uint64_t get_packet_size_increment_bytes(struct bt_ctfser
*ctfser
)
49 return bt_common_get_page_size(ctfser
->log_level
) * 8;
53 void mmap_align_ctfser(struct bt_ctfser
*ctfser
)
55 ctfser
->base_mma
= mmap_align(ctfser
->cur_packet_size_bytes
,
56 PROT_READ
| PROT_WRITE
,
57 MAP_SHARED
, ctfser
->fd
, ctfser
->mmap_offset
, ctfser
->log_level
);
61 int _bt_ctfser_increase_cur_packet_size(struct bt_ctfser
*ctfser
)
66 BT_LOGD("Increasing stream file's current packet size: "
67 "path=\"%s\", fd=%d, "
68 "offset-in-cur-packet-bits=%" PRIu64
", "
69 "cur-packet-size-bytes=%" PRIu64
,
70 ctfser
->path
->str
, ctfser
->fd
,
71 ctfser
->offset_in_cur_packet_bits
,
72 ctfser
->cur_packet_size_bytes
);
73 ret
= munmap_align(ctfser
->base_mma
);
75 BT_LOGE_ERRNO("Failed to perform an aligned memory unmapping",
80 ctfser
->cur_packet_size_bytes
+= get_packet_size_increment_bytes(
84 ret
= bt_posix_fallocate(ctfser
->fd
, ctfser
->mmap_offset
,
85 ctfser
->cur_packet_size_bytes
);
86 } while (ret
== EINTR
);
89 BT_LOGE("Failed to preallocate memory space: ret=%d", ret
);
93 mmap_align_ctfser(ctfser
);
94 if (ctfser
->base_mma
== MAP_FAILED
) {
95 BT_LOGE_ERRNO("Failed to perform an aligned memory mapping",
101 BT_LOGD("Increased packet size: "
102 "path=\"%s\", fd=%d, "
103 "offset-in-cur-packet-bits=%" PRIu64
", "
104 "new-packet-size-bytes=%" PRIu64
,
105 ctfser
->path
->str
, ctfser
->fd
,
106 ctfser
->offset_in_cur_packet_bits
,
107 ctfser
->cur_packet_size_bytes
);
114 int bt_ctfser_init(struct bt_ctfser
*ctfser
, const char *path
, int log_level
)
119 memset(ctfser
, 0, sizeof(*ctfser
));
120 ctfser
->fd
= open(path
, O_RDWR
| O_CREAT
| O_TRUNC
,
121 S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IWGRP
);
122 ctfser
->log_level
= log_level
;
123 if (ctfser
->fd
< 0) {
124 BT_LOGW_ERRNO("Failed to open stream file for writing",
125 ": path=\"%s\", ret=%d",
131 ctfser
->path
= g_string_new(path
);
138 int bt_ctfser_fini(struct bt_ctfser
*ctfser
)
142 if (ctfser
->fd
== -1) {
146 if (ctfser
->base_mma
) {
148 ret
= munmap_align(ctfser
->base_mma
);
150 BT_LOGE_ERRNO("Failed to unmap stream file",
151 ": ret=%d, size-bytes=%" PRIu64
,
152 ret
, ctfser
->stream_size_bytes
);
156 ctfser
->base_mma
= NULL
;
160 * Truncate the stream file's size to the minimum required to
161 * fit the last packet as we might have grown it too much during
162 * the last memory map.
165 ret
= ftruncate(ctfser
->fd
, ctfser
->stream_size_bytes
);
166 } while (ret
== -1 && errno
== EINTR
);
169 BT_LOGE_ERRNO("Failed to truncate stream file",
170 ": ret=%d, size-bytes=%" PRIu64
,
171 ret
, ctfser
->stream_size_bytes
);
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
);