1/*
2 * Copyright (C) 2008 The Android Open Source Project
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *  * Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 *  * Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in
12 *    the documentation and/or other materials provided with the
13 *    distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29#include <errno.h>
30#include <pthread.h>
31#include <stdlib.h>
32
33#include "private/bionic_macros.h"
34
35struct atfork_t {
36  atfork_t* next;
37  atfork_t* prev;
38
39  void (*prepare)(void);
40  void (*child)(void);
41  void (*parent)(void);
42
43  void* dso_handle;
44};
45
46class atfork_list_t {
47 public:
48  constexpr atfork_list_t() : first_(nullptr), last_(nullptr) {}
49
50  template<typename F>
51  void walk_forward(F f) {
52    for (atfork_t* it = first_; it != nullptr; it = it->next) {
53      f(it);
54    }
55  }
56
57  template<typename F>
58  void walk_backwards(F f) {
59    for (atfork_t* it = last_; it != nullptr; it = it->prev) {
60      f(it);
61    }
62  }
63
64  void push_back(atfork_t* entry) {
65    entry->next = nullptr;
66    entry->prev = last_;
67    if (entry->prev != nullptr) {
68      entry->prev->next = entry;
69    }
70    if (first_ == nullptr) {
71      first_ = entry;
72    }
73    last_ = entry;
74  }
75
76  template<typename F>
77  void remove_if(F predicate) {
78    atfork_t* it = first_;
79    while (it != nullptr) {
80      if (predicate(it)) {
81        atfork_t* entry = it;
82        it = it->next;
83        remove(entry);
84      } else {
85        it = it->next;
86      }
87    }
88  }
89
90 private:
91  void remove(atfork_t* entry) {
92    if (entry->prev != nullptr) {
93      entry->prev->next = entry->next;
94    } else {
95      first_ = entry->next;
96    }
97
98    if (entry->next != nullptr) {
99      entry->next->prev = entry->prev;
100    } else {
101      last_ = entry->prev;
102    }
103
104    free(entry);
105  }
106
107  atfork_t* first_;
108  atfork_t* last_;
109
110  DISALLOW_COPY_AND_ASSIGN(atfork_list_t);
111};
112
113static pthread_mutex_t g_atfork_list_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
114static atfork_list_t g_atfork_list;
115
116void __bionic_atfork_run_prepare() {
117  // We lock the atfork list here, unlock it in the parent, and reset it in the child.
118  // This ensures that nobody can modify the handler array between the calls
119  // to the prepare and parent/child handlers.
120  pthread_mutex_lock(&g_atfork_list_mutex);
121
122  // Call pthread_atfork() prepare handlers. POSIX states that the prepare
123  // handlers should be called in the reverse order of the parent/child
124  // handlers, so we iterate backwards.
125  g_atfork_list.walk_backwards([](atfork_t* it) {
126    if (it->prepare != nullptr) {
127      it->prepare();
128    }
129  });
130}
131
132void __bionic_atfork_run_child() {
133  g_atfork_list.walk_forward([](atfork_t* it) {
134    if (it->child != nullptr) {
135      it->child();
136    }
137  });
138
139  g_atfork_list_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
140}
141
142void __bionic_atfork_run_parent() {
143  g_atfork_list.walk_forward([](atfork_t* it) {
144    if (it->parent != nullptr) {
145      it->parent();
146    }
147  });
148
149  pthread_mutex_unlock(&g_atfork_list_mutex);
150}
151
152// __register_atfork is the name used by glibc
153extern "C" int __register_atfork(void (*prepare)(void), void (*parent)(void),
154                                 void(*child)(void), void* dso) {
155  atfork_t* entry = reinterpret_cast<atfork_t*>(malloc(sizeof(atfork_t)));
156  if (entry == nullptr) {
157    return ENOMEM;
158  }
159
160  entry->prepare = prepare;
161  entry->parent = parent;
162  entry->child = child;
163  entry->dso_handle = dso;
164
165  pthread_mutex_lock(&g_atfork_list_mutex);
166
167  g_atfork_list.push_back(entry);
168
169  pthread_mutex_unlock(&g_atfork_list_mutex);
170
171  return 0;
172}
173
174extern "C" __LIBC_HIDDEN__ void __unregister_atfork(void* dso) {
175  pthread_mutex_lock(&g_atfork_list_mutex);
176  g_atfork_list.remove_if([&](const atfork_t* entry) {
177    return entry->dso_handle == dso;
178  });
179  pthread_mutex_unlock(&g_atfork_list_mutex);
180}
181
182