/* Copyright (c) 2020, 2024, Oracle and/or its affiliates. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License, version 2.0, as published by the Free Software Foundation. This program is designed to work with certain software (including but not limited to OpenSSL) that is licensed under separate terms, as designated in a particular file or component or in included license documentation. The authors of MySQL hereby grant you an additional permission to link the program and your derivative works with the separately licensed software that they have either included with the program or referenced in the documentation. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ /** @file log_sink_perfschema.cc This file contains a) the ring-buffer that stores a backlog of error-messages so they can be exposed to the SQL layer via performance_schema.error_log; b) the log-sink that adds errors logged at run-time to the ring-buffer. c) the error log reader that reads error log file at start-up (These functions will in turn use a parse-function defined in a log-sink. Whichever log-sink that has a parse-function is listed first in @@global.log_error_services will be used; that service will decide what log-file to read (i.e. its name) and how to parse it. We initially support the reading of JSON- formatted error log files and of the traditional MySQL error log files.) This lets us restore error log information from previous runs when the server starts. These functions are called from mysqld.cc at start-up. */ #include "log_sink_perfschema.h" #include // data types #include // memset() #include "log_builtins_internal.h" #include "log_sink_perfschema_imp.h" #include "log_sink_trad.h" // log_sink_trad_parse_log_line() #include "my_dir.h" #include "my_systime.h" // my_micro_time() #include "mysql/components/services/log_builtins.h" #include "mysql/my_loglevel.h" #include "mysqld_error.h" #include "mysys_err.h" #include "sql/log.h" /** In the interest of not adding more settings to confuse the using, the error-log ring-buffer is of a static size for now. This will be easy enough to change later if needs or policy change. While a log-event can currently be up to 8 KB in size (and with minor changes be of practically arbitrary size), a majority of common events seem to be in the 150 - 200 bytes range (in trad mode, perhaps 100 more each in JSON mode) at the time of this writing. That lead us to expect a yield of 4-6 events per KB, and thus about 25,000 for a buffer of 5 MB. */ static const size_t ring_buffer_size = 5 * 1024 * 1024; static char *ring_buffer_start = nullptr; ///< buffer start static char *ring_buffer_end = nullptr; ///< buffer end (for convenience) static char *ring_buffer_write = nullptr; ///< write position ("head") static char *ring_buffer_read = nullptr; ///< read pos (oldest entry, "tail") ulong log_sink_pfs_buffered_bytes = 0; ///< bytes in use (now) ulong log_sink_pfs_buffered_events = 0; ///< events in buffer (now) ulong log_sink_pfs_expired_events = 0; ///< number of expired entries (ever) ulong log_sink_pfs_longest_event = 0; ///< longest event seen (ever) ulonglong log_sink_pfs_latest_timestamp = 0; ///< timestamp of most recent write PSI_memory_key key_memory_log_sink_pfs; ///< memory instrumentation /** ring-buffer rwlock Local to the sink that feeds the table performance_schema.error_log. Code outside of the sink can acquire / release this lock using log_sink_pfs_read_start() / log_sink_pfs_read_start(). */ static mysql_rwlock_t THR_LOCK_log_perfschema; #define LOG_ERR_READ_LINE_SIZE (LOG_BUFF_MAX * 2) /** Calculate the size of the given event (header + blob + '\0' + alignment). The header is followed by a blob (error message or JSON representation of the complete event) and a '\0' terminator (for safety); it is then aligned to the correct address boundary if needed. @param e The event we're interested in. Must be non-NULL. @retval The total size (header + message + '\0' + padding) in bytes. */ static inline size_t log_sink_pfs_event_size(log_sink_pfs_event *e) { assert(e != nullptr); size_t s = sizeof(log_sink_pfs_event) + ((size_t)e->m_message_length) + 1; s = MY_ALIGN(s, sizeof(ulonglong)); return s; } /** Test whether we're so close to the end of the ring-buffer that another event header would not fit. @param p The address where we'd like to write (e.g. ring_buffer_write) @retval true There is enough space to write a header. @retval false Insufficient space, must wrap around to buffer-start to write. */ static inline bool log_sink_pfs_event_header_fits(char *p) { return ((p + sizeof(log_sink_pfs_event)) <= ring_buffer_end); } /** Acquire a read-lock on the ring-buffer. */ void log_sink_pfs_read_start() { mysql_rwlock_rdlock(&THR_LOCK_log_perfschema); } /** Release read-lock on ring-buffer. */ void log_sink_pfs_read_end() { mysql_rwlock_unlock(&THR_LOCK_log_perfschema); } /** Get number of events currently in ring-buffer. Caller should hold THR_LOCK_log_perschema when reading this. @returns number of events current in ring-buffer (0..) */ size_t log_sink_pfs_event_count() { return log_sink_pfs_buffered_events; } /** Get oldest event still in ring-buffer. Caller should hold read-lock on THR_LOCK_log_perfschema when calling this. @retval nullptr No events in buffer @retval otherwise Address of oldest event in ring-buffer */ log_sink_pfs_event *log_sink_pfs_event_first() { if (log_sink_pfs_buffered_events == 0) return nullptr; return (log_sink_pfs_event *)ring_buffer_read; } /** Get event following the supplied one. Caller should hold read-lock on THR_LOCK_log_perfschema when calling this. If advancing the read position puts the read-pointer beyond the highest-address event in the ring-buffer (which isn't necessarily the latest event, which is defined as the last event before catching up with the write-pointer), i.e. at a position where either a wrap- around marker exists, or there is not enough space for a header, we wrap around to the start of the ring-buffer. @param e Last event the caller was processing. This event should be valid, non-NULL, and should not be a wrap-around marker (m_messages_length == 0). @retval nullptr No more events in ring-buffer (caught up with writer) @retval otherwise Address of the next event in the ring-buffer */ log_sink_pfs_event *log_sink_pfs_event_next(log_sink_pfs_event *e) { char *n; // pointer to next event // pre-condition: e must be a valid event assert(e != nullptr); // do not accept nullptr assert(e->m_message_length != 0); // current event should not be wrap-around marker // next event's location is current event's location plus its size n = ((char *)e) + log_sink_pfs_event_size(e); // We've caught up with the head (write-position): no more events if (n == ring_buffer_write) return nullptr; /* Wrap-around handling: The Ring If we're so close to the end of the ring-buffer that there is not enough space for another header, or a header exists but indicates its blob didn't fit, wrap around to start of ring-buffer. */ if (!log_sink_pfs_event_header_fits(n) || (((log_sink_pfs_event *)n)->m_message_length == 0)) { n = ring_buffer_start; /* Fail-safe: If there is only space for a single event, head and tail are now the same. In this case, we fail to read. This is a somewhat synthetic case in that it should only happen with minuscule buffer sizes (a few KB or less). */ if (n == ring_buffer_write) return nullptr; } // next event should not be wrap-around marker assert(((log_sink_pfs_event *)n)->m_message_length != 0); return (log_sink_pfs_event *)n; } /** Use timestamp to check whether a given event-pointer still points to a valid event in the ring-buffer. Caller should hold read-lock on THR_LOCK_log_perfschema when calling this. @param e Address of event @param logged unique timestamp of event @retval nullptr Event no longer exists in ring-buffer @retval otherwise Address of the event in the ring-buffer */ log_sink_pfs_event *log_sink_pfs_event_valid(log_sink_pfs_event *e, ulonglong logged) { assert(e != nullptr); assert(ring_buffer_read != nullptr); // If the ring-buffer is empty, the event won't be there. if (log_sink_pfs_buffered_events == 0) return nullptr; /* If the requested timestamp is older than the oldest item in the ring-buffer, bail. This is a valid condition. This usually means that the event existed earlier, but has since been discarded from the ring-buffer to make room for new events. */ if (logged < ((log_sink_pfs_event *)ring_buffer_read)->m_timestamp) return nullptr; /* purecov: inspected */ // Request's timestamp shouldn't be in the future. assert(logged <= log_sink_pfs_latest_timestamp); // Request's timestamp should equal that at the address we were given. assert(logged == e->m_timestamp); // If we got here, the event still exists in the ring-buffer. return e; } // expire tail event (oldest event in buffer) by adjusting the read-pointer static inline void log_sink_pfs_event_expire(void) { assert(log_sink_pfs_buffered_events > 0); assert(ring_buffer_read != nullptr); log_sink_pfs_buffered_bytes -= log_sink_pfs_event_size((log_sink_pfs_event *)ring_buffer_read); log_sink_pfs_buffered_events--; log_sink_pfs_expired_events++; ring_buffer_read = (char *)log_sink_pfs_event_next((log_sink_pfs_event *)ring_buffer_read); } /** If the current event can fit in the ring-buffer, but the write position is so close to the physical end of the ring-buffer that the event won't fit there, wrap to the beginning of the ring-buffer. Write a wrap-marker if possible. Adjust the pointers as needed: If there isn't enough space to write the current event (of size ``s``): a) if the read-pointer > write-pointer (which should always be the case after the first wrap), we wrap the read-pointer to the physical start of the ring-buffer b) write a wrap-marker if space permits c) wrap the write-pointer to the (physical) start of the ring-buffer Caller must guarantee that event size <= ring-buffer-size. @retval 0 didn't need to wrap @retval 1 write-pointer wrapped @retval 2 write-pointer and read-pointer wrapped */ static inline int log_sink_pfs_write_wrap(size_t s) { int ret = 0; assert(s <= ring_buffer_size); // Writing the event would go past the end of the buffer. Wrap around! if ((ring_buffer_write + s) > ring_buffer_end) { ret = 1; // After the first wrap (i.e. read > write): If we wrap write, also wrap // read. The buffer is empty, read is NULL here and we skip this branch. if (ring_buffer_read >= ring_buffer_write) { ret = 2; assert(log_sink_pfs_buffered_events > 0); // Expire high-address entries individually so statistics are correct while (ring_buffer_read >= ring_buffer_write) { assert(log_sink_pfs_buffered_events > 0); log_sink_pfs_event_expire(); } /* If the tail didn't wrap (so we ran out of events before the read pointer would wrap, resulting in ring_buffer_read == NULL), something's strange. (It is implied here that (ring_buffer_write > ring_buffer_start) -- otherwise, (s<=ring_buffer_size) would be false --, so wrapping around (ring_buffer_read = ring_buffer_start) and immediately satisfying ring_buffer_read == ring_buffer_write (with the resulting setting of ring_buffer_read to NULL) should not happen. */ assert(ring_buffer_read == ring_buffer_start); } /* If there is enough space for a header, write a wrap-around marker. (The header is of a fixed size, so if there isn't enough space for a wrap-around marker, the reader can reliably detect that. The reader logic is therefore, is there enough space for a header? if no, wrap around. if yes, read it: if it's a wrap-around marker, wrap around; otherwise, read the paylog string (the DATA field). */ if (log_sink_pfs_event_header_fits(ring_buffer_write)) memset(ring_buffer_write, 0, sizeof(log_sink_pfs_event)); // wrap write pointer ring_buffer_write = ring_buffer_start; } return ret; } // make sure that the event contains a sane timestamp static inline void log_sink_pfs_sanitize_timestamp(log_sink_pfs_event *e) { // failsafe: if no timestamp was given, create one now. if (e->m_timestamp == 0) e->m_timestamp = my_micro_time(); // make sure timestamps are unique if (e->m_timestamp <= log_sink_pfs_latest_timestamp) e->m_timestamp = ++log_sink_pfs_latest_timestamp; else log_sink_pfs_latest_timestamp = e->m_timestamp; } /** Add a log-event to the ring buffer. In the ring-buffer, each event exists as a header and a blob. The header is a log_sink_pfs_event struct containing the traditional error-log columns. It is followed by a variable-length blob that contains just the message string in traditional log mode, and the complete event as JSON in JSON log format. The length of the event will be align to the correct boundary. If writing the event would go past the end of the ring-buffer, we wrap around to the beginning of the buffer. After the function success, ``ring_buffer_read`` will be set to a valid, non-zero value. @param e filled-in event struct to copy into the ring-buffer @param blob_src variable-length part of the event to add to the ring-buffer @retval LOG_SERVICE_SUCCESS event was added @retval LOG_SERVICE_NOT_AVAILABLE ring-buffer not available @retval LOG_SERVICE_INVALID_ARGUMENT event has no message @retval LOG_SERVICE_ARGUMENT_TOO_LONG event is larger than buffer(!) */ log_service_error log_sink_pfs_event_add(log_sink_pfs_event *e, const char *blob_src) { char *blob_dst; // address to write the blob to in the ring-buffer size_t s; log_service_error ret = LOG_SERVICE_ARGUMENT_TOO_LONG; // If either of these fail, the ring-buffer's not been set up (yet). if ((ring_buffer_start == nullptr) || (ring_buffer_write == nullptr)) return LOG_SERVICE_NOT_AVAILABLE; // Have we been given an invalid event (one with no message)? assert(e->m_message_length > 0); // No-message event: Fail gracefully in production. if (e->m_message_length == 0) return LOG_SERVICE_INVALID_ARGUMENT; // How much space do we need in the ring-buffer (including alignment padding)? s = log_sink_pfs_event_size(e); // write-lock ring-buffer mysql_rwlock_wrlock(&THR_LOCK_log_perfschema); // Statistics: track longest event seen. if (s > log_sink_pfs_longest_event) log_sink_pfs_longest_event = s; // Let's not process events that are larger than the buffer. if (s >= ring_buffer_size) goto done; /* We've made sure the event will fit in the ring-buffer, but it may not fit at the current position. In that case, - if the read>write (as it will be after the first wrap), expire all events from read/tail until the phys-end of the buffer - if there is space for a wrap-marker, write one. - wrap the write-pointer to the start of the buffer */ log_sink_pfs_write_wrap(s); /* If the write position is <= the read position, but writing the event would write past the read position, there is an overlap, and we need to expire enough old events to write the new one: We move the read-position forward towards younger events, thereby expiring older ones that the writer is about to overwrite. Since the blob portion of the event is of variable size, writing one (large) new event may require expiring several (smaller) old events. If we already expired all events above, or the buffer was empty to begin with, log_sink_pfs_buffered_events is 0 here and we won't enter the loop. */ while ((log_sink_pfs_buffered_events > 0) && (ring_buffer_write <= ring_buffer_read) && ((ring_buffer_write + s) > ring_buffer_read)) { /* Skip forward to the next oldest event until we have expired enough old events to make room for the new one. The "next" function called by "expire" automatically handles the wrap-around at the end of the ring-buffer. ``ring_buffer_read`` can become NULL here if we end up throwing every last event in the buffer. */ log_sink_pfs_event_expire(); } /* If the ring-buffer was empty to begin with, or if we had to expire all existing events to make room of the new event (and ended up with an empty ring-buffer that way), ring_buffer_read is NULL now, and we'll re-initialize the read-pointer to a sensible value: The buffer is empty, and we're about to add the (now) first event to it: a) set read-pointer = write-pointer b) write the new event c) adjust the write-pointer to after the new event The read-pointer now points to the beginning of the sole event, the write-pointer points just behind it. If a write wrap-around was needed, this has already happened above, and we're copying a post-wrap pointer, i.e. one to the start of the buffer. At start-up, this should be equivalent to setting the read-pointer to ring_buffer_start (because we just wrote the very first event to the very start of the buffer). */ if (ring_buffer_read == nullptr) { assert(log_sink_pfs_buffered_events == 0); ring_buffer_read = ring_buffer_write; } // make sure that the event contains a sane timestamp log_sink_pfs_sanitize_timestamp(e); // copy the event header memcpy(ring_buffer_write, e, sizeof(log_sink_pfs_event)); // append the variable length message blob_dst = ring_buffer_write + sizeof(log_sink_pfs_event); memcpy(blob_dst, blob_src, e->m_message_length); // terminate for safety; this is accounted for in log_sink_pfs_event_size() blob_dst[e->m_message_length] = '\0'; // move the write-pointer behind the new event to the next write position ring_buffer_write += s; log_sink_pfs_buffered_events++; log_sink_pfs_buffered_bytes += s; // ensure that we leave the read-pointer in a valid state assert(((log_sink_pfs_event *)ring_buffer_read)->m_message_length != 0); ret = LOG_SERVICE_SUCCESS; done: mysql_rwlock_unlock(&THR_LOCK_log_perfschema); return ret; } // Restoring the log from the file /** Add all rows from a log file to the error-log ring-buffer. We have to guesstimate where to start reading in the log: - The error_log table is kept in a ring-buffer. Reading more items than we have space for is therefore harmless; we should however try to keep the waste down for performance reasons. - In the traditional log, the part of the row before the message is 63 characters long. This gets converted into an event header. The header's size is platform-dependent, but usually shorter than 63 bytes. Thus, the size of each record in the input will be more or less the size of its corresponding record in the output. As a consequence, reading the ring-buffer's size from the input should be about right. - When reading the JSON log, we'll fill in the event header from the parsed values, but we will also attach the entire JSON record to the event. Each record in the ring-buffer is therefore the size of the original JSON record, plus the size of a record header. As a consequence reading the ring-buffer's size from the input will give us more events than we need (because we "lose" about 50 bytes to the header for each event). However, the input is of variable length and we can not tell whether it's a few long rows or a lot of short ones. Therefore, we assume the worst (rather than the average) case and try to read input the size of the ring-buffer. This will mean that we read some more rows than we have space for, but since it's a ring-buffer, that means that the oldest entries will be discarded to make room for the younger ones, and we'll end up with the correct result. @param log_file The file's name @param size length of the input file (in bytes) @retval LOG_SERVICE_SUCCESS success @retval LOG_SERVICE_OPEN_FAILED failed to open file @retval LOG_SERVICE_SEEK_FAILED seek failed @retval LOG_SERVICE_UNABLE_TO_READ read failed @retval LOG_SERVICE_PARSE_ERROR could not find delimiter ('\n') */ static log_service_error log_error_read_loop(const char *log_file, size_t size) { FILE *fh; off_t pos; char *chunk; const char *line_start, *line_end; log_service_error ret = LOG_SERVICE_SUCCESS; assert(log_sink_pfs_source != nullptr); assert(log_sink_pfs_source->sce != nullptr); if (size <= 0) return LOG_SERVICE_UNABLE_TO_READ; if ((fh = fopen(log_file, "r")) == nullptr) return LOG_SERVICE_OPEN_FAILED; if ((chunk = (char *)my_malloc(key_memory_log_sink_pfs, LOG_ERR_READ_LINE_SIZE, MYF(0))) == nullptr) goto fail_with_close; /* If the file would fit into the ring-buffer entirely, we'll read it from the beginning. (We don't actually read it to the ring-buffer, but it's a good guide-line.) Otherwise, we start reading from a point in the file where about the size of the ring-buffer remains as input. */ if (size <= ring_buffer_size) pos = 0; else { pos = size - ring_buffer_size; // seek to the approximate position of the row to start reading at if (fseek(fh, (long)pos, SEEK_SET)) { /* purecov: begin inspected */ ret = LOG_SERVICE_SEEK_FAILED; goto fail_with_free; /* purecov: end */ } // we're likely in the middle of a row, skip forward to the next if ((line_start = fgets(chunk, LOG_ERR_READ_LINE_SIZE, fh)) == nullptr) { ret = LOG_SERVICE_UNABLE_TO_READ; /* purecov: begin inspected */ goto fail_with_free; /* purecov: end */ } } while ((line_start = fgets(chunk, LOG_ERR_READ_LINE_SIZE, fh)) != nullptr) { /* If we did not manage to read a full line, skip to next record. Excessively long records are thus skipped, but do not abort the reading. */ if ((line_end = (const char *)memchr(line_start, '\n', LOG_ERR_READ_LINE_SIZE)) == nullptr) { // Skip the rest of the overly long row, until we find a newline. do { if ((line_start = fgets(chunk, LOG_ERR_READ_LINE_SIZE, fh)) == nullptr) { ret = LOG_SERVICE_PARSE_ERROR; goto fail_with_free; } line_end = (const char *)memchr(line_start, '\n', LOG_ERR_READ_LINE_SIZE); } while (line_end == nullptr); /* We now have (fragment of) a skipped line in the buffer. We do not try to parse it; just proceed with reading the next line. */ } else { // get a log event from the read line and add it to the ring-buffer if (!(log_sink_pfs_source->sce->chistics & LOG_SERVICE_BUILTIN)) { SERVICE_TYPE(log_service) * ls; ls = reinterpret_cast( log_sink_pfs_source->sce->service); assert(ls != nullptr); if (ls != nullptr) ret = ls->parse_log_line(line_start, line_end - line_start); } else ret = log_sink_trad_parse_log_line(line_start, line_end - line_start); } } fail_with_free: my_free(chunk); fail_with_close: fclose(fh); return ret; } // The public interface to restoring the error-log to the ring-buffer: /** Restore error log messages from previous shutdown. We try restoring from the first (leftmost) of those services listed in @@global.log_error_services that have the LOG_SERVICE_LOG_PARSER characteristic. It is assumed that the last run's log file name is the same as the current one's. That is to say, we check whether the file supplied to --log-error already exists. Once we have determined what file to read from, we'll call @see log_error_read_loop() to do the actual reading and parsing. It should be noted that at the point this function is normally called, buffered error logging will not have flushed yet. a) If we are using the built-in "trad" sink/reader, the start-up messages are usually not buffered, and have already been written to the error log. In this case, they will be restored from the log (and flushing won't add another event to the ring-buffer). b) If we are using a reader in a loadable log-service, @param log_name The log file to read (log_error_dest). @retval LOG_SERVICE_SUCCESS Success (log read and parsed) @retval LOG_SERVICE_UNABLE_TO_READ Could not read/access() file @retval LOG_SERVICE_INVALID_ARGUMENT Invalid file-name (no '.') @retval LOG_SERVICE_NOT_AVAILABLE No log_component active that can parse log-files @retval LOG_SERVICE_ARGUMENT_TOO_LONG File-name too long @retval LOG_SERVICE_COULD_NOT_MAKE_LOG_NAME Could not determine file extension @retval otherwise Return value from reader */ log_service_error log_error_read_log(const char *log_name) { MY_STAT stat_log; char path[FN_REFLEN]; log_service_error ret; assert((log_name != nullptr) && (log_name[0] != '\0')); assert(ring_buffer_start != nullptr); // No log-service configured that could parse a log if ((log_sink_pfs_source == nullptr) || !(log_sink_pfs_source->sce->chistics & LOG_SERVICE_LOG_PARSER)) { LogErr(INFORMATION_LEVEL, ER_NO_ERROR_LOG_PARSER_CONFIGURED); return LOG_SERVICE_NOT_AVAILABLE; } // If --log-err=... does not name a file, there's nothing we can do here. assert(log_name != nullptr); assert(log_name[0] != '\0'); assert(0 != strcmp(log_name, "stderr")); // If we're not using the built-in (trad log) reader, fix the log file name if (!(log_sink_pfs_source->sce->chistics & LOG_SERVICE_BUILTIN)) { char ext[32]; SERVICE_TYPE(log_service) * ls; ls = reinterpret_cast( log_sink_pfs_source->sce->service); assert(ls != nullptr); // try to determine file extension for this log-service if ((ls == nullptr) || (ls->get_log_name(nullptr, ext, sizeof(ext)) < 0)) return LOG_SERVICE_COULD_NOT_MAKE_LOG_NAME; /* purecov: inspected */ if (make_log_path(path, ext) != LOG_SERVICE_SUCCESS) return LOG_SERVICE_COULD_NOT_MAKE_LOG_NAME; /* purecov: inspected */ } else if (strlen(log_name) >= FN_REFLEN) return LOG_SERVICE_ARGUMENT_TOO_LONG; /* purecov: inspected */ else strcpy(path, log_name); // trad log. use default @@log_error. /* Lock the error-logger while we're restoring the error-log so nobody writes to the log-file while we're reading it. That way, we won't have to deal with half-written lines or the file-size changing. */ log_builtins_error_stack_wrlock(); if (my_access(path, R_OK) || (my_stat(path, &stat_log, MYF(0)) == nullptr)) ret = LOG_SERVICE_UNABLE_TO_READ; /* purecov: inspected */ else ret = log_error_read_loop(path, (size_t)stat_log.st_size); log_builtins_error_stack_unlock(); return ret; } /** Release error log ring-buffer. @retval 0 Success - buffer was released, or did not exist in the first place. */ int log_error_read_log_exit() { mysql_rwlock_wrlock(&THR_LOCK_log_perfschema); if (ring_buffer_start != nullptr) { my_free(ring_buffer_start); } log_sink_pfs_buffered_bytes = 0; log_sink_pfs_expired_events = 0; log_sink_pfs_buffered_events = 0; ring_buffer_write = ring_buffer_read = ring_buffer_start = ring_buffer_end = nullptr; mysql_rwlock_unlock(&THR_LOCK_log_perfschema); mysql_rwlock_destroy(&THR_LOCK_log_perfschema); return 0; } /** Set up ring-buffer for error-log. @retval 0 Success - buffer was allocated. @retval !=0 Failure - buffer was not allocated. */ int log_error_read_log_init() { assert(ring_buffer_start == nullptr); char *b; if ((b = (char *)my_malloc(key_memory_log_sink_pfs, ring_buffer_size, MYF(0))) == nullptr) return -1; /* purecov: inspected */ if (mysql_rwlock_init(0, &THR_LOCK_log_perfschema)) { my_free(b); /* purecov: inspected */ return -1; /* purecov: inspected */ } log_sink_pfs_buffered_bytes = 0; log_sink_pfs_expired_events = 0; log_sink_pfs_buffered_events = 0; ring_buffer_start = b; ring_buffer_read = ring_buffer_start; ring_buffer_write = ring_buffer_start; ring_buffer_end = ring_buffer_start + ring_buffer_size; // convenience return 0; } /** services: log sinks: logging to performance_schema ring-buffer Will write timestamp, label, thread-ID, and message to stderr/file. If you should not be able to specify a label, one will be generated for you from the line's priority field. @param instance instance handle @param ll the log line to write @retval int number of added fields, if any */ int log_sink_perfschema(void *instance [[maybe_unused]], log_line *ll) { log_sink_pfs_event e; memset(&e, 0, sizeof(log_sink_pfs_event)); assert(ring_buffer_start != nullptr); const char *msg = nullptr; int c, out_fields = 0; size_t iso_len = 0; unsigned int err_code = 0; log_item_type item_type = LOG_ITEM_END; log_item_type_mask out_types = 0; const char *iso_timestamp = ""; log_item *capture_buffer = log_line_get_output_buffer(ll); if (capture_buffer != nullptr) { msg = capture_buffer->data.data_string.str; e.m_message_length = capture_buffer->data.data_string.length; } e.m_prio = ERROR_LEVEL; if (ll->count > 0) { for (c = 0; c < ll->count; c++) { item_type = ll->item[c].type; out_fields++; switch (item_type) { case LOG_ITEM_LOG_BUFFERED: e.m_timestamp = (ulonglong)ll->item[c].data.data_integer; break; case LOG_ITEM_SQL_ERRCODE: err_code = (unsigned int)ll->item[c].data.data_integer; e.m_error_code_length = snprintf(e.m_error_code, LOG_SINK_PFS_ERROR_CODE_LENGTH, "MY-%06u", err_code); break; case LOG_ITEM_LOG_PRIO: e.m_prio = (enum loglevel)ll->item[c].data.data_integer; break; case LOG_ITEM_LOG_MESSAGE: if (msg == nullptr) { msg = ll->item[c].data.data_string.str; e.m_message_length = ll->item[c].data.data_string.length; } break; case LOG_ITEM_SRV_SUBSYS: if ((e.m_subsys_length = ll->item[c].data.data_string.length) >= LOG_SINK_PFS_SUBSYS_LENGTH) e.m_subsys_length = LOG_SINK_PFS_SUBSYS_LENGTH - 1; strncpy(e.m_subsys, ll->item[c].data.data_string.str, e.m_subsys_length); e.m_subsys[e.m_subsys_length] = '\0'; break; case LOG_ITEM_LOG_TIMESTAMP: iso_timestamp = ll->item[c].data.data_string.str; iso_len = ll->item[c].data.data_string.length; e.m_timestamp = iso8601_timestamp_to_microseconds(iso_timestamp, iso_len); break; case LOG_ITEM_SRV_THREAD: e.m_thread_id = (my_thread_id)ll->item[c].data.data_integer; break; default: out_fields--; } out_types |= item_type; } // failsafe: guard against no or zero-length message if (!(out_types & LOG_ITEM_LOG_MESSAGE) || (msg == nullptr) || (e.m_message_length == 0)) { msg = "No error message, or error message of non-string type. " "This is almost certainly a bug!"; e.m_message_length = strlen(msg); e.m_prio = ERROR_LEVEL; // force severity out_types &= ~(LOG_ITEM_LOG_LABEL); // regenerate label out_types |= LOG_ITEM_LOG_MESSAGE; // we added a message } if (log_sink_pfs_event_add(&e, msg) != LOG_SERVICE_SUCCESS) return 0; return out_fields; // returning number of processed items } // no item in log-line return 0; /* purecov: inspected */ } /** Add a log-event to the ring buffer. We require the various pieces of information to be passed individually rather than accepting a log_sink_pfs_event so we can sanity check each part individually and don't have to worry about different components using different versions/sizes of the struct. We copy the data as needed, so caller may free their copy once this call returns. @param timestamp Timestamp (in microseconds), or 0 to have one generated @param thread_id thread_id of the thread that detected the issue @param prio (INFORMATION|WARNING|ERROR|SYSTEM)_LEVEL @param error_code "MY-123456"-style error-code, or nullptr @param error_code_length length in bytes of error_code @param subsys Subsystem ("InnoDB", "Server", "Repl"), or nullptr @param subsys_length length in bytes of subsys @param message data (error message/JSON record/...). required. @param message_length length of data field @retval LOG_SERVICE_SUCCESS success @retval LOG_SERVICE_ARGUMENT_TOO_LONG argument too long @retval LOG_SERVICE_INVALID_ARGUMENT invalid argument */ DEFINE_METHOD(log_service_error, log_sink_perfschema_imp::event_add, (ulonglong timestamp, ulonglong thread_id, ulong prio, const char *error_code, uint error_code_length, const char *subsys, uint subsys_length, const char *message, uint message_length)) { const log_service_error ret = LOG_SERVICE_ARGUMENT_TOO_LONG; log_sink_pfs_event e; memset(&e, 0, sizeof(log_sink_pfs_event)); // prio if (prio > INFORMATION_LEVEL) return LOG_SERVICE_INVALID_ARGUMENT; e.m_prio = prio; // thread_id e.m_thread_id = thread_id; // message (mandatory. ring-buffer doesn't have LOG_BUFF_MAX limitation.) if ((message == nullptr) || (message_length == 0)) return LOG_SERVICE_INVALID_ARGUMENT; e.m_message_length = message_length; // subsys if ((subsys != nullptr) && (subsys_length < LOG_SINK_PFS_SUBSYS_LENGTH)) { memcpy(e.m_subsys, subsys, subsys_length); e.m_subsys_length = subsys_length; e.m_subsys[subsys_length] = '\0'; } else return ret; // error-code if ((error_code != nullptr) && (error_code_length < LOG_SINK_PFS_ERROR_CODE_LENGTH)) { memcpy(e.m_error_code, error_code, error_code_length); e.m_error_code_length = error_code_length; e.m_error_code[error_code_length] = '\0'; } else return ret; /* The add-function below will provide a current timestamp if 0 was given, and make sure the values are strictly increasing, so we're not sanity testing here. */ e.m_timestamp = timestamp; // This function will deep-copy the data as needed. return log_sink_pfs_event_add(&e, message); }