| /* |
| * Copyright © 2019 Collabora Ltd. |
| * |
| * 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 (including the |
| * next paragraph) 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. |
| */ |
| |
| #include "config.h" |
| |
| #include <libweston/weston-log.h> |
| #include "shared/helpers.h" |
| #include "shared/zalloc.h" |
| #include <libweston/libweston.h> |
| |
| #include "weston-log-internal.h" |
| |
| #include <assert.h> |
| #include <unistd.h> |
| #include <stdarg.h> |
| #include <string.h> |
| #include <errno.h> |
| #include <sys/time.h> |
| |
| struct weston_ring_buffer { |
| uint32_t append_pos; /**< where in the buffer we are */ |
| uint32_t size; /**< max length of the ring buffer */ |
| char *buf; /**< the buffer itself */ |
| FILE *file; /**< where to write in case we need to dump the buf */ |
| bool overlap; /**< in case buff overlaps, hint from where to print buf contents */ |
| }; |
| |
| /** allows easy access to the ring buffer in case of a core dump |
| */ |
| WL_EXPORT struct weston_ring_buffer *weston_primary_flight_recorder_ring_buffer = NULL; |
| |
| /** A black box type of stream, used to aggregate data continuously, and |
| * when needed, to dump its contents for inspection. |
| */ |
| struct weston_debug_log_flight_recorder { |
| struct weston_log_subscriber base; |
| struct weston_ring_buffer rb; |
| }; |
| |
| static void |
| weston_ring_buffer_init(struct weston_ring_buffer *rb, size_t size, char *buf) |
| { |
| rb->append_pos = 0; |
| rb->size = size - 1; |
| rb->buf = buf; |
| rb->overlap = false; |
| rb->file = stderr; |
| } |
| |
| static struct weston_debug_log_flight_recorder * |
| to_flight_recorder(struct weston_log_subscriber *sub) |
| { |
| return container_of(sub, struct weston_debug_log_flight_recorder, base); |
| } |
| |
| static void |
| weston_log_flight_recorder_adjust_end(struct weston_ring_buffer *rb, |
| size_t bytes_to_advance) |
| { |
| if (rb->append_pos == rb->size - bytes_to_advance) |
| rb->append_pos = 0; |
| else |
| rb->append_pos += bytes_to_advance; |
| } |
| |
| static void |
| weston_log_flight_recorder_write_chunks(struct weston_ring_buffer *rb, |
| const char *data, size_t len) |
| { |
| /* no of chunks that matches our buffer size */ |
| size_t nr_chunks = len / rb->size; |
| |
| /* bytes left that do not fill entire buffer */ |
| size_t bytes_left_last_chunk = len % rb->size; |
| const char *c_data = data; |
| |
| /* might overlap multiple times, memcpy is redundant, |
| * that's why we don't even modify append_pos */ |
| while (nr_chunks-- > 0) { |
| memcpy(&rb->buf[rb->append_pos], c_data, rb->size); |
| c_data += rb->size; |
| } |
| |
| if (bytes_left_last_chunk) |
| memcpy(&rb->buf[rb->append_pos], c_data, bytes_left_last_chunk); |
| |
| /* adjust append_pos */ |
| weston_log_flight_recorder_adjust_end(rb, bytes_left_last_chunk); |
| } |
| |
| static void |
| weston_log_flight_recorder_write_chunks_overlap(struct weston_ring_buffer *rb, |
| const char *data, size_t len) |
| { |
| size_t transfer_remains = |
| (rb->append_pos + len) - rb->size; |
| size_t transfer_to_end = len - transfer_remains; |
| const char *c_data = data; |
| |
| /* transfer what remains until the end of the buffer */ |
| memcpy(&rb->buf[rb->append_pos], c_data, transfer_to_end); |
| c_data += transfer_to_end; |
| |
| /* reset append_pos as we filled up the buffer */ |
| rb->append_pos = 0; |
| |
| /* transfer what remains */ |
| weston_log_flight_recorder_write_chunks(rb, c_data, transfer_remains); |
| rb->overlap = true; |
| } |
| |
| static void |
| weston_log_flight_recorder_write_data(struct weston_ring_buffer *rb, |
| const char *data, size_t len) |
| { |
| /* |
| * If append_pos is at the beginning of the buffer, we determine if we |
| * should do it in chunks, and if there are any bytes left we transfer |
| * those as well. |
| * |
| * If the append_pos is somewhere inside the buffer we determine how |
| * many bytes we need to transfer between we reach the end and overlap, |
| * then we proceed as in the first step. |
| */ |
| if (rb->append_pos == 0) |
| weston_log_flight_recorder_write_chunks(rb, data, len); |
| else |
| weston_log_flight_recorder_write_chunks_overlap(rb, data, len); |
| } |
| |
| static void |
| weston_log_flight_recorder_write(struct weston_log_subscriber *sub, |
| const char *data, size_t len) |
| { |
| struct weston_debug_log_flight_recorder *flight_rec = |
| to_flight_recorder(sub); |
| struct weston_ring_buffer *rb = &flight_rec->rb; |
| |
| /* in case the data is bigger than the size of the buf */ |
| if (rb->size < len) { |
| weston_log_flight_recorder_write_data(rb, data, len); |
| } else { |
| /* if we can transfer it without wrapping it do it at once */ |
| if (rb->append_pos <= rb->size - len) { |
| memcpy(&rb->buf[rb->append_pos], data, len); |
| |
| /* |
| * adjust append_pos, take care of the situation were |
| * to fill up the entire buf |
| */ |
| weston_log_flight_recorder_adjust_end(rb, len); |
| } else { |
| weston_log_flight_recorder_write_data(rb, data, len); |
| } |
| } |
| |
| } |
| |
| static void |
| weston_log_flight_recorder_map_memory(struct weston_debug_log_flight_recorder *flight_rec) |
| { |
| size_t i = 0; |
| |
| for (i = 0; i < flight_rec->rb.size; i++) |
| flight_rec->rb.buf[i] = 0xff; |
| } |
| |
| static void |
| weston_log_subscriber_display_flight_rec_data(struct weston_ring_buffer *rb, |
| FILE *file) |
| { |
| FILE *file_d = stderr; |
| if (file) |
| file_d = file; |
| |
| if (!rb->overlap) { |
| if (rb->append_pos) |
| fwrite(rb->buf, sizeof(char), rb->append_pos, file_d); |
| else |
| fwrite(rb->buf, sizeof(char), rb->size, file_d); |
| } else { |
| /* from append_pos to size */ |
| fwrite(&rb->buf[rb->append_pos], sizeof(char), |
| rb->size - rb->append_pos, file_d); |
| /* from 0 to append_pos */ |
| fwrite(rb->buf, sizeof(char), rb->append_pos, file_d); |
| } |
| } |
| |
| WL_EXPORT void |
| weston_log_subscriber_display_flight_rec(struct weston_log_subscriber *sub) |
| { |
| struct weston_debug_log_flight_recorder *flight_rec = |
| to_flight_recorder(sub); |
| struct weston_ring_buffer *rb = &flight_rec->rb; |
| |
| weston_log_subscriber_display_flight_rec_data(rb, rb->file); |
| } |
| |
| static void |
| weston_log_subscriber_destroy_flight_rec(struct weston_log_subscriber *sub) |
| { |
| struct weston_debug_log_flight_recorder *flight_rec = to_flight_recorder(sub); |
| |
| /* Resets weston_primary_flight_recorder_ring_buffer to NULL if it |
| * is the destroyed subscriber */ |
| if (weston_primary_flight_recorder_ring_buffer == &flight_rec->rb) |
| weston_primary_flight_recorder_ring_buffer = NULL; |
| |
| weston_log_subscriber_release(sub); |
| free(flight_rec->rb.buf); |
| free(flight_rec); |
| } |
| |
| /** Create a flight recorder type of subscriber |
| * |
| * Allocates both the flight recorder and the underlying ring buffer. Use |
| * weston_log_subscriber_destroy() to clean-up. |
| * |
| * @param size specify the maximum size (in bytes) of the backing storage |
| * for the flight recorder |
| * @returns a weston_log_subscriber object or NULL in case of failure |
| */ |
| WL_EXPORT struct weston_log_subscriber * |
| weston_log_subscriber_create_flight_rec(size_t size) |
| { |
| struct weston_debug_log_flight_recorder *flight_rec; |
| char *weston_rb; |
| |
| assert("Can't create more than one flight recorder." && |
| !weston_primary_flight_recorder_ring_buffer); |
| |
| flight_rec = zalloc(sizeof(*flight_rec)); |
| if (!flight_rec) |
| return NULL; |
| |
| flight_rec->base.write = weston_log_flight_recorder_write; |
| flight_rec->base.destroy = weston_log_subscriber_destroy_flight_rec; |
| flight_rec->base.destroy_subscription = NULL; |
| flight_rec->base.complete = NULL; |
| wl_list_init(&flight_rec->base.subscription_list); |
| |
| weston_rb = zalloc(sizeof(char) * size); |
| if (!weston_rb) { |
| free(flight_rec); |
| return NULL; |
| } |
| |
| weston_ring_buffer_init(&flight_rec->rb, size, weston_rb); |
| weston_primary_flight_recorder_ring_buffer = &flight_rec->rb; |
| |
| /* write some data to the rb such that the memory gets mapped */ |
| weston_log_flight_recorder_map_memory(flight_rec); |
| |
| return &flight_rec->base; |
| } |
| |
| /** Retrieve flight recorder ring buffer contents, could be useful when |
| * implementing an assert()-like wrapper. |
| * |
| * @param file a FILE type already opened. Can also pass stderr/stdout under gdb |
| * if the program is loaded into memory. |
| * |
| * Uses the global exposed weston_primary_flight_recorder_ring_buffer. |
| * |
| */ |
| WL_EXPORT void |
| weston_log_flight_recorder_display_buffer(FILE *file) |
| { |
| if (!weston_primary_flight_recorder_ring_buffer) |
| return; |
| |
| weston_log_subscriber_display_flight_rec_data(weston_primary_flight_recorder_ring_buffer, |
| file); |
| } |