Page MenuHome
Differential D12741 Diff 42862 source/blender/blenlib/intern/BLI_mmap.c

Changeset View

Standalone View

View Options

source/blender/blenlib/intern/BLI_mmap.c

Context not available.
#include "BLI_mmap.h" #include "BLI_mmap.h"
#include "BLI_fileops.h" #include "BLI_fileops.h"
#include "BLI_listbase.h" #include "BLI_linklist.h"
#include "BLI_threads.h"
#include "MEM_guardedalloc.h" #include "MEM_guardedalloc.h"
#include <threads.h>
#include <string.h> #include <string.h>
Context not available.
* set after it's done reading. * set after it's done reading.
* If the error occurred outside of a memory-mapped region, we call the previous * If the error occurred outside of a memory-mapped region, we call the previous
* handler if one was configured and abort the process otherwise. * handler if one was configured and abort the process otherwise.
* Note that signal handlers are extremely limited in terms of what they may do -
* in particular, any operations that might lock (e.g. also malloc()) can end up
* deadlocking the process.
* This becomes a problem if multiple threads are using memory-mapped files since
* accesses to the FileData list might conflict, but we can't lock on it.
* Luckily, unlike signals in general, SIGBUS is guaranteed to be delivered to the
* thread that triggered it. Therefore, we can use thread-local storage to store
* a separate list for each thread. This unfortunately implies that a BLI_mmap_file
* may only be safely accessed from the thread that opened it.
*/ */
/* Implicitly zero-initialized. */
static thread_local LinkNode *open_mmaps = NULL;
static struct error_handler_data { static struct error_handler_data {
ListBase open_mmaps;
char configured; /* The signal handler should only be set up once.
* Since this isn't locked by the signal handler, a mutex is fine here. */
volatile char configured;
ThreadMutex setup_mutex;
void (*next_handler)(int, siginfo_t *, void *); void (*next_handler)(int, siginfo_t *, void *);
campbellbartonUnsubmitted
Not Done
Inline Actions

While I don't have a strong opinion on this, a BLI_mmap_init_once() function would avoid the lock & configured check, I have a slight preference for this over locking for a one-off call.

campbellbarton: While I don't have a strong opinion on this, a `BLI_mmap_init_once()` function would avoid the…
} error_handler = {0}; } error_handler = {0, BLI_MUTEX_INITIALIZER, NULL};
static void sigbus_handler(int sig, siginfo_t *siginfo, void *ptr) static void sigbus_handler(int sig, siginfo_t *siginfo, void *ptr)
{ {
Context not available.
char *error_addr = (char *)siginfo->si_addr; char *error_addr = (char *)siginfo->si_addr;
/* Find the file that this error belongs to. */ /* Find the file that this error belongs to. */
LISTBASE_FOREACH (LinkData *, link, &error_handler.open_mmaps) { for (LinkNode *link = open_mmaps; link; link = link->next) {
BLI_mmap_file *file = link->data; BLI_mmap_file *file = link->link;
/* Is the address where the error occurred in this file's mapped range? */ /* Is the address where the error occurred in this file's mapped range? */
if (error_addr >= file->memory && error_addr < file->memory + file->length) { if (error_addr >= file->memory && error_addr < file->memory + file->length) {
Context not available.
const void *mapped_memory = mmap( const void *mapped_memory = mmap(
file->memory, file->length, PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0); file->memory, file->length, PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
if (mapped_memory == MAP_FAILED) { if (mapped_memory == MAP_FAILED) {
fprintf(stderr, "SIGBUS handler: Error replacing mapped file with zeros\n"); /* fprintf may allocate internal buffers, which is not signal-safe. */
const char *msg = "SIGBUS handler: Error replacing mapped file with zeros\n";
write(STDERR_FILENO, msg, strlen(msg));
} }
return; return;
Context not available.
error_handler.next_handler(sig, siginfo, ptr); error_handler.next_handler(sig, siginfo, ptr);
} }
else { else {
fprintf(stderr, "Unhandled SIGBUS caught\n"); const char *msg = "Unhandled SIGBUS caught\n";
write(STDERR_FILENO, msg, strlen(msg));
abort(); abort();
} }
} }
Context not available.
/* Ensures that the error handler is set up and ready. */ /* Ensures that the error handler is set up and ready. */
static bool sigbus_handler_setup(void) static bool sigbus_handler_setup(void)
{ {
if (error_handler.configured) {
return true;
}
BLI_mutex_lock(&error_handler.setup_mutex);
if (!error_handler.configured) { if (!error_handler.configured) {
struct sigaction newact = {0}, oldact = {0}; struct sigaction newact = {0}, oldact = {0};
Context not available.
newact.sa_flags = SA_SIGINFO; newact.sa_flags = SA_SIGINFO;
if (sigaction(SIGBUS, &newact, &oldact)) { if (sigaction(SIGBUS, &newact, &oldact)) {
BLI_mutex_unlock(&error_handler.setup_mutex);
return false; return false;
} }
Context not available.
error_handler.next_handler = oldact.sa_sigaction; error_handler.next_handler = oldact.sa_sigaction;
error_handler.configured = 1; error_handler.configured = 1;
} }
BLI_mutex_unlock(&error_handler.setup_mutex);
return true; return true;
} }
Context not available.
/* Adds a file to the list that the error handler checks. */ /* Adds a file to the list that the error handler checks. */
static void sigbus_handler_add(BLI_mmap_file *file) static void sigbus_handler_add(BLI_mmap_file *file)
{ {
BLI_addtail(&error_handler.open_mmaps, BLI_genericNodeN(file)); BLI_linklist_prepend(&open_mmaps, file);
} }
/* Removes a file from the list that the error handler checks. */ /* Removes a file from the list that the error handler checks. */
static void sigbus_handler_remove(BLI_mmap_file *file) static void sigbus_handler_remove(BLI_mmap_file *file)
{ {
LinkData *link = BLI_findptr(&error_handler.open_mmaps, file, offsetof(LinkData, data)); /* Search the entry matching this file and remove it from the list. */
BLI_freelinkN(&error_handler.open_mmaps, link); for (LinkNode **link = &open_mmaps; *link != NULL; *link = (*link)->next) {
if ((*link)->link == file) {
LinkNode *next = (*link)->next;
MEM_freeN(*link);
*link = next;
break;
}
}
} }
#endif #endif
Context not available.