Branch data Line data Source code
1 : : /* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; -*- */
2 : : // SPDX-License-Identifier: MIT OR LGPL-2.0-or-later
3 : : // SPDX-FileCopyrightText: 2014 Colin Walters <walters@verbum.org>
4 : :
5 : : #ifndef GJS_CONTEXT_PRIVATE_H_
6 : : #define GJS_CONTEXT_PRIVATE_H_
7 : :
8 : : #include <config.h>
9 : :
10 : : #include <stddef.h> // for size_t
11 : : #include <stdint.h>
12 : :
13 : : #include <atomic>
14 : : #include <string>
15 : : #include <thread>
16 : : #include <unordered_map>
17 : : #include <utility> // for pair
18 : : #include <vector>
19 : :
20 : : #include <gio/gio.h> // for GMemoryMonitor
21 : : #include <glib-object.h>
22 : : #include <glib.h>
23 : :
24 : : #include <js/AllocPolicy.h>
25 : : #include <js/Context.h>
26 : : #include <js/GCAPI.h>
27 : : #include <js/GCHashTable.h>
28 : : #include <js/GCVector.h>
29 : : #include <js/HashTable.h> // for DefaultHasher
30 : : #include <js/Promise.h>
31 : : #include <js/Realm.h>
32 : : #include <js/RootingAPI.h>
33 : : #include <js/TypeDecls.h>
34 : : #include <js/UniquePtr.h>
35 : : #include <js/Utility.h> // for UniqueChars, FreePolicy
36 : : #include <js/ValueArray.h>
37 : : #include <jsfriendapi.h> // for ScriptEnvironmentPreparer
38 : :
39 : : #include "gi/closure.h"
40 : : #include "gjs/context.h"
41 : : #include "gjs/jsapi-util.h"
42 : : #include "gjs/jsapi-util-root.h"
43 : : #include "gjs/macros.h"
44 : : #include "gjs/mainloop.h"
45 : : #include "gjs/profiler.h"
46 : : #include "gjs/promise.h"
47 : :
48 : : class GjsAtoms;
49 : : class JSTracer;
50 : :
51 : : using JobQueueStorage =
52 : : JS::GCVector<JS::Heap<JSObject*>, 0, js::SystemAllocPolicy>;
53 : : using ObjectInitList =
54 : : JS::GCVector<JS::Heap<JSObject*>, 0, js::SystemAllocPolicy>;
55 : : using FundamentalTable =
56 : : JS::GCHashMap<void*, Gjs::WeakPtr<JSObject*>, js::DefaultHasher<void*>,
57 : : js::SystemAllocPolicy>;
58 : : using GTypeTable =
59 : : JS::GCHashMap<GType, Gjs::WeakPtr<JSObject*>, js::DefaultHasher<GType>,
60 : : js::SystemAllocPolicy>;
61 : : using FunctionVector = JS::GCVector<JSFunction*, 0, js::SystemAllocPolicy>;
62 : :
63 : : class GjsContextPrivate : public JS::JobQueue {
64 : : public:
65 : : using DestroyNotify = void (*)(JSContext*, void* data);
66 : :
67 : : private:
68 : : GjsContext* m_public_context;
69 : : JSContext* m_cx;
70 : : JS::Heap<JSObject*> m_main_loop_hook;
71 : : JS::Heap<JSObject*> m_global;
72 : : JS::Heap<JSObject*> m_internal_global;
73 : : std::thread::id m_owner_thread;
74 : :
75 : : char* m_program_name;
76 : : char* m_program_path;
77 : :
78 : : char** m_search_path;
79 : :
80 : : unsigned m_auto_gc_id;
81 : :
82 : : GjsAtoms* m_atoms;
83 : :
84 : : std::vector<std::string> m_args;
85 : :
86 : : JobQueueStorage m_job_queue;
87 : : Gjs::PromiseJobDispatcher m_dispatcher;
88 : : Gjs::MainLoop m_main_loop;
89 : : GjsAutoUnref<GMemoryMonitor> m_memory_monitor;
90 : :
91 : : std::vector<std::pair<DestroyNotify, void*>> m_destroy_notifications;
92 : : std::vector<Gjs::Closure::Ptr> m_async_closures;
93 : : std::unordered_map<uint64_t, JS::UniqueChars> m_unhandled_rejection_stacks;
94 : : FunctionVector m_cleanup_tasks;
95 : :
96 : : GjsProfiler* m_profiler;
97 : :
98 : : /* Environment preparer needed for debugger, taken from SpiderMonkey's
99 : : * JS shell */
100 : : struct EnvironmentPreparer final : protected js::ScriptEnvironmentPreparer {
101 : : JSContext* m_cx;
102 : :
103 : 235 : explicit EnvironmentPreparer(JSContext* cx) : m_cx(cx) {
104 : 235 : js::SetScriptEnvironmentPreparer(m_cx, this);
105 : 235 : }
106 : :
107 : : void invoke(JS::HandleObject scope, Closure& closure) override;
108 : : };
109 : : EnvironmentPreparer m_environment_preparer;
110 : :
111 : : // Weak pointer mapping from fundamental native pointer to JSObject
112 : : JS::WeakCache<FundamentalTable>* m_fundamental_table;
113 : : JS::WeakCache<GTypeTable>* m_gtype_table;
114 : :
115 : : // List that holds JSObject GObject wrappers for JS-created classes, from
116 : : // the time of their creation until their GObject instance init function is
117 : : // called
118 : : ObjectInitList m_object_init_list;
119 : :
120 : : uint8_t m_exit_code;
121 : :
122 : : /* flags */
123 : : std::atomic_bool m_destroying = ATOMIC_VAR_INIT(false);
124 : : bool m_should_exit : 1;
125 : : bool m_force_gc : 1;
126 : : bool m_draining_job_queue : 1;
127 : : bool m_should_profile : 1;
128 : : bool m_exec_as_module : 1;
129 : : bool m_unhandled_exception : 1;
130 : : bool m_should_listen_sigusr2 : 1;
131 : :
132 : : void schedule_gc_internal(bool force_gc);
133 : : static gboolean trigger_gc_if_needed(void* data);
134 : : void on_garbage_collection(JSGCStatus, JS::GCReason);
135 : :
136 : : class SavedQueue;
137 : : void start_draining_job_queue(void);
138 : : void stop_draining_job_queue(void);
139 : :
140 : : void warn_about_unhandled_promise_rejections();
141 : :
142 : : GJS_JSAPI_RETURN_CONVENTION bool run_main_loop_hook();
143 : : [[nodiscard]] bool handle_exit_code(bool no_sync_error_pending,
144 : : const char* source_type,
145 : : const char* identifier,
146 : : uint8_t* exit_code, GError** error);
147 : : [[nodiscard]] bool auto_profile_enter(void);
148 : : void auto_profile_exit(bool status);
149 : :
150 : : class AutoResetExit {
151 : : GjsContextPrivate* m_self;
152 : :
153 : : public:
154 : 347 : explicit AutoResetExit(GjsContextPrivate* self) { m_self = self; }
155 : 345 : ~AutoResetExit() {
156 : 345 : m_self->m_should_exit = false;
157 : 345 : m_self->m_exit_code = 0;
158 : 345 : }
159 : : };
160 : :
161 : : public:
162 : : /* Retrieving a GjsContextPrivate from JSContext or GjsContext */
163 : 134496 : [[nodiscard]] static GjsContextPrivate* from_cx(JSContext* cx) {
164 : 134496 : return static_cast<GjsContextPrivate*>(JS_GetContextPrivate(cx));
165 : : }
166 : : [[nodiscard]] static GjsContextPrivate* from_object(
167 : : GObject* public_context);
168 : : [[nodiscard]] static GjsContextPrivate* from_object(
169 : : GjsContext* public_context);
170 : : [[nodiscard]] static GjsContextPrivate* from_current_context();
171 : :
172 : : GjsContextPrivate(JSContext* cx, GjsContext* public_context);
173 : : ~GjsContextPrivate(void);
174 : :
175 : : /* Accessors */
176 : : [[nodiscard]] GjsContext* public_context() const {
177 : : return m_public_context;
178 : : }
179 : : [[nodiscard]] bool set_main_loop_hook(JSObject* callable);
180 : 690 : [[nodiscard]] bool has_main_loop_hook() { return !!m_main_loop_hook; }
181 : 26087 : [[nodiscard]] JSContext* context() const { return m_cx; }
182 : 12318 : [[nodiscard]] JSObject* global() const { return m_global.get(); }
183 : 470 : [[nodiscard]] JSObject* internal_global() const {
184 : 470 : return m_internal_global.get();
185 : : }
186 : 387 : void main_loop_hold() { m_main_loop.hold(); }
187 : 384 : void main_loop_release() { m_main_loop.release(); }
188 : 2210 : [[nodiscard]] GjsProfiler* profiler() const { return m_profiler; }
189 : 20445 : [[nodiscard]] const GjsAtoms& atoms() const { return *m_atoms; }
190 : 3879 : [[nodiscard]] bool destroying() const { return m_destroying.load(); }
191 : 71 : [[nodiscard]] const char* program_name() const { return m_program_name; }
192 : 235 : void set_program_name(char* value) { m_program_name = value; }
193 : 71 : GJS_USE const char* program_path(void) const { return m_program_path; }
194 : 235 : void set_program_path(char* value) { m_program_path = value; }
195 : 235 : void set_search_path(char** value) { m_search_path = value; }
196 : 235 : void set_should_profile(bool value) { m_should_profile = value; }
197 : 235 : void set_execute_as_module(bool value) { m_exec_as_module = value; }
198 : 235 : void set_should_listen_sigusr2(bool value) {
199 : 235 : m_should_listen_sigusr2 = value;
200 : 235 : }
201 : : void set_args(std::vector<std::string>&& args);
202 : : GJS_JSAPI_RETURN_CONVENTION JSObject* build_args_array();
203 : 3304 : [[nodiscard]] bool is_owner_thread() const {
204 : 3304 : return m_owner_thread == std::this_thread::get_id();
205 : : }
206 : 0 : [[nodiscard]] JS::WeakCache<FundamentalTable>& fundamental_table() {
207 : 0 : return *m_fundamental_table;
208 : : }
209 : 5643 : [[nodiscard]] JS::WeakCache<GTypeTable>& gtype_table() {
210 : 5643 : return *m_gtype_table;
211 : : }
212 : 2485 : [[nodiscard]] ObjectInitList& object_init_list() {
213 : 2485 : return m_object_init_list;
214 : : }
215 : 67167 : [[nodiscard]] static const GjsAtoms& atoms(JSContext* cx) {
216 : 67167 : return *(from_cx(cx)->m_atoms);
217 : : }
218 : : [[nodiscard]] static JSObject* global(JSContext* cx) {
219 : : return from_cx(cx)->global();
220 : : }
221 : :
222 : : [[nodiscard]] bool eval(const char* script, size_t script_len,
223 : : const char* filename, int* exit_status_p,
224 : : GError** error);
225 : : GJS_JSAPI_RETURN_CONVENTION
226 : : bool eval_with_scope(JS::HandleObject scope_object, const char* script,
227 : : size_t script_len, const char* filename,
228 : : JS::MutableHandleValue retval);
229 : : [[nodiscard]] bool eval_module(const char* identifier, uint8_t* exit_code_p,
230 : : GError** error);
231 : : GJS_JSAPI_RETURN_CONVENTION
232 : : bool call_function(JS::HandleObject this_obj, JS::HandleValue func_val,
233 : : const JS::HandleValueArray& args,
234 : : JS::MutableHandleValue rval);
235 : :
236 : 1420 : void schedule_gc(void) { schedule_gc_internal(true); }
237 : : void schedule_gc_if_needed(void);
238 : :
239 : 1 : void report_unhandled_exception() { m_unhandled_exception = true; }
240 : : void exit(uint8_t exit_code);
241 : : [[nodiscard]] bool should_exit(uint8_t* exit_code_p) const;
242 : : [[noreturn]] void exit_immediately(uint8_t exit_code);
243 : :
244 : : // Implementations of JS::JobQueue virtual functions
245 : : GJS_JSAPI_RETURN_CONVENTION
246 : : JSObject* getIncumbentGlobal(JSContext* cx) override;
247 : : GJS_JSAPI_RETURN_CONVENTION
248 : : bool enqueuePromiseJob(JSContext* cx, JS::HandleObject promise,
249 : : JS::HandleObject job,
250 : : JS::HandleObject allocation_site,
251 : : JS::HandleObject incumbent_global) override;
252 : : void runJobs(JSContext* cx) override;
253 : 7891 : [[nodiscard]] bool empty() const override { return m_job_queue.empty(); }
254 : 2606 : [[nodiscard]] bool isDrainingStopped() const override {
255 : 2606 : return !m_draining_job_queue;
256 : : }
257 : : js::UniquePtr<JS::JobQueue::SavedJobQueue> saveJobQueue(
258 : : JSContext* cx) override;
259 : :
260 : : GJS_JSAPI_RETURN_CONVENTION bool run_jobs_fallible();
261 : : void register_unhandled_promise_rejection(uint64_t id,
262 : : JS::UniqueChars&& stack);
263 : : void unregister_unhandled_promise_rejection(uint64_t id);
264 : : GJS_JSAPI_RETURN_CONVENTION bool queue_finalization_registry_cleanup(
265 : : JSFunction* cleanup_task);
266 : : GJS_JSAPI_RETURN_CONVENTION bool run_finalization_registry_cleanup();
267 : :
268 : : void register_notifier(DestroyNotify notify_func, void* data);
269 : : void unregister_notifier(DestroyNotify notify_func, void* data);
270 : : void async_closure_enqueue_for_gc(Gjs::Closure*);
271 : :
272 : : [[nodiscard]] bool register_module(const char* identifier,
273 : : const char* filename, GError** error);
274 : :
275 : : static void trace(JSTracer* trc, void* data);
276 : :
277 : : void free_profiler(void);
278 : : void dispose(void);
279 : : };
280 : :
281 : : std::string gjs_dumpstack_string();
282 : :
283 : : namespace Gjs {
284 : : class AutoMainRealm : public JSAutoRealm {
285 : : public:
286 : : explicit AutoMainRealm(GjsContextPrivate* gjs);
287 : : explicit AutoMainRealm(JSContext* cx);
288 : : };
289 : :
290 : : class AutoInternalRealm : public JSAutoRealm {
291 : : public:
292 : : explicit AutoInternalRealm(GjsContextPrivate* gjs);
293 : : explicit AutoInternalRealm(JSContext* cx);
294 : : };
295 : : } // namespace Gjs
296 : :
297 : : #endif // GJS_CONTEXT_PRIVATE_H_
|
