X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=src%2Fplugins%2Fctf%2Ffs-src%2Fdata-stream-file.c;h=7d4ccf5a69333a44702446b0e8e13003bac2237f;hb=ef4ef75649a4f8484aa308ac7759bae9700f94e1;hp=078e8b5fccd10d10568ddf83c19e975dbced54cc;hpb=3073da6664aa036a96fa3e78d35d53c76a23448b;p=babeltrace.git diff --git a/src/plugins/ctf/fs-src/data-stream-file.c b/src/plugins/ctf/fs-src/data-stream-file.c index 078e8b5f..7d4ccf5a 100644 --- a/src/plugins/ctf/fs-src/data-stream-file.c +++ b/src/plugins/ctf/fs-src/data-stream-file.c @@ -1,25 +1,9 @@ /* - * Copyright 2016-2017 - Philippe Proulx - * Copyright 2016 - Jérémie Galarneau - * Copyright 2010-2011 - EfficiOS Inc. and Linux Foundation + * SPDX-License-Identifier: MIT * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. + * Copyright 2016-2017 Philippe Proulx + * Copyright 2016 Jérémie Galarneau + * Copyright 2010-2011 EfficiOS Inc. and Linux Foundation */ #define BT_COMP_LOG_SELF_COMP (self_comp) @@ -51,6 +35,17 @@ size_t remaining_mmap_bytes(struct ctf_fs_ds_file *ds_file) return ds_file->mmap_len - ds_file->request_offset_in_mapping; } +/* + * Return true if `offset_in_file` is in the current mapping. + */ + +static +bool offset_ist_mapped(struct ctf_fs_ds_file *ds_file, off_t offset_in_file) +{ + return offset_in_file >= ds_file->mmap_offset_in_file && + offset_in_file < (ds_file->mmap_offset_in_file + ds_file->mmap_len); +} + static enum ctf_msg_iter_medium_status ds_file_munmap( struct ctf_fs_ds_file *ds_file) @@ -83,38 +78,59 @@ end: return status; } +/* + * mmap a region of `ds_file` such that `requested_offset_in_file` is in the + * mapping. If the currently mmap-ed region already contains + * `requested_offset_in_file`, the mapping is kept. + * + * Set `ds_file->requested_offset_in_mapping` based on `request_offset_in_file`, + * such that the next call to `request_bytes` will return bytes starting at that + * position. + * + * `requested_offset_in_file` must be a valid offset in the file. + */ static -enum ctf_msg_iter_medium_status ds_file_mmap_next( - struct ctf_fs_ds_file *ds_file) +enum ctf_msg_iter_medium_status ds_file_mmap( + struct ctf_fs_ds_file *ds_file, off_t requested_offset_in_file) { enum ctf_msg_iter_medium_status status; bt_self_component *self_comp = ds_file->self_comp; bt_logging_level log_level = ds_file->log_level; - /* Unmap old region */ - if (ds_file->mmap_addr) { - status = ds_file_munmap(ds_file); - if (status != CTF_MSG_ITER_MEDIUM_STATUS_OK) { - goto end; - } + /* Ensure the requested offset is in the file range. */ + BT_ASSERT(requested_offset_in_file >= 0); + BT_ASSERT(requested_offset_in_file < ds_file->file->size); - /* - * mmap_len is guaranteed to be page-aligned except on the - * last mapping where it may not be possible (since the file's - * size itself may not be a page multiple). - */ - ds_file->mmap_offset_in_file += ds_file->mmap_len; - ds_file->request_offset_in_mapping = 0; + /* + * If the mapping already contains the requested offset, just adjust + * requested_offset_in_mapping. + */ + if (offset_ist_mapped(ds_file, requested_offset_in_file)) { + ds_file->request_offset_in_mapping = + requested_offset_in_file - ds_file->mmap_offset_in_file; + status = CTF_MSG_ITER_MEDIUM_STATUS_OK; + goto end; } - ds_file->mmap_len = MIN(ds_file->file->size - ds_file->mmap_offset_in_file, - ds_file->mmap_max_len); - if (ds_file->mmap_len == 0) { - status = CTF_MSG_ITER_MEDIUM_STATUS_EOF; + /* Unmap old region */ + status = ds_file_munmap(ds_file); + if (status != CTF_MSG_ITER_MEDIUM_STATUS_OK) { goto end; } - /* Map new region */ - BT_ASSERT(ds_file->mmap_len); + + /* + * Compute a mapping that has the required alignment properties and + * contains `requested_offset_in_file`. + */ + ds_file->request_offset_in_mapping = + requested_offset_in_file % bt_mmap_get_offset_align_size(ds_file->log_level); + ds_file->mmap_offset_in_file = + requested_offset_in_file - ds_file->request_offset_in_mapping; + ds_file->mmap_len = MIN(ds_file->file->size - ds_file->mmap_offset_in_file, + ds_file->mmap_max_len); + + BT_ASSERT(ds_file->mmap_len > 0); + ds_file->mmap_addr = bt_mmap((void *) 0, ds_file->mmap_len, PROT_READ, MAP_PRIVATE, fileno(ds_file->file->fp), ds_file->mmap_offset_in_file, ds_file->log_level); @@ -128,6 +144,46 @@ enum ctf_msg_iter_medium_status ds_file_mmap_next( } status = CTF_MSG_ITER_MEDIUM_STATUS_OK; + +end: + return status; +} + +/* + * Change the mapping of the file to read the region that follows the current + * mapping. + * + * If the file hasn't been mapped yet, then everything (mmap_offset_in_file, + * mmap_len, request_offset_in_mapping) should have the value 0, which will + * result in the beginning of the file getting mapped. + * + * return _EOF if the current mapping is the end of the file. + */ + +static +enum ctf_msg_iter_medium_status ds_file_mmap_next( + struct ctf_fs_ds_file *ds_file) +{ + enum ctf_msg_iter_medium_status status; + + /* + * If we're called, it's because more bytes are requested but we have + * given all the bytes of the current mapping. + */ + BT_ASSERT(ds_file->request_offset_in_mapping == ds_file->mmap_len); + + /* + * If the current mapping coincides with the end of the file, there is + * no next mapping. + */ + if (ds_file->mmap_offset_in_file + ds_file->mmap_len == ds_file->file->size) { + status = CTF_MSG_ITER_MEDIUM_STATUS_EOF; + goto end; + } + + status = ds_file_mmap(ds_file, + ds_file->mmap_offset_in_file + ds_file->mmap_len); + end: return status; } @@ -216,62 +272,230 @@ end: static enum ctf_msg_iter_medium_status medop_seek(off_t offset, void *data) { - enum ctf_msg_iter_medium_status status; struct ctf_fs_ds_file *ds_file = data; - off_t offset_in_mapping, file_size = ds_file->file->size; - bt_self_component *self_comp = ds_file->self_comp; - bt_logging_level log_level = ds_file->log_level; BT_ASSERT(offset >= 0); - BT_ASSERT(offset < file_size); + BT_ASSERT(offset < ds_file->file->size); - /* If there is no current mapping, map the right file directly. */ - if (!ds_file->mmap_addr) { - goto map_requested_offset; - } + return ds_file_mmap(ds_file, offset); +} + +BT_HIDDEN +struct ctf_msg_iter_medium_ops ctf_fs_ds_file_medops = { + .request_bytes = medop_request_bytes, + .borrow_stream = medop_borrow_stream, + .seek = medop_seek, +}; + +struct ctf_fs_ds_group_medops_data { + /* Weak, set once at creation time. */ + struct ctf_fs_ds_file_group *ds_file_group; /* - * Determine whether or not the destination is contained within the - * current mapping. + * Index (as in element rank) of the index entry of ds_file_groups' + * index we will read next (so, the one after the one we are reading + * right now). */ - if (offset < ds_file->mmap_offset_in_file || - offset >= ds_file->mmap_offset_in_file + ds_file->mmap_len) { - BT_COMP_LOGD("Medium seek request cannot be accomodated by the current " - "file mapping: offset=%jd, mmap-offset=%jd, " - "mmap-len=%zu", (intmax_t) offset, (intmax_t) ds_file->mmap_offset_in_file, - ds_file->mmap_len); - status = ds_file_munmap(ds_file); - if (status != CTF_MSG_ITER_MEDIUM_STATUS_OK) { + guint next_index_entry_index; + + /* + * File we are currently reading. Changes whenever we switch to + * reading another data file. + * + * Owned by this. + */ + struct ctf_fs_ds_file *file; + + /* Weak, for context / logging / appending causes. */ + bt_self_message_iterator *self_msg_iter; + bt_logging_level log_level; +}; + +static +enum ctf_msg_iter_medium_status medop_group_request_bytes( + size_t request_sz, + uint8_t **buffer_addr, + size_t *buffer_sz, + void *void_data) +{ + struct ctf_fs_ds_group_medops_data *data = void_data; + + /* Return bytes from the current file. */ + return medop_request_bytes(request_sz, buffer_addr, buffer_sz, data->file); +} + +static +bt_stream *medop_group_borrow_stream( + bt_stream_class *stream_class, + int64_t stream_id, + void *void_data) +{ + struct ctf_fs_ds_group_medops_data *data = void_data; + + return medop_borrow_stream(stream_class, stream_id, data->file); +} + +/* + * Set `data->file` to prepare it to read the packet described + * by `index_entry`. + */ + +static +enum ctf_msg_iter_medium_status ctf_fs_ds_group_medops_set_file( + struct ctf_fs_ds_group_medops_data *data, + struct ctf_fs_ds_index_entry *index_entry, + bt_self_message_iterator *self_msg_iter, + bt_logging_level log_level) +{ + enum ctf_msg_iter_medium_status status; + + BT_ASSERT(data); + BT_ASSERT(index_entry); + + /* Check if that file is already the one mapped. */ + if (!data->file || strcmp(index_entry->path, data->file->file->path->str) != 0) { + /* Destroy the previously used file. */ + ctf_fs_ds_file_destroy(data->file); + + /* Create the new file. */ + data->file = ctf_fs_ds_file_create( + data->ds_file_group->ctf_fs_trace, + self_msg_iter, + data->ds_file_group->stream, + index_entry->path, + log_level); + if (!data->file) { + BT_MSG_ITER_LOGE_APPEND_CAUSE(self_msg_iter, + "failed to create ctf_fs_ds_file."); + status = CTF_MSG_ITER_MEDIUM_STATUS_ERROR; goto end; } - goto map_requested_offset; - } else { - ds_file->request_offset_in_mapping = offset - ds_file->mmap_offset_in_file; - status = CTF_MSG_ITER_MEDIUM_STATUS_OK; + } + + /* + * Ensure the right portion of the file will be returned on the next + * request_bytes call. + */ + status = ds_file_mmap(data->file, index_entry->offset); + if (status != CTF_MSG_ITER_MEDIUM_STATUS_OK) { goto end; } -map_requested_offset: - offset_in_mapping = offset % - bt_mmap_get_offset_align_size(ds_file->log_level); + status = CTF_MSG_ITER_MEDIUM_STATUS_OK; + +end: + return status; +} + +static +enum ctf_msg_iter_medium_status medop_group_switch_packet(void *void_data) +{ + struct ctf_fs_ds_group_medops_data *data = void_data; + struct ctf_fs_ds_index_entry *index_entry; + enum ctf_msg_iter_medium_status status; - ds_file->mmap_offset_in_file = offset - offset_in_mapping; - ds_file->request_offset_in_mapping = offset_in_mapping; - status = ds_file_mmap_next(ds_file); + /* If we have gone through all index entries, we are done. */ + if (data->next_index_entry_index >= + data->ds_file_group->index->entries->len) { + status = CTF_MSG_ITER_MEDIUM_STATUS_EOF; + goto end; + } + + /* + * Otherwise, look up the next index entry / packet and prepare it + * for reading. + */ + index_entry = g_ptr_array_index( + data->ds_file_group->index->entries, + data->next_index_entry_index); + + status = ctf_fs_ds_group_medops_set_file( + data, index_entry, data->self_msg_iter, data->log_level); if (status != CTF_MSG_ITER_MEDIUM_STATUS_OK) { goto end; } + data->next_index_entry_index++; + status = CTF_MSG_ITER_MEDIUM_STATUS_OK; end: return status; } BT_HIDDEN -struct ctf_msg_iter_medium_ops ctf_fs_ds_file_medops = { - .request_bytes = medop_request_bytes, - .borrow_stream = medop_borrow_stream, - .seek = medop_seek, +void ctf_fs_ds_group_medops_data_destroy( + struct ctf_fs_ds_group_medops_data *data) +{ + if (!data) { + goto end; + } + + ctf_fs_ds_file_destroy(data->file); + + g_free(data); + +end: + return; +} + +enum ctf_msg_iter_medium_status ctf_fs_ds_group_medops_data_create( + struct ctf_fs_ds_file_group *ds_file_group, + bt_self_message_iterator *self_msg_iter, + bt_logging_level log_level, + struct ctf_fs_ds_group_medops_data **out) +{ + struct ctf_fs_ds_group_medops_data *data; + enum ctf_msg_iter_medium_status status; + + BT_ASSERT(self_msg_iter); + BT_ASSERT(ds_file_group); + BT_ASSERT(ds_file_group->index); + BT_ASSERT(ds_file_group->index->entries->len > 0); + + data = g_new0(struct ctf_fs_ds_group_medops_data, 1); + if (!data) { + BT_MSG_ITER_LOGE_APPEND_CAUSE(self_msg_iter, + "Failed to allocate a struct ctf_fs_ds_group_medops_data"); + status = CTF_MSG_ITER_MEDIUM_STATUS_MEMORY_ERROR; + goto error; + } + + data->ds_file_group = ds_file_group; + data->self_msg_iter = self_msg_iter; + data->log_level = log_level; + + /* + * No need to prepare the first file. ctf_msg_iter will call + * switch_packet before reading the first packet, it will be + * done then. + */ + + *out = data; + status = CTF_MSG_ITER_MEDIUM_STATUS_OK; + goto end; + +error: + ctf_fs_ds_group_medops_data_destroy(data); + +end: + return status; +} + +void ctf_fs_ds_group_medops_data_reset(struct ctf_fs_ds_group_medops_data *data) +{ + data->next_index_entry_index = 0; +} + +struct ctf_msg_iter_medium_ops ctf_fs_ds_group_medops = { + .request_bytes = medop_group_request_bytes, + .borrow_stream = medop_group_borrow_stream, + .switch_packet = medop_group_switch_packet, + + /* + * We don't support seeking using this medops. It would probably be + * possible, but it's not needed at the moment. + */ + .seek = NULL, }; static @@ -408,6 +632,13 @@ struct ctf_fs_ds_index *build_index_from_idx_file( } file_index_entry_size = be32toh(header->packet_index_len); + if (file_index_entry_size < CTF_INDEX_1_0_SIZE) { + BT_COMP_LOGW("Invalid `packet_index_len` in LTTng trace index file (`packet_index_len` < CTF index 1.0 index entry size): " + "packet_index_len=%zu, CTF_INDEX_1_0_SIZE=%zu", + file_index_entry_size, CTF_INDEX_1_0_SIZE); + goto error; + } + file_entry_count = (filesize - sizeof(*header)) / file_index_entry_size; if ((filesize - sizeof(*header)) % file_index_entry_size) { BT_COMP_LOGW("Invalid LTTng trace index: the index's size after the header "