sentry-contrib-native-sys 0.3.0

Unofficial FFI bindings to the Sentry Native SDK for Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

#include "sentry_unix_pageallocator.h"
#include "sentry_core.h"
#include "sentry_unix_spinlock.h"

#include <sys/mman.h>
#include <unistd.h>

// some macos versions do not have this yet
#if !defined(MAP_ANONYMOUS) && defined(SENTRY_PLATFORM_DARWIN)
#    define MAP_ANONYMOUS MAP_ANON
#endif

#define ALIGN 8

struct page_header;
struct page_header {
    struct page_header *next;
    size_t num_pages;
};

struct page_allocator_s {
    size_t page_size;
    struct page_header *last_page;
    char *current_page;
    size_t page_offset;
    size_t pages_allocated;
};

static struct page_allocator_s g_page_allocator_backing = { 0 };
static struct page_allocator_s *g_alloc = NULL;
static sentry_spinlock_t g_lock = SENTRY__SPINLOCK_INIT;

bool
sentry__page_allocator_enabled(void)
{
    return !!g_alloc;
}

void
sentry__page_allocator_enable(void)
{
    sentry__spinlock_lock(&g_lock);
    if (!g_alloc) {
        g_alloc = &g_page_allocator_backing;
        g_alloc->page_size = getpagesize();
        g_alloc->last_page = NULL;
        g_alloc->current_page = NULL;
        g_alloc->page_offset = 0;
        g_alloc->pages_allocated = 0;
    }
    sentry__spinlock_unlock(&g_lock);
}

static void *
get_pages(size_t num_pages)
{
    void *rv = mmap(NULL, g_alloc->page_size * num_pages,
        PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (rv == MAP_FAILED) {
        return NULL;
    }

#if defined(__has_feature)
#    if __has_feature(memory_sanitizer)
    __msan_unpoison(rv, g_alloc->page_size * num_pages);
#    endif
#endif

    struct page_header *header = (struct page_header *)rv;
    header->next = g_alloc->last_page;
    header->num_pages = num_pages;
    g_alloc->last_page = header;

    g_alloc->pages_allocated += num_pages;

    return rv;
}

void *
sentry__page_allocator_alloc(size_t size)
{
    if (!size) {
        return NULL;
    }

    // make sure the requested size is correctly aligned
    size_t diff = size % ALIGN;
    size = size + ALIGN - diff;

    char *rv = NULL;

    sentry__spinlock_lock(&g_lock);

    // current page is large enough
    if (g_alloc->current_page
        && g_alloc->page_size - g_alloc->page_offset >= size) {
        rv = g_alloc->current_page + g_alloc->page_offset;
        g_alloc->page_offset += size;
        if (g_alloc->page_offset == g_alloc->page_size) {
            g_alloc->page_offset = 0;
            g_alloc->current_page = NULL;
        }
    } else {
        // allocate new pages

        size_t requested_size = size + sizeof(struct page_header);
        size_t pages
            = (requested_size + g_alloc->page_size - 1) / g_alloc->page_size;
        size_t actual_size = g_alloc->page_size * pages;

        rv = get_pages(pages);

        if (rv) {
            size_t diff = actual_size - requested_size;
            g_alloc->page_offset
                = (g_alloc->page_size - diff) % g_alloc->page_size;
            g_alloc->current_page = g_alloc->page_offset
                ? rv + g_alloc->page_size * (pages - 1)
                : NULL;
            rv += sizeof(struct page_header);
        }
    }

    sentry__spinlock_unlock(&g_lock);
    return rv;
}

#if SENTRY_UNITTEST
void
sentry__page_allocator_disable(void)
{
    if (!g_alloc) {
        return;
    }
    struct page_header *next;
    for (struct page_header *cur = g_alloc->last_page; cur; cur = next) {
        next = cur->next;
        munmap(cur, cur->num_pages * g_alloc->page_size);
    }
    g_alloc = NULL;
}
#endif