Bug Summary

File:var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp
Warning:line 1546, column 5
Value stored to 'srv' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name mozStorageConnection.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -ffp-contract=off -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/storage -fcoverage-compilation-dir=/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/storage -resource-dir /usr/lib/llvm-19/lib/clang/19 -include /var/lib/jenkins/workspace/firefox-scan-build/config/gcc_hidden.h -include /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/mozilla-config.h -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/stl_wrappers -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/system_wrappers -U _FORTIFY_SOURCE -D _FORTIFY_SOURCE=2 -D DEBUG=1 -D MOZ_SQLITE_PERSIST_AUXILIARY_FILES=1 -D MOZ_HAS_MOZGLUE -D MOZILLA_INTERNAL_API -D IMPL_LIBXUL -D MOZ_SUPPORT_LEAKCHECKING -D STATIC_EXPORTABLE_JS_API -I /var/lib/jenkins/workspace/firefox-scan-build/storage -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/storage -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders -I /var/lib/jenkins/workspace/firefox-scan-build/ipc/chromium/src -I /var/lib/jenkins/workspace/firefox-scan-build/dom/base -I /var/lib/jenkins/workspace/firefox-scan-build/third_party/sqlite3/src -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/nspr -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/nss -D MOZILLA_CLIENT -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/x86_64-linux-gnu/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14/backward -internal-isystem /usr/lib/llvm-19/lib/clang/19/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-error=tautological-type-limit-compare -Wno-invalid-offsetof -Wno-range-loop-analysis -Wno-deprecated-anon-enum-enum-conversion -Wno-deprecated-enum-enum-conversion -Wno-deprecated-this-capture -Wno-inline-new-delete -Wno-error=deprecated-declarations -Wno-error=array-bounds -Wno-error=free-nonheap-object -Wno-error=atomic-alignment -Wno-error=deprecated-builtins -Wno-psabi -Wno-error=builtin-macro-redefined -Wno-vla-cxx-extension -Wno-unknown-warning-option -fdeprecated-macro -ferror-limit 19 -fstrict-flex-arrays=1 -stack-protector 2 -fstack-clash-protection -ftrivial-auto-var-init=pattern -fno-rtti -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fno-sized-deallocation -fno-aligned-allocation -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2024-09-22-115206-3586786-1 -x c++ /var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp
1/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2 * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
3 * This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6
7#include "BaseVFS.h"
8#include "ErrorList.h"
9#include "nsError.h"
10#include "nsThreadUtils.h"
11#include "nsIFile.h"
12#include "nsIFileURL.h"
13#include "nsIXPConnect.h"
14#include "mozilla/AppShutdown.h"
15#include "mozilla/CheckedInt.h"
16#include "mozilla/Telemetry.h"
17#include "mozilla/Mutex.h"
18#include "mozilla/CondVar.h"
19#include "mozilla/Attributes.h"
20#include "mozilla/ErrorNames.h"
21#include "mozilla/Unused.h"
22#include "mozilla/dom/quota/QuotaObject.h"
23#include "mozilla/ScopeExit.h"
24#include "mozilla/SpinEventLoopUntil.h"
25#include "mozilla/StaticPrefs_storage.h"
26
27#include "mozIStorageCompletionCallback.h"
28#include "mozIStorageFunction.h"
29
30#include "mozStorageAsyncStatementExecution.h"
31#include "mozStorageSQLFunctions.h"
32#include "mozStorageConnection.h"
33#include "mozStorageService.h"
34#include "mozStorageStatement.h"
35#include "mozStorageAsyncStatement.h"
36#include "mozStorageArgValueArray.h"
37#include "mozStoragePrivateHelpers.h"
38#include "mozStorageStatementData.h"
39#include "ObfuscatingVFS.h"
40#include "QuotaVFS.h"
41#include "StorageBaseStatementInternal.h"
42#include "SQLCollations.h"
43#include "FileSystemModule.h"
44#include "mozStorageHelper.h"
45
46#include "mozilla/Assertions.h"
47#include "mozilla/Logging.h"
48#include "mozilla/Printf.h"
49#include "mozilla/ProfilerLabels.h"
50#include "mozilla/RefPtr.h"
51#include "nsComponentManagerUtils.h"
52#include "nsProxyRelease.h"
53#include "nsStringFwd.h"
54#include "nsURLHelper.h"
55
56#define MIN_AVAILABLE_BYTES_PER_CHUNKED_GROWTH524288000 524288000 // 500 MiB
57
58// Maximum size of the pages cache per connection.
59#define MAX_CACHE_SIZE_KIBIBYTES2048 2048 // 2 MiB
60
61mozilla::LazyLogModule gStorageLog("mozStorage");
62
63// Checks that the protected code is running on the main-thread only if the
64// connection was also opened on it.
65#ifdef DEBUG1
66# define CHECK_MAINTHREAD_ABUSE()do { do { if (!(eventTargetOpenedOn == GetMainThreadSerialEventTarget
() || !NS_IsMainThread())) { NS_DebugBreak(NS_DEBUG_WARNING, "Using Storage synchronous API on main-thread, but "
"the connection was opened on another thread.", "eventTargetOpenedOn == GetMainThreadSerialEventTarget() || !NS_IsMainThread()"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 66); } } while (false); } while (0)
\
67 do { \
68 NS_WARNING_ASSERTION( \do { if (!(eventTargetOpenedOn == GetMainThreadSerialEventTarget
() || !NS_IsMainThread())) { NS_DebugBreak(NS_DEBUG_WARNING, "Using Storage synchronous API on main-thread, but "
"the connection was opened on another thread.", "eventTargetOpenedOn == GetMainThreadSerialEventTarget() || !NS_IsMainThread()"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 72); } } while (false)
69 eventTargetOpenedOn == GetMainThreadSerialEventTarget() || \do { if (!(eventTargetOpenedOn == GetMainThreadSerialEventTarget
() || !NS_IsMainThread())) { NS_DebugBreak(NS_DEBUG_WARNING, "Using Storage synchronous API on main-thread, but "
"the connection was opened on another thread.", "eventTargetOpenedOn == GetMainThreadSerialEventTarget() || !NS_IsMainThread()"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 72); } } while (false)
70 !NS_IsMainThread(), \do { if (!(eventTargetOpenedOn == GetMainThreadSerialEventTarget
() || !NS_IsMainThread())) { NS_DebugBreak(NS_DEBUG_WARNING, "Using Storage synchronous API on main-thread, but "
"the connection was opened on another thread.", "eventTargetOpenedOn == GetMainThreadSerialEventTarget() || !NS_IsMainThread()"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 72); } } while (false)
71 "Using Storage synchronous API on main-thread, but " \do { if (!(eventTargetOpenedOn == GetMainThreadSerialEventTarget
() || !NS_IsMainThread())) { NS_DebugBreak(NS_DEBUG_WARNING, "Using Storage synchronous API on main-thread, but "
"the connection was opened on another thread.", "eventTargetOpenedOn == GetMainThreadSerialEventTarget() || !NS_IsMainThread()"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 72); } } while (false)
72 "the connection was opened on another thread.")do { if (!(eventTargetOpenedOn == GetMainThreadSerialEventTarget
() || !NS_IsMainThread())) { NS_DebugBreak(NS_DEBUG_WARNING, "Using Storage synchronous API on main-thread, but "
"the connection was opened on another thread.", "eventTargetOpenedOn == GetMainThreadSerialEventTarget() || !NS_IsMainThread()"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 72); } } while (false)
; \
73 } while (0)
74#else
75# define CHECK_MAINTHREAD_ABUSE()do { do { if (!(eventTargetOpenedOn == GetMainThreadSerialEventTarget
() || !NS_IsMainThread())) { NS_DebugBreak(NS_DEBUG_WARNING, "Using Storage synchronous API on main-thread, but "
"the connection was opened on another thread.", "eventTargetOpenedOn == GetMainThreadSerialEventTarget() || !NS_IsMainThread()"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 75); } } while (false); } while (0)
\
76 do { /* Nothing */ \
77 } while (0)
78#endif
79
80namespace mozilla::storage {
81
82using mozilla::dom::quota::QuotaObject;
83using mozilla::Telemetry::AccumulateCategoricalKeyed;
84using mozilla::Telemetry::LABELS_SQLITE_STORE_OPEN;
85using mozilla::Telemetry::LABELS_SQLITE_STORE_QUERY;
86
87namespace {
88
89int nsresultToSQLiteResult(nsresult aXPCOMResultCode) {
90 if (NS_SUCCEEDED(aXPCOMResultCode)((bool)(__builtin_expect(!!(!NS_FAILED_impl(aXPCOMResultCode)
), 1)))
) {
91 return SQLITE_OK0;
92 }
93
94 switch (aXPCOMResultCode) {
95 case NS_ERROR_FILE_CORRUPTED:
96 return SQLITE_CORRUPT11;
97 case NS_ERROR_FILE_ACCESS_DENIED:
98 return SQLITE_CANTOPEN14;
99 case NS_ERROR_STORAGE_BUSY:
100 return SQLITE_BUSY5;
101 case NS_ERROR_FILE_IS_LOCKED:
102 return SQLITE_LOCKED6;
103 case NS_ERROR_FILE_READ_ONLY:
104 return SQLITE_READONLY8;
105 case NS_ERROR_STORAGE_IOERR:
106 return SQLITE_IOERR10;
107 case NS_ERROR_FILE_NO_DEVICE_SPACE:
108 return SQLITE_FULL13;
109 case NS_ERROR_OUT_OF_MEMORY:
110 return SQLITE_NOMEM7;
111 case NS_ERROR_UNEXPECTED:
112 return SQLITE_MISUSE21;
113 case NS_ERROR_ABORT:
114 return SQLITE_ABORT4;
115 case NS_ERROR_STORAGE_CONSTRAINT:
116 return SQLITE_CONSTRAINT19;
117 default:
118 return SQLITE_ERROR1;
119 }
120
121 MOZ_MAKE_COMPILER_ASSUME_IS_UNREACHABLE("Must return in switch above!")do { do { static_assert( mozilla::detail::AssertionConditionType
<decltype(false)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("false" " (" "MOZ_ASSERT_UNREACHABLE: "
"Must return in switch above!" ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 121); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") ("
"MOZ_ASSERT_UNREACHABLE: " "Must return in switch above!" ")"
); do { *((volatile int*)__null) = 121; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); __builtin_unreachable
(); } while (false)
;
122}
123
124////////////////////////////////////////////////////////////////////////////////
125//// Variant Specialization Functions (variantToSQLiteT)
126
127int sqlite3_T_int(sqlite3_context* aCtx, int aValue) {
128 ::sqlite3_result_int(aCtx, aValue);
129 return SQLITE_OK0;
130}
131
132int sqlite3_T_int64(sqlite3_context* aCtx, sqlite3_int64 aValue) {
133 ::sqlite3_result_int64(aCtx, aValue);
134 return SQLITE_OK0;
135}
136
137int sqlite3_T_double(sqlite3_context* aCtx, double aValue) {
138 ::sqlite3_result_double(aCtx, aValue);
139 return SQLITE_OK0;
140}
141
142int sqlite3_T_text(sqlite3_context* aCtx, const nsCString& aValue) {
143 CheckedInt<int32_t> length(aValue.Length());
144 if (!length.isValid()) {
145 return SQLITE_MISUSE21;
146 }
147 ::sqlite3_result_text(aCtx, aValue.get(), length.value(), SQLITE_TRANSIENT((sqlite3_destructor_type)-1));
148 return SQLITE_OK0;
149}
150
151int sqlite3_T_text16(sqlite3_context* aCtx, const nsString& aValue) {
152 CheckedInt<int32_t> n_bytes =
153 CheckedInt<int32_t>(aValue.Length()) * sizeof(char16_t);
154 if (!n_bytes.isValid()) {
155 return SQLITE_MISUSE21;
156 }
157 ::sqlite3_result_text16(aCtx, aValue.get(), n_bytes.value(),
158 SQLITE_TRANSIENT((sqlite3_destructor_type)-1));
159 return SQLITE_OK0;
160}
161
162int sqlite3_T_null(sqlite3_context* aCtx) {
163 ::sqlite3_result_null(aCtx);
164 return SQLITE_OK0;
165}
166
167int sqlite3_T_blob(sqlite3_context* aCtx, const void* aData, int aSize) {
168 ::sqlite3_result_blob(aCtx, aData, aSize, free);
169 return SQLITE_OK0;
170}
171
172#include "variantToSQLiteT_impl.h"
173
174////////////////////////////////////////////////////////////////////////////////
175//// Modules
176
177struct Module {
178 const char* name;
179 int (*registerFunc)(sqlite3*, const char*);
180};
181
182Module gModules[] = {{"filesystem", RegisterFileSystemModule}};
183
184////////////////////////////////////////////////////////////////////////////////
185//// Local Functions
186
187int tracefunc(unsigned aReason, void* aClosure, void* aP, void* aX) {
188 switch (aReason) {
189 case SQLITE_TRACE_STMT0x01: {
190 // aP is a pointer to the prepared statement.
191 sqlite3_stmt* stmt = static_cast<sqlite3_stmt*>(aP);
192 // aX is a pointer to a string containing the unexpanded SQL or a comment,
193 // starting with "--"" in case of a trigger.
194 char* expanded = static_cast<char*>(aX);
195 // Simulate what sqlite_trace was doing.
196 if (!::strncmp(expanded, "--", 2)) {
197 MOZ_LOG(gStorageLog, LogLevel::Debug,do { const ::mozilla::LogModule* moz_real_module = gStorageLog
; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Debug)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Debug, "TRACE_STMT on %p: '%s'", aClosure, expanded
); } } while (0)
198 ("TRACE_STMT on %p: '%s'", aClosure, expanded))do { const ::mozilla::LogModule* moz_real_module = gStorageLog
; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Debug)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Debug, "TRACE_STMT on %p: '%s'", aClosure, expanded
); } } while (0)
;
199 } else {
200 char* sql = ::sqlite3_expanded_sql(stmt);
201 MOZ_LOG(gStorageLog, LogLevel::Debug,do { const ::mozilla::LogModule* moz_real_module = gStorageLog
; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Debug)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Debug, "TRACE_STMT on %p: '%s'", aClosure, sql); }
} while (0)
202 ("TRACE_STMT on %p: '%s'", aClosure, sql))do { const ::mozilla::LogModule* moz_real_module = gStorageLog
; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Debug)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Debug, "TRACE_STMT on %p: '%s'", aClosure, sql); }
} while (0)
;
203 ::sqlite3_free(sql);
204 }
205 break;
206 }
207 case SQLITE_TRACE_PROFILE0x02: {
208 // aX is pointer to a 64bit integer containing nanoseconds it took to
209 // execute the last command.
210 sqlite_int64 time = *(static_cast<sqlite_int64*>(aX)) / 1000000;
211 if (time > 0) {
212 MOZ_LOG(gStorageLog, LogLevel::Debug,do { const ::mozilla::LogModule* moz_real_module = gStorageLog
; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Debug)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Debug, "TRACE_TIME on %p: %lldms", aClosure, time
); } } while (0)
213 ("TRACE_TIME on %p: %lldms", aClosure, time))do { const ::mozilla::LogModule* moz_real_module = gStorageLog
; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Debug)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Debug, "TRACE_TIME on %p: %lldms", aClosure, time
); } } while (0)
;
214 }
215 break;
216 }
217 }
218 return 0;
219}
220
221void basicFunctionHelper(sqlite3_context* aCtx, int aArgc,
222 sqlite3_value** aArgv) {
223 void* userData = ::sqlite3_user_data(aCtx);
224
225 mozIStorageFunction* func = static_cast<mozIStorageFunction*>(userData);
226
227 RefPtr<ArgValueArray> arguments(new ArgValueArray(aArgc, aArgv));
228 if (!arguments) return;
229
230 nsCOMPtr<nsIVariant> result;
231 nsresult rv = func->OnFunctionCall(arguments, getter_AddRefs(result));
232 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
233 nsAutoCString errorMessage;
234 GetErrorName(rv, errorMessage);
235 errorMessage.InsertLiteral("User function returned ", 0);
236 errorMessage.Append('!');
237
238 NS_WARNING(errorMessage.get())NS_DebugBreak(NS_DEBUG_WARNING, errorMessage.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 238)
;
239
240 ::sqlite3_result_error(aCtx, errorMessage.get(), -1);
241 ::sqlite3_result_error_code(aCtx, nsresultToSQLiteResult(rv));
242 return;
243 }
244 int retcode = variantToSQLiteT(aCtx, result);
245 if (retcode != SQLITE_OK0) {
246 NS_WARNING("User function returned invalid data type!")NS_DebugBreak(NS_DEBUG_WARNING, "User function returned invalid data type!"
, nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 246)
;
247 ::sqlite3_result_error(aCtx, "User function returned invalid data type",
248 -1);
249 }
250}
251
252RefPtr<QuotaObject> GetQuotaObject(sqlite3_file* aFile, bool obfuscatingVFS) {
253 return obfuscatingVFS
254 ? mozilla::storage::obfsvfs::GetQuotaObjectForFile(aFile)
255 : mozilla::storage::quotavfs::GetQuotaObjectForFile(aFile);
256}
257
258/**
259 * This code is heavily based on the sample at:
260 * http://www.sqlite.org/unlock_notify.html
261 */
262class UnlockNotification {
263 public:
264 UnlockNotification()
265 : mMutex("UnlockNotification mMutex"),
266 mCondVar(mMutex, "UnlockNotification condVar"),
267 mSignaled(false) {}
268
269 void Wait() {
270 MutexAutoLock lock(mMutex);
271 while (!mSignaled) {
272 (void)mCondVar.Wait();
273 }
274 }
275
276 void Signal() {
277 MutexAutoLock lock(mMutex);
278 mSignaled = true;
279 (void)mCondVar.Notify();
280 }
281
282 private:
283 Mutex mMutex MOZ_UNANNOTATED;
284 CondVar mCondVar;
285 bool mSignaled;
286};
287
288void UnlockNotifyCallback(void** aArgs, int aArgsSize) {
289 for (int i = 0; i < aArgsSize; i++) {
290 UnlockNotification* notification =
291 static_cast<UnlockNotification*>(aArgs[i]);
292 notification->Signal();
293 }
294}
295
296int WaitForUnlockNotify(sqlite3* aDatabase) {
297 UnlockNotification notification;
298 int srv =
299 ::sqlite3_unlock_notify(aDatabase, UnlockNotifyCallback, &notification);
300 MOZ_ASSERT(srv == SQLITE_LOCKED || srv == SQLITE_OK)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(srv == 6 || srv == 0)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(srv == 6 || srv == 0))), 0))
) { do { } while (false); MOZ_ReportAssertionFailure("srv == 6 || srv == 0"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 300); AnnotateMozCrashReason("MOZ_ASSERT" "(" "srv == 6 || srv == 0"
")"); do { *((volatile int*)__null) = 300; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
301 if (srv == SQLITE_OK0) {
302 notification.Wait();
303 }
304
305 return srv;
306}
307
308////////////////////////////////////////////////////////////////////////////////
309//// Local Classes
310
311class AsyncCloseConnection final : public Runnable {
312 public:
313 AsyncCloseConnection(Connection* aConnection, sqlite3* aNativeConnection,
314 nsIRunnable* aCallbackEvent)
315 : Runnable("storage::AsyncCloseConnection"),
316 mConnection(aConnection),
317 mNativeConnection(aNativeConnection),
318 mCallbackEvent(aCallbackEvent) {}
319
320 NS_IMETHODvirtual nsresult Run() override {
321 // Make sure we don't dispatch to the current thread.
322 MOZ_ASSERT(!IsOnCurrentSerialEventTarget(mConnection->eventTargetOpenedOn))do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!IsOnCurrentSerialEventTarget(mConnection->eventTargetOpenedOn
))>::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(!IsOnCurrentSerialEventTarget(mConnection->eventTargetOpenedOn
)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("!IsOnCurrentSerialEventTarget(mConnection->eventTargetOpenedOn)"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 322); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!IsOnCurrentSerialEventTarget(mConnection->eventTargetOpenedOn)"
")"); do { *((volatile int*)__null) = 322; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
323
324 nsCOMPtr<nsIRunnable> event =
325 NewRunnableMethod("storage::Connection::shutdownAsyncThread",
326 mConnection, &Connection::shutdownAsyncThread);
327 MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(event))do { if ((__builtin_expect(!!(((bool)(__builtin_expect(!!(!NS_FAILED_impl
(NS_DispatchToMainThread(event))), 1)))), 1))) { } else { do {
static_assert( mozilla::detail::AssertionConditionType<decltype
(false)>::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(false))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("false" " (" "NS_SUCCEEDED(NS_DispatchToMainThread(event))" ")"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 327); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "NS_SUCCEEDED(NS_DispatchToMainThread(event))" ")"); do
{ *((volatile int*)__null) = 327; __attribute__((nomerge)) ::
abort(); } while (false); } } while (false); } } while (false
)
;
328
329 // Internal close.
330 (void)mConnection->internalClose(mNativeConnection);
331
332 // Callback
333 if (mCallbackEvent) {
334 nsCOMPtr<nsIThread> thread;
335 (void)NS_GetMainThread(getter_AddRefs(thread));
336 (void)thread->Dispatch(mCallbackEvent, NS_DISPATCH_NORMALnsIEventTarget::DISPATCH_NORMAL);
337 }
338
339 return NS_OK;
340 }
341
342 ~AsyncCloseConnection() override {
343 NS_ReleaseOnMainThread("AsyncCloseConnection::mConnection",
344 mConnection.forget());
345 NS_ReleaseOnMainThread("AsyncCloseConnection::mCallbackEvent",
346 mCallbackEvent.forget());
347 }
348
349 private:
350 RefPtr<Connection> mConnection;
351 sqlite3* mNativeConnection;
352 nsCOMPtr<nsIRunnable> mCallbackEvent;
353};
354
355/**
356 * An event used to initialize the clone of a connection.
357 *
358 * Must be executed on the clone's async execution thread.
359 */
360class AsyncInitializeClone final : public Runnable {
361 public:
362 /**
363 * @param aConnection The connection being cloned.
364 * @param aClone The clone.
365 * @param aReadOnly If |true|, the clone is read only.
366 * @param aCallback A callback to trigger once initialization
367 * is complete. This event will be called on
368 * aClone->eventTargetOpenedOn.
369 */
370 AsyncInitializeClone(Connection* aConnection, Connection* aClone,
371 const bool aReadOnly,
372 mozIStorageCompletionCallback* aCallback)
373 : Runnable("storage::AsyncInitializeClone"),
374 mConnection(aConnection),
375 mClone(aClone),
376 mReadOnly(aReadOnly),
377 mCallback(aCallback) {
378 MOZ_ASSERT(NS_IsMainThread())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(NS_IsMainThread())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(NS_IsMainThread()))), 0))) {
do { } while (false); MOZ_ReportAssertionFailure("NS_IsMainThread()"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 378); AnnotateMozCrashReason("MOZ_ASSERT" "(" "NS_IsMainThread()"
")"); do { *((volatile int*)__null) = 378; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
379 }
380
381 NS_IMETHODvirtual nsresult Run() override {
382 MOZ_ASSERT(!NS_IsMainThread())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!NS_IsMainThread())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!NS_IsMainThread()))), 0))) {
do { } while (false); MOZ_ReportAssertionFailure("!NS_IsMainThread()"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 382); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!NS_IsMainThread()"
")"); do { *((volatile int*)__null) = 382; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
383 nsresult rv = mConnection->initializeClone(mClone, mReadOnly);
384 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
385 return Dispatch(rv, nullptr);
386 }
387 return Dispatch(NS_OK,
388 NS_ISUPPORTS_CAST(mozIStorageAsyncConnection*, mClone)static_cast<nsISupports*>(static_cast<mozIStorageAsyncConnection
*>(mClone))
);
389 }
390
391 private:
392 nsresult Dispatch(nsresult aResult, nsISupports* aValue) {
393 RefPtr<CallbackComplete> event =
394 new CallbackComplete(aResult, aValue, mCallback.forget());
395 return mClone->eventTargetOpenedOn->Dispatch(event, NS_DISPATCH_NORMALnsIEventTarget::DISPATCH_NORMAL);
396 }
397
398 ~AsyncInitializeClone() override {
399 nsCOMPtr<nsIThread> thread;
400 DebugOnly<nsresult> rv = NS_GetMainThread(getter_AddRefs(thread));
401 MOZ_ASSERT(NS_SUCCEEDED(rv))do { static_assert( mozilla::detail::AssertionConditionType<
decltype(((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1)
)))>::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1)
))))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1)))", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 401); AnnotateMozCrashReason("MOZ_ASSERT" "(" "((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1)))"
")"); do { *((volatile int*)__null) = 401; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
402
403 // Handle ambiguous nsISupports inheritance.
404 NS_ProxyRelease("AsyncInitializeClone::mConnection", thread,
405 mConnection.forget());
406 NS_ProxyRelease("AsyncInitializeClone::mClone", thread, mClone.forget());
407
408 // Generally, the callback will be released by CallbackComplete.
409 // However, if for some reason Run() is not executed, we still
410 // need to ensure that it is released here.
411 NS_ProxyRelease("AsyncInitializeClone::mCallback", thread,
412 mCallback.forget());
413 }
414
415 RefPtr<Connection> mConnection;
416 RefPtr<Connection> mClone;
417 const bool mReadOnly;
418 nsCOMPtr<mozIStorageCompletionCallback> mCallback;
419};
420
421/**
422 * A listener for async connection closing.
423 */
424class CloseListener final : public mozIStorageCompletionCallback {
425 public:
426 NS_DECL_ISUPPORTSpublic: virtual nsresult QueryInterface(const nsIID& aIID
, void** aInstancePtr) override; virtual MozExternalRefCountType
AddRef(void) override; virtual MozExternalRefCountType Release
(void) override; using HasThreadSafeRefCnt = std::false_type;
protected: nsAutoRefCnt mRefCnt; nsAutoOwningThread _mOwningThread
; public:
427 CloseListener() : mClosed(false) {}
428
429 NS_IMETHODvirtual nsresult Complete(nsresult, nsISupports*) override {
430 mClosed = true;
431 return NS_OK;
432 }
433
434 bool mClosed;
435
436 private:
437 ~CloseListener() = default;
438};
439
440NS_IMPL_ISUPPORTS(CloseListener, mozIStorageCompletionCallback)MozExternalRefCountType CloseListener::AddRef(void) { static_assert
(!std::is_destructible_v<CloseListener>, "Reference-counted class "
"CloseListener" " should not have a public destructor. " "Make this class's destructor non-public"
); do { static_assert( mozilla::detail::AssertionConditionType
<decltype(int32_t(mRefCnt) >= 0)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(int32_t(mRefCnt) >= 0))),
0))) { do { } while (false); MOZ_ReportAssertionFailure("int32_t(mRefCnt) >= 0"
" (" "illegal refcnt" ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 440); AnnotateMozCrashReason("MOZ_ASSERT" "(" "int32_t(mRefCnt) >= 0"
") (" "illegal refcnt" ")"); do { *((volatile int*)__null) =
440; __attribute__((nomerge)) ::abort(); } while (false); } }
while (false); do { static_assert( mozilla::detail::AssertionConditionType
<decltype("CloseListener" != nullptr)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!("CloseListener" != nullptr))
), 0))) { do { } while (false); MOZ_ReportAssertionFailure("\"CloseListener\" != nullptr"
" (" "Must specify a name" ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 440); AnnotateMozCrashReason("MOZ_ASSERT" "(" "\"CloseListener\" != nullptr"
") (" "Must specify a name" ")"); do { *((volatile int*)__null
) = 440; __attribute__((nomerge)) ::abort(); } while (false);
} } while (false); if (!mRefCnt.isThreadSafe) _mOwningThread
.AssertOwnership("CloseListener" " not thread-safe"); nsrefcnt
count = ++mRefCnt; NS_LogAddRef((this), (count), ("CloseListener"
), (uint32_t)(sizeof(*this))); return count; } MozExternalRefCountType
CloseListener::Release(void) { do { static_assert( mozilla::
detail::AssertionConditionType<decltype(int32_t(mRefCnt) >
0)>::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(int32_t(mRefCnt) > 0))), 0))) { do { } while (false
); MOZ_ReportAssertionFailure("int32_t(mRefCnt) > 0" " (" "dup release"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 440); AnnotateMozCrashReason("MOZ_ASSERT" "(" "int32_t(mRefCnt) > 0"
") (" "dup release" ")"); do { *((volatile int*)__null) = 440
; __attribute__((nomerge)) ::abort(); } while (false); } } while
(false); do { static_assert( mozilla::detail::AssertionConditionType
<decltype("CloseListener" != nullptr)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!("CloseListener" != nullptr))
), 0))) { do { } while (false); MOZ_ReportAssertionFailure("\"CloseListener\" != nullptr"
" (" "Must specify a name" ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 440); AnnotateMozCrashReason("MOZ_ASSERT" "(" "\"CloseListener\" != nullptr"
") (" "Must specify a name" ")"); do { *((volatile int*)__null
) = 440; __attribute__((nomerge)) ::abort(); } while (false);
} } while (false); if (!mRefCnt.isThreadSafe) _mOwningThread
.AssertOwnership("CloseListener" " not thread-safe"); const char
* const nametmp = "CloseListener"; nsrefcnt count = --mRefCnt
; NS_LogRelease((this), (count), (nametmp)); if (count == 0) {
mRefCnt = 1; delete (this); return 0; } return count; } nsresult
CloseListener::QueryInterface(const nsIID& aIID, void** aInstancePtr
) { do { if (!(aInstancePtr)) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "QueryInterface requires a non-NULL destination!", "aInstancePtr"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 440); MOZ_PretendNoReturn(); } } while (0); nsresult rv = NS_ERROR_FAILURE
; static_assert(1 > 0, "Need more arguments to NS_INTERFACE_TABLE"
); static const QITableEntry table[] = { {&mozilla::detail
::kImplementedIID<CloseListener, mozIStorageCompletionCallback
>, int32_t( reinterpret_cast<char*>(static_cast<mozIStorageCompletionCallback
*>((CloseListener*)0x1000)) - reinterpret_cast<char*>
((CloseListener*)0x1000))}, {&mozilla::detail::kImplementedIID
<CloseListener, nsISupports>, int32_t(reinterpret_cast<
char*>(static_cast<nsISupports*>( static_cast<mozIStorageCompletionCallback
*>((CloseListener*)0x1000))) - reinterpret_cast<char*>
((CloseListener*)0x1000))}, { nullptr, 0 } } ; static_assert(
(sizeof(table) / sizeof(table[0])) > 1, "need at least 1 interface"
); rv = NS_TableDrivenQI(static_cast<void*>(this), aIID
, aInstancePtr, table); return rv; }
441
442class AsyncVacuumEvent final : public Runnable {
443 public:
444 AsyncVacuumEvent(Connection* aConnection,
445 mozIStorageCompletionCallback* aCallback,
446 bool aUseIncremental, int32_t aSetPageSize)
447 : Runnable("storage::AsyncVacuum"),
448 mConnection(aConnection),
449 mCallback(aCallback),
450 mUseIncremental(aUseIncremental),
451 mSetPageSize(aSetPageSize),
452 mStatus(NS_ERROR_UNEXPECTED) {}
453
454 NS_IMETHODvirtual nsresult Run() override {
455 // This is initially dispatched to the helper thread, then re-dispatched
456 // to the opener thread, where it will callback.
457 if (IsOnCurrentSerialEventTarget(mConnection->eventTargetOpenedOn)) {
458 // Send the completion event.
459 if (mCallback) {
460 mozilla::Unused << mCallback->Complete(mStatus, nullptr);
461 }
462 return NS_OK;
463 }
464
465 // Ensure to invoke the callback regardless of errors.
466 auto guard = MakeScopeExit([&]() {
467 mConnection->mIsStatementOnHelperThreadInterruptible = false;
468 mozilla::Unused << mConnection->eventTargetOpenedOn->Dispatch(
469 this, NS_DISPATCH_NORMALnsIEventTarget::DISPATCH_NORMAL);
470 });
471
472 // Get list of attached databases.
473 nsCOMPtr<mozIStorageStatement> stmt;
474 nsresult rv = mConnection->CreateStatement(MOZ_STORAGE_UNIQUIFY_QUERY_STR"/* " "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
" */ "
475 "PRAGMA database_list"_ns,
476 getter_AddRefs(stmt));
477 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 477); return rv; } } while (false)
;
478 // We must accumulate names and loop through them later, otherwise VACUUM
479 // will see an ongoing statement and bail out.
480 nsTArray<nsCString> schemaNames;
481 bool hasResult = false;
482 while (stmt && NS_SUCCEEDED(stmt->ExecuteStep(&hasResult))((bool)(__builtin_expect(!!(!NS_FAILED_impl(stmt->ExecuteStep
(&hasResult))), 1)))
&& hasResult) {
483 nsAutoCString name;
484 rv = stmt->GetUTF8String(1, name);
485 if (NS_SUCCEEDED(rv)((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1))) && !name.EqualsLiteral("temp")) {
486 schemaNames.AppendElement(name);
487 }
488 }
489 mStatus = NS_OK;
490 // Mark this vacuum as an interruptible operation, so it can be interrupted
491 // if the connection closes during shutdown.
492 mConnection->mIsStatementOnHelperThreadInterruptible = true;
493 for (const nsCString& schemaName : schemaNames) {
494 rv = this->Vacuum(schemaName);
495 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
496 // This is sub-optimal since it's only keeping the last error reason,
497 // but it will do for now.
498 mStatus = rv;
499 }
500 }
501 return mStatus;
502 }
503
504 nsresult Vacuum(const nsACString& aSchemaName) {
505 // Abort if we're in shutdown.
506 if (AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownConfirmed)) {
507 return NS_ERROR_ABORT;
508 }
509 int32_t removablePages = mConnection->RemovablePagesInFreeList(aSchemaName);
510 if (!removablePages) {
511 // There's no empty pages to remove, so skip this vacuum for now.
512 return NS_OK;
513 }
514 nsresult rv;
515 bool needsFullVacuum = true;
516
517 if (mSetPageSize) {
518 nsAutoCString query(MOZ_STORAGE_UNIQUIFY_QUERY_STR"/* " "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
" */ "
"PRAGMA ");
519 query.Append(aSchemaName);
520 query.AppendLiteral(".page_size = ");
521 query.AppendInt(mSetPageSize);
522 nsCOMPtr<mozIStorageStatement> stmt;
523 rv = mConnection->ExecuteSimpleSQL(query);
524 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 524); return rv; } } while (false)
;
525 }
526
527 // Check auto_vacuum.
528 {
529 nsAutoCString query(MOZ_STORAGE_UNIQUIFY_QUERY_STR"/* " "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
" */ "
"PRAGMA ");
530 query.Append(aSchemaName);
531 query.AppendLiteral(".auto_vacuum");
532 nsCOMPtr<mozIStorageStatement> stmt;
533 rv = mConnection->CreateStatement(query, getter_AddRefs(stmt));
534 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 534); return rv; } } while (false)
;
535 bool hasResult = false;
536 bool changeAutoVacuum = false;
537 if (stmt && NS_SUCCEEDED(stmt->ExecuteStep(&hasResult))((bool)(__builtin_expect(!!(!NS_FAILED_impl(stmt->ExecuteStep
(&hasResult))), 1)))
&& hasResult) {
538 bool isIncrementalVacuum = stmt->AsInt32(0) == 2;
539 changeAutoVacuum = isIncrementalVacuum != mUseIncremental;
540 if (isIncrementalVacuum && !changeAutoVacuum) {
541 needsFullVacuum = false;
542 }
543 }
544 // Changing auto_vacuum is only supported on the main schema.
545 if (aSchemaName.EqualsLiteral("main") && changeAutoVacuum) {
546 nsAutoCString query(MOZ_STORAGE_UNIQUIFY_QUERY_STR"/* " "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
" */ "
"PRAGMA ");
547 query.Append(aSchemaName);
548 query.AppendLiteral(".auto_vacuum = ");
549 query.AppendInt(mUseIncremental ? 2 : 0);
550 rv = mConnection->ExecuteSimpleSQL(query);
551 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 551); return rv; } } while (false)
;
552 }
553 }
554
555 if (needsFullVacuum) {
556 nsAutoCString query(MOZ_STORAGE_UNIQUIFY_QUERY_STR"/* " "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
" */ "
"VACUUM ");
557 query.Append(aSchemaName);
558 rv = mConnection->ExecuteSimpleSQL(query);
559 // TODO (Bug 1818039): Report failed vacuum telemetry.
560 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 560); return rv; } } while (false)
;
561 } else {
562 nsAutoCString query(MOZ_STORAGE_UNIQUIFY_QUERY_STR"/* " "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
" */ "
"PRAGMA ");
563 query.Append(aSchemaName);
564 query.AppendLiteral(".incremental_vacuum(");
565 query.AppendInt(removablePages);
566 query.AppendLiteral(")");
567 rv = mConnection->ExecuteSimpleSQL(query);
568 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 568); return rv; } } while (false)
;
569 }
570
571 return NS_OK;
572 }
573
574 ~AsyncVacuumEvent() override {
575 NS_ReleaseOnMainThread("AsyncVacuum::mConnection", mConnection.forget());
576 NS_ReleaseOnMainThread("AsyncVacuum::mCallback", mCallback.forget());
577 }
578
579 private:
580 RefPtr<Connection> mConnection;
581 nsCOMPtr<mozIStorageCompletionCallback> mCallback;
582 bool mUseIncremental;
583 int32_t mSetPageSize;
584 Atomic<nsresult> mStatus;
585};
586
587/**
588 * A runnable to perform an SQLite database backup when there may be one or more
589 * open connections on that database.
590 */
591class AsyncBackupDatabaseFile final : public Runnable, public nsITimerCallback {
592 public:
593 NS_DECL_ISUPPORTS_INHERITEDpublic: virtual nsresult QueryInterface(const nsIID& aIID
, void** aInstancePtr) override; virtual MozExternalRefCountType
AddRef(void) override; virtual MozExternalRefCountType Release
(void) override;
594
595 /**
596 * @param aConnection The connection to the database being backed up.
597 * @param aNativeConnection The native connection to the database being backed
598 * up.
599 * @param aDestinationFile The destination file for the created backup.
600 * @param aCallback A callback to trigger once the backup process has
601 * completed. The callback will be supplied with an nsresult
602 * indicating whether or not the backup was successfully
603 * created. This callback will be called on the
604 * mConnection->eventTargetOpenedOn thread.
605 * @throws
606 */
607 AsyncBackupDatabaseFile(Connection* aConnection, sqlite3* aNativeConnection,
608 nsIFile* aDestinationFile,
609 mozIStorageCompletionCallback* aCallback,
610 int32_t aPagesPerStep, uint32_t aStepDelayMs)
611 : Runnable("storage::AsyncBackupDatabaseFile"),
612 mConnection(aConnection),
613 mNativeConnection(aNativeConnection),
614 mDestinationFile(aDestinationFile),
615 mCallback(aCallback),
616 mPagesPerStep(aPagesPerStep),
617 mStepDelayMs(aStepDelayMs),
618 mBackupFile(nullptr),
619 mBackupHandle(nullptr) {
620 MOZ_ASSERT(NS_IsMainThread())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(NS_IsMainThread())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(NS_IsMainThread()))), 0))) {
do { } while (false); MOZ_ReportAssertionFailure("NS_IsMainThread()"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 620); AnnotateMozCrashReason("MOZ_ASSERT" "(" "NS_IsMainThread()"
")"); do { *((volatile int*)__null) = 620; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
621 }
622
623 NS_IMETHODvirtual nsresult Run() override {
624 MOZ_ASSERT(!NS_IsMainThread())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!NS_IsMainThread())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!NS_IsMainThread()))), 0))) {
do { } while (false); MOZ_ReportAssertionFailure("!NS_IsMainThread()"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 624); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!NS_IsMainThread()"
")"); do { *((volatile int*)__null) = 624; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
625
626 nsAutoString path;
627 nsresult rv = mDestinationFile->GetPath(path);
628 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
629 return Dispatch(rv, nullptr);
630 }
631 // Put a .tmp on the end of the destination while the backup is underway.
632 // This extension will be stripped off after the backup successfully
633 // completes.
634 path.AppendLiteral(".tmp");
635
636 int srv = ::sqlite3_open(NS_ConvertUTF16toUTF8(path).get(), &mBackupFile);
637 if (srv != SQLITE_OK0) {
638 return Dispatch(NS_ERROR_FAILURE, nullptr);
639 }
640
641 static const char* mainDBName = "main";
642
643 mBackupHandle = ::sqlite3_backup_init(mBackupFile, mainDBName,
644 mNativeConnection, mainDBName);
645 if (!mBackupHandle) {
646 MOZ_ALWAYS_TRUE(::sqlite3_close(mBackupFile) == SQLITE_OK)do { if ((__builtin_expect(!!(::sqlite3_close(mBackupFile) ==
0), 1))) { } else { do { static_assert( mozilla::detail::AssertionConditionType
<decltype(false)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("false" " (" "::sqlite3_close(mBackupFile) == SQLITE_OK"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 646); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "::sqlite3_close(mBackupFile) == SQLITE_OK" ")"); do {
*((volatile int*)__null) = 646; __attribute__((nomerge)) ::abort
(); } while (false); } } while (false); } } while (false)
;
647 return Dispatch(NS_ERROR_FAILURE, nullptr);
648 }
649
650 return DoStep();
651 }
652
653 NS_IMETHODvirtual nsresult
654 Notify(nsITimer* aTimer) override { return DoStep(); }
655
656 private:
657 nsresult DoStep() {
658#define DISPATCH_AND_RETURN_IF_FAILED(rv) \
659 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) { \
660 return Dispatch(rv, nullptr); \
661 }
662
663 // This guard is used to close the backup database in the event of
664 // some failure throughout this process. We release the exit guard
665 // only if we complete the backup successfully, or defer to another
666 // later call to DoStep.
667 auto guard = MakeScopeExit([&]() {
668 MOZ_ALWAYS_TRUE(::sqlite3_close(mBackupFile) == SQLITE_OK)do { if ((__builtin_expect(!!(::sqlite3_close(mBackupFile) ==
0), 1))) { } else { do { static_assert( mozilla::detail::AssertionConditionType
<decltype(false)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("false" " (" "::sqlite3_close(mBackupFile) == SQLITE_OK"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 668); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "::sqlite3_close(mBackupFile) == SQLITE_OK" ")"); do {
*((volatile int*)__null) = 668; __attribute__((nomerge)) ::abort
(); } while (false); } } while (false); } } while (false)
;
669 mBackupFile = nullptr;
670 });
671
672 MOZ_ASSERT(!NS_IsMainThread())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!NS_IsMainThread())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!NS_IsMainThread()))), 0))) {
do { } while (false); MOZ_ReportAssertionFailure("!NS_IsMainThread()"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 672); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!NS_IsMainThread()"
")"); do { *((volatile int*)__null) = 672; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
673 nsAutoString originalPath;
674 nsresult rv = mDestinationFile->GetPath(originalPath);
675 DISPATCH_AND_RETURN_IF_FAILED(rv);
676
677 nsAutoString tempPath = originalPath;
678 tempPath.AppendLiteral(".tmp");
679
680 nsCOMPtr<nsIFile> file =
681 do_CreateInstance("@mozilla.org/file/local;1", &rv);
682 DISPATCH_AND_RETURN_IF_FAILED(rv);
683
684 rv = file->InitWithPath(tempPath);
685 DISPATCH_AND_RETURN_IF_FAILED(rv);
686
687 int srv = ::sqlite3_backup_step(mBackupHandle, mPagesPerStep);
688 if (srv == SQLITE_OK0 || srv == SQLITE_BUSY5 || srv == SQLITE_LOCKED6) {
689 // We're continuing the backup later. Release the guard to avoid closing
690 // the database.
691 guard.release();
692 // Queue up the next step
693 return NS_NewTimerWithCallback(getter_AddRefs(mTimer), this, mStepDelayMs,
694 nsITimer::TYPE_ONE_SHOT,
695 GetCurrentSerialEventTarget());
696 }
697#ifdef DEBUG1
698 if (srv != SQLITE_DONE101) {
699 nsCString warnMsg;
700 warnMsg.AppendLiteral(
701 "The SQLite database copy could not be completed due to an error: ");
702 warnMsg.Append(::sqlite3_errmsg(mBackupFile));
703 NS_WARNING(warnMsg.get())NS_DebugBreak(NS_DEBUG_WARNING, warnMsg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 703)
;
704 }
705#endif
706
707 (void)::sqlite3_backup_finish(mBackupHandle);
708 MOZ_ALWAYS_TRUE(::sqlite3_close(mBackupFile) == SQLITE_OK)do { if ((__builtin_expect(!!(::sqlite3_close(mBackupFile) ==
0), 1))) { } else { do { static_assert( mozilla::detail::AssertionConditionType
<decltype(false)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("false" " (" "::sqlite3_close(mBackupFile) == SQLITE_OK"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 708); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "::sqlite3_close(mBackupFile) == SQLITE_OK" ")"); do {
*((volatile int*)__null) = 708; __attribute__((nomerge)) ::abort
(); } while (false); } } while (false); } } while (false)
;
709 mBackupFile = nullptr;
710
711 // The database is already closed, so we can release this guard now.
712 guard.release();
713
714 if (srv != SQLITE_DONE101) {
715 NS_WARNING("Failed to create database copy.")NS_DebugBreak(NS_DEBUG_WARNING, "Failed to create database copy."
, nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 715)
;
716
717 // The partially created database file is not useful. Let's remove it.
718 rv = file->Remove(false);
719 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
720 NS_WARNING(NS_DebugBreak(NS_DEBUG_WARNING, "Removing a partially backed up SQLite database file failed."
, nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 721)
721 "Removing a partially backed up SQLite database file failed.")NS_DebugBreak(NS_DEBUG_WARNING, "Removing a partially backed up SQLite database file failed."
, nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 721)
;
722 }
723
724 return Dispatch(convertResultCode(srv), nullptr);
725 }
726
727 // Now that we've successfully created the copy, we'll strip off the .tmp
728 // extension.
729
730 nsAutoString leafName;
731 rv = mDestinationFile->GetLeafName(leafName);
732 DISPATCH_AND_RETURN_IF_FAILED(rv);
733
734 rv = file->RenameTo(nullptr, leafName);
735 DISPATCH_AND_RETURN_IF_FAILED(rv);
736
737#undef DISPATCH_AND_RETURN_IF_FAILED
738 return Dispatch(NS_OK, nullptr);
739 }
740
741 nsresult Dispatch(nsresult aResult, nsISupports* aValue) {
742 RefPtr<CallbackComplete> event =
743 new CallbackComplete(aResult, aValue, mCallback.forget());
744 return mConnection->eventTargetOpenedOn->Dispatch(event,
745 NS_DISPATCH_NORMALnsIEventTarget::DISPATCH_NORMAL);
746 }
747
748 ~AsyncBackupDatabaseFile() override {
749 nsresult rv;
750 nsCOMPtr<nsIThread> thread =
751 do_QueryInterface(mConnection->eventTargetOpenedOn, &rv);
752 MOZ_ASSERT(NS_SUCCEEDED(rv))do { static_assert( mozilla::detail::AssertionConditionType<
decltype(((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1)
)))>::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1)
))))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1)))", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 752); AnnotateMozCrashReason("MOZ_ASSERT" "(" "((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1)))"
")"); do { *((volatile int*)__null) = 752; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
753
754 // Handle ambiguous nsISupports inheritance.
755 NS_ProxyRelease("AsyncBackupDatabaseFile::mConnection", thread,
756 mConnection.forget());
757 NS_ProxyRelease("AsyncBackupDatabaseFile::mDestinationFile", thread,
758 mDestinationFile.forget());
759
760 // Generally, the callback will be released by CallbackComplete.
761 // However, if for some reason Run() is not executed, we still
762 // need to ensure that it is released here.
763 NS_ProxyRelease("AsyncInitializeClone::mCallback", thread,
764 mCallback.forget());
765 }
766
767 RefPtr<Connection> mConnection;
768 sqlite3* mNativeConnection;
769 nsCOMPtr<nsITimer> mTimer;
770 nsCOMPtr<nsIFile> mDestinationFile;
771 nsCOMPtr<mozIStorageCompletionCallback> mCallback;
772 int32_t mPagesPerStep;
773 uint32_t mStepDelayMs;
774 sqlite3* mBackupFile;
775 sqlite3_backup* mBackupHandle;
776};
777
778NS_IMPL_ISUPPORTS_INHERITED(AsyncBackupDatabaseFile, Runnable, nsITimerCallback)nsresult AsyncBackupDatabaseFile::QueryInterface(const nsIID&
aIID, void** aInstancePtr) { do { if (!(aInstancePtr)) { NS_DebugBreak
(NS_DEBUG_ASSERTION, "QueryInterface requires a non-NULL destination!"
, "aInstancePtr", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 778); MOZ_PretendNoReturn(); } } while (0); nsresult rv = NS_ERROR_FAILURE
; static_assert(1 > 0, "Need more arguments to NS_INTERFACE_TABLE_INHERITED"
); static const QITableEntry table[] = { {&mozilla::detail
::kImplementedIID<AsyncBackupDatabaseFile, nsITimerCallback
>, int32_t( reinterpret_cast<char*>(static_cast<nsITimerCallback
*>((AsyncBackupDatabaseFile*)0x1000)) - reinterpret_cast<
char*>((AsyncBackupDatabaseFile*)0x1000))}, { nullptr, 0 }
} ; static_assert((sizeof(table) / sizeof(table[0])) > 1,
"need at least 1 interface"); rv = NS_TableDrivenQI(static_cast
<void*>(this), aIID, aInstancePtr, table); if (((bool)(
__builtin_expect(!!(!NS_FAILED_impl(rv)), 1)))) return rv; return
Runnable::QueryInterface(aIID, aInstancePtr); } MozExternalRefCountType
AsyncBackupDatabaseFile::AddRef(void) { static_assert(!std::
is_destructible_v<AsyncBackupDatabaseFile>, "Reference-counted class "
"AsyncBackupDatabaseFile" " should not have a public destructor. "
"Make this class's destructor non-public"); nsrefcnt r = Runnable
::AddRef(); if constexpr (::mozilla::detail::ShouldLogInheritedRefcnt
<AsyncBackupDatabaseFile>) { NS_LogAddRef((this), (r), (
"AsyncBackupDatabaseFile"), (uint32_t)(sizeof(*this))); } return
r; } MozExternalRefCountType AsyncBackupDatabaseFile::Release
(void) { nsrefcnt r = Runnable::Release(); if constexpr (::mozilla
::detail::ShouldLogInheritedRefcnt<AsyncBackupDatabaseFile
>) { NS_LogRelease((this), (r), ("AsyncBackupDatabaseFile"
)); } return r; }
779
780} // namespace
781
782////////////////////////////////////////////////////////////////////////////////
783//// Connection
784
785Connection::Connection(Service* aService, int aFlags,
786 ConnectionOperation aSupportedOperations,
787 const nsCString& aTelemetryFilename, bool aInterruptible,
788 bool aIgnoreLockingMode, bool aOpenNotExclusive)
789 : sharedAsyncExecutionMutex("Connection::sharedAsyncExecutionMutex"),
790 sharedDBMutex("Connection::sharedDBMutex"),
791 eventTargetOpenedOn(WrapNotNull(GetCurrentSerialEventTarget())),
792 mIsStatementOnHelperThreadInterruptible(false),
793 mDBConn(nullptr),
794 mDefaultTransactionType(mozIStorageConnection::TRANSACTION_DEFERRED),
795 mDestroying(false),
796 mProgressHandler(nullptr),
797 mStorageService(aService),
798 mFlags(aFlags),
799 mTransactionNestingLevel(0),
800 mSupportedOperations(aSupportedOperations),
801 mInterruptible(aSupportedOperations == Connection::ASYNCHRONOUS ||
802 aInterruptible),
803 mIgnoreLockingMode(aIgnoreLockingMode),
804 mOpenNotExclusive(aOpenNotExclusive),
805 mAsyncExecutionThreadShuttingDown(false),
806 mConnectionClosed(false),
807 mGrowthChunkSize(0) {
808 MOZ_ASSERT(!mIgnoreLockingMode || mFlags & SQLITE_OPEN_READONLY,do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!mIgnoreLockingMode || mFlags & 0x00000001)>::
isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(!mIgnoreLockingMode || mFlags & 0x00000001))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("!mIgnoreLockingMode || mFlags & 0x00000001"
" (" "Can't ignore locking for a non-readonly connection!" ")"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 809); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mIgnoreLockingMode || mFlags & 0x00000001"
") (" "Can't ignore locking for a non-readonly connection!" ")"
); do { *((volatile int*)__null) = 809; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
809 "Can't ignore locking for a non-readonly connection!")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!mIgnoreLockingMode || mFlags & 0x00000001)>::
isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(!mIgnoreLockingMode || mFlags & 0x00000001))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("!mIgnoreLockingMode || mFlags & 0x00000001"
" (" "Can't ignore locking for a non-readonly connection!" ")"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 809); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mIgnoreLockingMode || mFlags & 0x00000001"
") (" "Can't ignore locking for a non-readonly connection!" ")"
); do { *((volatile int*)__null) = 809; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
810 mStorageService->registerConnection(this);
811 MOZ_ASSERT(!aTelemetryFilename.IsEmpty(),do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!aTelemetryFilename.IsEmpty())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!aTelemetryFilename.IsEmpty(
)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("!aTelemetryFilename.IsEmpty()" " (" "A telemetry filename should have been passed-in."
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 812); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!aTelemetryFilename.IsEmpty()"
") (" "A telemetry filename should have been passed-in." ")"
); do { *((volatile int*)__null) = 812; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
812 "A telemetry filename should have been passed-in.")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!aTelemetryFilename.IsEmpty())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!aTelemetryFilename.IsEmpty(
)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("!aTelemetryFilename.IsEmpty()" " (" "A telemetry filename should have been passed-in."
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 812); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!aTelemetryFilename.IsEmpty()"
") (" "A telemetry filename should have been passed-in." ")"
); do { *((volatile int*)__null) = 812; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
813 mTelemetryFilename.Assign(aTelemetryFilename);
814}
815
816Connection::~Connection() {
817 // Failsafe Close() occurs in our custom Release method because of
818 // complications related to Close() potentially invoking AsyncClose() which
819 // will increment our refcount.
820 MOZ_ASSERT(!mAsyncExecutionThread,do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!mAsyncExecutionThread)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!mAsyncExecutionThread))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("!mAsyncExecutionThread"
" (" "The async thread has not been shutdown properly!" ")",
"/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 821); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mAsyncExecutionThread"
") (" "The async thread has not been shutdown properly!" ")"
); do { *((volatile int*)__null) = 821; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
821 "The async thread has not been shutdown properly!")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!mAsyncExecutionThread)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!mAsyncExecutionThread))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("!mAsyncExecutionThread"
" (" "The async thread has not been shutdown properly!" ")",
"/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 821); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mAsyncExecutionThread"
") (" "The async thread has not been shutdown properly!" ")"
); do { *((volatile int*)__null) = 821; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
822}
823
824NS_IMPL_ADDREF(Connection)MozExternalRefCountType Connection::AddRef(void) { static_assert
(!std::is_destructible_v<Connection>, "Reference-counted class "
"Connection" " should not have a public destructor. " "Make this class's destructor non-public"
); do { static_assert( mozilla::detail::AssertionConditionType
<decltype(int32_t(mRefCnt) >= 0)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(int32_t(mRefCnt) >= 0))),
0))) { do { } while (false); MOZ_ReportAssertionFailure("int32_t(mRefCnt) >= 0"
" (" "illegal refcnt" ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 824); AnnotateMozCrashReason("MOZ_ASSERT" "(" "int32_t(mRefCnt) >= 0"
") (" "illegal refcnt" ")"); do { *((volatile int*)__null) =
824; __attribute__((nomerge)) ::abort(); } while (false); } }
while (false); do { static_assert( mozilla::detail::AssertionConditionType
<decltype("Connection" != nullptr)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!("Connection" != nullptr))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("\"Connection\" != nullptr"
" (" "Must specify a name" ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 824); AnnotateMozCrashReason("MOZ_ASSERT" "(" "\"Connection\" != nullptr"
") (" "Must specify a name" ")"); do { *((volatile int*)__null
) = 824; __attribute__((nomerge)) ::abort(); } while (false);
} } while (false); if (!mRefCnt.isThreadSafe) _mOwningThread
.AssertOwnership("Connection" " not thread-safe"); nsrefcnt count
= ++mRefCnt; NS_LogAddRef((this), (count), ("Connection"), (
uint32_t)(sizeof(*this))); return count; }
825
826NS_INTERFACE_MAP_BEGIN(Connection)nsresult Connection::QueryInterface(const nsIID& aIID, void
** aInstancePtr) { do { if (!(aInstancePtr)) { NS_DebugBreak(
NS_DEBUG_ASSERTION, "QueryInterface requires a non-NULL destination!"
, "aInstancePtr", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 826); MOZ_PretendNoReturn(); } } while (0); nsISupports* foundInterface
;
827 NS_INTERFACE_MAP_ENTRY(mozIStorageAsyncConnection)if (aIID.Equals(mozilla::detail::kImplementedIID<std::remove_reference_t
<decltype(*this)>, mozIStorageAsyncConnection>)) foundInterface
= static_cast<mozIStorageAsyncConnection*>(this); else
828 NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor)if (aIID.Equals(mozilla::detail::kImplementedIID<std::remove_reference_t
<decltype(*this)>, nsIInterfaceRequestor>)) foundInterface
= static_cast<nsIInterfaceRequestor*>(this); else
829 NS_INTERFACE_MAP_ENTRY(mozIStorageConnection)if (aIID.Equals(mozilla::detail::kImplementedIID<std::remove_reference_t
<decltype(*this)>, mozIStorageConnection>)) foundInterface
= static_cast<mozIStorageConnection*>(this); else
830 NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, mozIStorageConnection)if (aIID.Equals(mozilla::detail::kImplementedIID<std::remove_reference_t
<decltype(*this)>, nsISupports>)) foundInterface = static_cast
<nsISupports*>(static_cast<mozIStorageConnection*>
(this)); else
831NS_INTERFACE_MAP_ENDfoundInterface = 0; nsresult status; if (!foundInterface) { do
{ static_assert( mozilla::detail::AssertionConditionType<
decltype(!aIID.Equals((nsISupports::COMTypeInfo<nsISupports
, void>::kIID)))>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!aIID.Equals((nsISupports::COMTypeInfo
<nsISupports, void>::kIID))))), 0))) { do { } while (false
); MOZ_ReportAssertionFailure("!aIID.Equals((nsISupports::COMTypeInfo<nsISupports, void>::kIID))"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 831); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!aIID.Equals((nsISupports::COMTypeInfo<nsISupports, void>::kIID))"
")"); do { *((volatile int*)__null) = 831; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); status = NS_NOINTERFACE
; } else { (foundInterface)->AddRef(); status = NS_OK; } *
aInstancePtr = foundInterface; return status; }
832
833// This is identical to what NS_IMPL_RELEASE provides, but with the
834// extra |1 == count| case.
835NS_IMETHODIMP_(MozExternalRefCountType)MozExternalRefCountType Connection::Release(void) {
836 MOZ_ASSERT(0 != mRefCnt, "dup release")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(0 != mRefCnt)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(0 != mRefCnt))), 0))) { do {
} while (false); MOZ_ReportAssertionFailure("0 != mRefCnt" " ("
"dup release" ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 836); AnnotateMozCrashReason("MOZ_ASSERT" "(" "0 != mRefCnt"
") (" "dup release" ")"); do { *((volatile int*)__null) = 836
; __attribute__((nomerge)) ::abort(); } while (false); } } while
(false)
;
837 nsrefcnt count = --mRefCnt;
838 NS_LOG_RELEASE(this, count, "Connection")NS_LogRelease((this), (count), ("Connection"));
839 if (1 == count) {
840 // If the refcount went to 1, the single reference must be from
841 // gService->mConnections (in class |Service|). And the code calling
842 // Release is either:
843 // - The "user" code that had created the connection, releasing on any
844 // thread.
845 // - One of Service's getConnections() callers had acquired a strong
846 // reference to the Connection that out-lived the last "user" reference,
847 // and now that just got dropped. Note that this reference could be
848 // getting dropped on the main thread or Connection->eventTargetOpenedOn
849 // (because of the NewRunnableMethod used by minimizeMemory).
850 //
851 // Either way, we should now perform our failsafe Close() and unregister.
852 // However, we only want to do this once, and the reality is that our
853 // refcount could go back up above 1 and down again at any time if we are
854 // off the main thread and getConnections() gets called on the main thread,
855 // so we use an atomic here to do this exactly once.
856 if (mDestroying.compareExchange(false, true)) {
857 // Close the connection, dispatching to the opening event target if we're
858 // not on that event target already and that event target is still
859 // accepting runnables. We do this because it's possible we're on the main
860 // thread because of getConnections(), and we REALLY don't want to
861 // transfer I/O to the main thread if we can avoid it.
862 if (IsOnCurrentSerialEventTarget(eventTargetOpenedOn)) {
863 // This could cause SpinningSynchronousClose() to be invoked and AddRef
864 // triggered for AsyncCloseConnection's strong ref if the conn was ever
865 // use for async purposes. (Main-thread only, though.)
866 Unused << synchronousClose();
867 } else {
868 nsCOMPtr<nsIRunnable> event =
869 NewRunnableMethod("storage::Connection::synchronousClose", this,
870 &Connection::synchronousClose);
871 if (NS_FAILED(eventTargetOpenedOn->Dispatch(event.forget(),((bool)(__builtin_expect(!!(NS_FAILED_impl(eventTargetOpenedOn
->Dispatch(event.forget(), nsIEventTarget::DISPATCH_NORMAL
))), 0)))
872 NS_DISPATCH_NORMAL))((bool)(__builtin_expect(!!(NS_FAILED_impl(eventTargetOpenedOn
->Dispatch(event.forget(), nsIEventTarget::DISPATCH_NORMAL
))), 0)))
) {
873 // The event target was dead and so we've just leaked our runnable.
874 // This should not happen because our non-main-thread consumers should
875 // be explicitly closing their connections, not relying on us to close
876 // them for them. (It's okay to let a statement go out of scope for
877 // automatic cleanup, but not a Connection.)
878 MOZ_ASSERT(false,do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false" " (" "Leaked Connection::synchronousClose(), ownership fail."
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 879); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") ("
"Leaked Connection::synchronousClose(), ownership fail." ")"
); do { *((volatile int*)__null) = 879; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
879 "Leaked Connection::synchronousClose(), ownership fail.")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false" " (" "Leaked Connection::synchronousClose(), ownership fail."
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 879); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") ("
"Leaked Connection::synchronousClose(), ownership fail." ")"
); do { *((volatile int*)__null) = 879; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
880 Unused << synchronousClose();
881 }
882 }
883
884 // This will drop its strong reference right here, right now.
885 mStorageService->unregisterConnection(this);
886 }
887 } else if (0 == count) {
888 mRefCnt = 1; /* stabilize */
889#if 0 /* enable this to find non-threadsafe destructors: */
890 NS_ASSERT_OWNINGTHREAD(Connection)_mOwningThread.AssertOwnership("Connection" " not thread-safe"
)
;
891#endif
892 delete (this);
893 return 0;
894 }
895 return count;
896}
897
898int32_t Connection::getSqliteRuntimeStatus(int32_t aStatusOption,
899 int32_t* aMaxValue) {
900 MOZ_ASSERT(connectionReady(), "A connection must exist at this point")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(connectionReady())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(connectionReady()))), 0))) {
do { } while (false); MOZ_ReportAssertionFailure("connectionReady()"
" (" "A connection must exist at this point" ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 900); AnnotateMozCrashReason("MOZ_ASSERT" "(" "connectionReady()"
") (" "A connection must exist at this point" ")"); do { *((
volatile int*)__null) = 900; __attribute__((nomerge)) ::abort
(); } while (false); } } while (false)
;
901 int curr = 0, max = 0;
902 DebugOnly<int> rc =
903 ::sqlite3_db_status(mDBConn, aStatusOption, &curr, &max, 0);
904 MOZ_ASSERT(NS_SUCCEEDED(convertResultCode(rc)))do { static_assert( mozilla::detail::AssertionConditionType<
decltype(((bool)(__builtin_expect(!!(!NS_FAILED_impl(convertResultCode
(rc))), 1))))>::isValid, "invalid assertion condition"); if
((__builtin_expect(!!(!(!!(((bool)(__builtin_expect(!!(!NS_FAILED_impl
(convertResultCode(rc))), 1)))))), 0))) { do { } while (false
); MOZ_ReportAssertionFailure("((bool)(__builtin_expect(!!(!NS_FAILED_impl(convertResultCode(rc))), 1)))"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 904); AnnotateMozCrashReason("MOZ_ASSERT" "(" "((bool)(__builtin_expect(!!(!NS_FAILED_impl(convertResultCode(rc))), 1)))"
")"); do { *((volatile int*)__null) = 904; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
905 if (aMaxValue) *aMaxValue = max;
906 return curr;
907}
908
909nsIEventTarget* Connection::getAsyncExecutionTarget() {
910 NS_ENSURE_TRUE(IsOnCurrentSerialEventTarget(eventTargetOpenedOn), nullptr)do { if ((__builtin_expect(!!(!(IsOnCurrentSerialEventTarget(
eventTargetOpenedOn))), 0))) { NS_DebugBreak(NS_DEBUG_WARNING
, "NS_ENSURE_TRUE(" "IsOnCurrentSerialEventTarget(eventTargetOpenedOn)"
") failed", nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 910); return nullptr; } } while (false)
;
911
912 // Don't return the asynchronous event target if we are shutting down.
913 if (mAsyncExecutionThreadShuttingDown) {
914 return nullptr;
915 }
916
917 // Create the async event target if there's none yet.
918 if (!mAsyncExecutionThread) {
919 // Names start with "sqldb:" followed by a recognizable name, like the
920 // database file name, or a specially crafted name like "memory".
921 // This name will be surfaced on https://crash-stats.mozilla.org, so any
922 // sensitive part of the file name (e.g. an URL origin) should be replaced
923 // by passing an explicit telemetryName to openDatabaseWithFileURL.
924 nsAutoCString name("sqldb:"_ns);
925 name.Append(mTelemetryFilename);
926 static nsThreadPoolNaming naming;
927 nsresult rv = NS_NewNamedThread(naming.GetNextThreadName(name),
928 getter_AddRefs(mAsyncExecutionThread));
929 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
930 NS_WARNING("Failed to create async thread.")NS_DebugBreak(NS_DEBUG_WARNING, "Failed to create async thread."
, nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 930)
;
931 return nullptr;
932 }
933 }
934
935 return mAsyncExecutionThread;
936}
937
938void Connection::RecordOpenStatus(nsresult rv) {
939 nsCString histogramKey = mTelemetryFilename;
940
941 if (histogramKey.IsEmpty()) {
942 histogramKey.AssignLiteral("unknown");
943 }
944
945 if (NS_SUCCEEDED(rv)((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1)))) {
946 AccumulateCategoricalKeyed(histogramKey, LABELS_SQLITE_STORE_OPEN::success);
947 return;
948 }
949
950 switch (rv) {
951 case NS_ERROR_FILE_CORRUPTED:
952 AccumulateCategoricalKeyed(histogramKey,
953 LABELS_SQLITE_STORE_OPEN::corrupt);
954 break;
955 case NS_ERROR_STORAGE_IOERR:
956 AccumulateCategoricalKeyed(histogramKey,
957 LABELS_SQLITE_STORE_OPEN::diskio);
958 break;
959 case NS_ERROR_FILE_ACCESS_DENIED:
960 case NS_ERROR_FILE_IS_LOCKED:
961 case NS_ERROR_FILE_READ_ONLY:
962 AccumulateCategoricalKeyed(histogramKey,
963 LABELS_SQLITE_STORE_OPEN::access);
964 break;
965 case NS_ERROR_FILE_NO_DEVICE_SPACE:
966 AccumulateCategoricalKeyed(histogramKey,
967 LABELS_SQLITE_STORE_OPEN::diskspace);
968 break;
969 default:
970 AccumulateCategoricalKeyed(histogramKey,
971 LABELS_SQLITE_STORE_OPEN::failure);
972 }
973}
974
975void Connection::RecordQueryStatus(int srv) {
976 nsCString histogramKey = mTelemetryFilename;
977
978 if (histogramKey.IsEmpty()) {
979 histogramKey.AssignLiteral("unknown");
980 }
981
982 switch (srv) {
983 case SQLITE_OK0:
984 case SQLITE_ROW100:
985 case SQLITE_DONE101:
986
987 // Note that these are returned when we intentionally cancel a statement so
988 // they aren't indicating a failure.
989 case SQLITE_ABORT4:
990 case SQLITE_INTERRUPT9:
991 AccumulateCategoricalKeyed(histogramKey,
992 LABELS_SQLITE_STORE_QUERY::success);
993 break;
994 case SQLITE_CORRUPT11:
995 case SQLITE_NOTADB26:
996 AccumulateCategoricalKeyed(histogramKey,
997 LABELS_SQLITE_STORE_QUERY::corrupt);
998 break;
999 case SQLITE_PERM3:
1000 case SQLITE_CANTOPEN14:
1001 case SQLITE_LOCKED6:
1002 case SQLITE_READONLY8:
1003 AccumulateCategoricalKeyed(histogramKey,
1004 LABELS_SQLITE_STORE_QUERY::access);
1005 break;
1006 case SQLITE_IOERR10:
1007 case SQLITE_NOLFS22:
1008 AccumulateCategoricalKeyed(histogramKey,
1009 LABELS_SQLITE_STORE_QUERY::diskio);
1010 break;
1011 case SQLITE_FULL13:
1012 case SQLITE_TOOBIG18:
1013 AccumulateCategoricalKeyed(histogramKey,
1014 LABELS_SQLITE_STORE_QUERY::diskspace);
1015 break;
1016 case SQLITE_CONSTRAINT19:
1017 case SQLITE_RANGE25:
1018 case SQLITE_MISMATCH20:
1019 case SQLITE_MISUSE21:
1020 AccumulateCategoricalKeyed(histogramKey,
1021 LABELS_SQLITE_STORE_QUERY::misuse);
1022 break;
1023 case SQLITE_BUSY5:
1024 AccumulateCategoricalKeyed(histogramKey, LABELS_SQLITE_STORE_QUERY::busy);
1025 break;
1026 default:
1027 AccumulateCategoricalKeyed(histogramKey,
1028 LABELS_SQLITE_STORE_QUERY::failure);
1029 }
1030}
1031
1032nsresult Connection::initialize(const nsACString& aStorageKey,
1033 const nsACString& aName) {
1034 MOZ_ASSERT(aStorageKey.Equals(kMozStorageMemoryStorageKey))do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aStorageKey.Equals(kMozStorageMemoryStorageKey))>
::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(aStorageKey.Equals(kMozStorageMemoryStorageKey)))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("aStorageKey.Equals(kMozStorageMemoryStorageKey)"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1034); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aStorageKey.Equals(kMozStorageMemoryStorageKey)"
")"); do { *((volatile int*)__null) = 1034; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1035 NS_ASSERTION(!connectionReady(),do { if (!(!connectionReady())) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "Initialize called on already opened database!", "!connectionReady()"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1036); MOZ_PretendNoReturn(); } } while (0)
1036 "Initialize called on already opened database!")do { if (!(!connectionReady())) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "Initialize called on already opened database!", "!connectionReady()"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1036); MOZ_PretendNoReturn(); } } while (0)
;
1037 MOZ_ASSERT(!mIgnoreLockingMode, "Can't ignore locking on an in-memory db.")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!mIgnoreLockingMode)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!mIgnoreLockingMode))), 0)))
{ do { } while (false); MOZ_ReportAssertionFailure("!mIgnoreLockingMode"
" (" "Can't ignore locking on an in-memory db." ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1037); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mIgnoreLockingMode"
") (" "Can't ignore locking on an in-memory db." ")"); do { *
((volatile int*)__null) = 1037; __attribute__((nomerge)) ::abort
(); } while (false); } } while (false)
;
1038 AUTO_PROFILER_LABEL("Connection::initialize", OTHER)mozilla::AutoProfilerLabel raiiObject1038( "Connection::initialize"
, nullptr, JS::ProfilingCategoryPair::OTHER)
;
1039
1040 mStorageKey = aStorageKey;
1041 mName = aName;
1042
1043 // in memory database requested, sqlite uses a magic file name
1044
1045 const nsAutoCString path =
1046 mName.IsEmpty() ? nsAutoCString(":memory:"_ns)
1047 : "file:"_ns + mName + "?mode=memory&cache=shared"_ns;
1048
1049 int srv = ::sqlite3_open_v2(path.get(), &mDBConn, mFlags,
1050 basevfs::GetVFSName(true));
1051 if (srv != SQLITE_OK0) {
1052 mDBConn = nullptr;
1053 nsresult rv = convertResultCode(srv);
1054 RecordOpenStatus(rv);
1055 return rv;
1056 }
1057
1058#ifdef MOZ_SQLITE_FTS3_TOKENIZER
1059 srv =
1060 ::sqlite3_db_config(mDBConn, SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER1004, 1, 0);
1061 MOZ_ASSERT(srv == SQLITE_OK,do { static_assert( mozilla::detail::AssertionConditionType<
decltype(srv == 0)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(srv == 0))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("srv == 0" " (" "SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER should be enabled"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1062); AnnotateMozCrashReason("MOZ_ASSERT" "(" "srv == 0" ") ("
"SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER should be enabled" ")"
); do { *((volatile int*)__null) = 1062; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
1062 "SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER should be enabled")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(srv == 0)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(srv == 0))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("srv == 0" " (" "SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER should be enabled"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1062); AnnotateMozCrashReason("MOZ_ASSERT" "(" "srv == 0" ") ("
"SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER should be enabled" ")"
); do { *((volatile int*)__null) = 1062; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1063#endif
1064
1065 // Do not set mDatabaseFile or mFileURL here since this is a "memory"
1066 // database.
1067
1068 nsresult rv = initializeInternal();
1069 RecordOpenStatus(rv);
1070 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1070); return rv; } } while (false)
;
1071
1072 return NS_OK;
1073}
1074
1075nsresult Connection::initialize(nsIFile* aDatabaseFile) {
1076 NS_ASSERTION(aDatabaseFile, "Passed null file!")do { if (!(aDatabaseFile)) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "Passed null file!", "aDatabaseFile", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1076); MOZ_PretendNoReturn(); } } while (0)
;
1077 NS_ASSERTION(!connectionReady(),do { if (!(!connectionReady())) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "Initialize called on already opened database!", "!connectionReady()"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1078); MOZ_PretendNoReturn(); } } while (0)
1078 "Initialize called on already opened database!")do { if (!(!connectionReady())) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "Initialize called on already opened database!", "!connectionReady()"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1078); MOZ_PretendNoReturn(); } } while (0)
;
1079 AUTO_PROFILER_LABEL("Connection::initialize", OTHER)mozilla::AutoProfilerLabel raiiObject1079( "Connection::initialize"
, nullptr, JS::ProfilingCategoryPair::OTHER)
;
1080
1081 // Do not set mFileURL here since this is database does not have an associated
1082 // URL.
1083 mDatabaseFile = aDatabaseFile;
1084
1085 nsAutoString path;
1086 nsresult rv = aDatabaseFile->GetPath(path);
1087 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1087); return rv; } } while (false)
;
1088
1089 bool exclusive =
1090 StaticPrefs::storage_sqlite_exclusiveLock_enabled() && !mOpenNotExclusive;
1091 int srv;
1092 if (mIgnoreLockingMode) {
1093 exclusive = false;
1094 srv = ::sqlite3_open_v2(NS_ConvertUTF16toUTF8(path).get(), &mDBConn, mFlags,
1095 "readonly-immutable-nolock");
1096 } else {
1097 srv = ::sqlite3_open_v2(NS_ConvertUTF16toUTF8(path).get(), &mDBConn, mFlags,
1098 basevfs::GetVFSName(exclusive));
1099 if (exclusive && (srv == SQLITE_LOCKED6 || srv == SQLITE_BUSY5)) {
1100 // Retry without trying to get an exclusive lock.
1101 exclusive = false;
1102 srv = ::sqlite3_open_v2(NS_ConvertUTF16toUTF8(path).get(), &mDBConn,
1103 mFlags, basevfs::GetVFSName(false));
1104 }
1105 }
1106 if (srv != SQLITE_OK0) {
1107 mDBConn = nullptr;
1108 rv = convertResultCode(srv);
1109 RecordOpenStatus(rv);
1110 return rv;
1111 }
1112
1113 rv = initializeInternal();
1114 if (exclusive &&
1115 (rv == NS_ERROR_STORAGE_BUSY || rv == NS_ERROR_FILE_IS_LOCKED)) {
1116 // Usually SQLite will fail to acquire an exclusive lock on opening, but in
1117 // some cases it may successfully open the database and then lock on the
1118 // first query execution. When initializeInternal fails it closes the
1119 // connection, so we can try to restart it in non-exclusive mode.
1120 srv = ::sqlite3_open_v2(NS_ConvertUTF16toUTF8(path).get(), &mDBConn, mFlags,
1121 basevfs::GetVFSName(false));
1122 if (srv == SQLITE_OK0) {
1123 rv = initializeInternal();
1124 }
1125 }
1126
1127 RecordOpenStatus(rv);
1128 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1128); return rv; } } while (false)
;
1129
1130 return NS_OK;
1131}
1132
1133nsresult Connection::initialize(nsIFileURL* aFileURL) {
1134 NS_ASSERTION(aFileURL, "Passed null file URL!")do { if (!(aFileURL)) { NS_DebugBreak(NS_DEBUG_ASSERTION, "Passed null file URL!"
, "aFileURL", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1134); MOZ_PretendNoReturn(); } } while (0)
;
1135 NS_ASSERTION(!connectionReady(),do { if (!(!connectionReady())) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "Initialize called on already opened database!", "!connectionReady()"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1136); MOZ_PretendNoReturn(); } } while (0)
1136 "Initialize called on already opened database!")do { if (!(!connectionReady())) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "Initialize called on already opened database!", "!connectionReady()"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1136); MOZ_PretendNoReturn(); } } while (0)
;
1137 AUTO_PROFILER_LABEL("Connection::initialize", OTHER)mozilla::AutoProfilerLabel raiiObject1137( "Connection::initialize"
, nullptr, JS::ProfilingCategoryPair::OTHER)
;
1138
1139 nsCOMPtr<nsIFile> databaseFile;
1140 nsresult rv = aFileURL->GetFile(getter_AddRefs(databaseFile));
1141 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1141); return rv; } } while (false)
;
1142
1143 // Set both mDatabaseFile and mFileURL here.
1144 mFileURL = aFileURL;
1145 mDatabaseFile = databaseFile;
1146
1147 nsAutoCString spec;
1148 rv = aFileURL->GetSpec(spec);
1149 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1149); return rv; } } while (false)
;
1150
1151 // If there is a key specified, we need to use the obfuscating VFS.
1152 nsAutoCString query;
1153 rv = aFileURL->GetQuery(query);
1154 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1154); return rv; } } while (false)
;
1155
1156 bool hasKey = false;
1157 bool hasDirectoryLockId = false;
1158
1159 MOZ_ALWAYS_TRUE(do { if ((__builtin_expect(!!(URLParams::Parse(query, true, [
&hasKey, &hasDirectoryLockId]( const nsACString& aName
, const nsACString& aValue) { if (aName.EqualsLiteral("key"
)) { hasKey = true; return true; } if (aName.EqualsLiteral("directoryLockId"
)) { hasDirectoryLockId = true; return true; } return true; }
)), 1))) { } else { do { static_assert( mozilla::detail::AssertionConditionType
<decltype(false)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("false" " (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1172); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")"); do { *((volatile int*)__null) = 1172; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
1160 URLParams::Parse(query, true,do { if ((__builtin_expect(!!(URLParams::Parse(query, true, [
&hasKey, &hasDirectoryLockId]( const nsACString& aName
, const nsACString& aValue) { if (aName.EqualsLiteral("key"
)) { hasKey = true; return true; } if (aName.EqualsLiteral("directoryLockId"
)) { hasDirectoryLockId = true; return true; } return true; }
)), 1))) { } else { do { static_assert( mozilla::detail::AssertionConditionType
<decltype(false)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("false" " (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1172); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")"); do { *((volatile int*)__null) = 1172; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
1161 [&hasKey, &hasDirectoryLockId](do { if ((__builtin_expect(!!(URLParams::Parse(query, true, [
&hasKey, &hasDirectoryLockId]( const nsACString& aName
, const nsACString& aValue) { if (aName.EqualsLiteral("key"
)) { hasKey = true; return true; } if (aName.EqualsLiteral("directoryLockId"
)) { hasDirectoryLockId = true; return true; } return true; }
)), 1))) { } else { do { static_assert( mozilla::detail::AssertionConditionType
<decltype(false)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("false" " (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1172); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")"); do { *((volatile int*)__null) = 1172; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
1162 const nsACString& aName, const nsACString& aValue) {do { if ((__builtin_expect(!!(URLParams::Parse(query, true, [
&hasKey, &hasDirectoryLockId]( const nsACString& aName
, const nsACString& aValue) { if (aName.EqualsLiteral("key"
)) { hasKey = true; return true; } if (aName.EqualsLiteral("directoryLockId"
)) { hasDirectoryLockId = true; return true; } return true; }
)), 1))) { } else { do { static_assert( mozilla::detail::AssertionConditionType
<decltype(false)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("false" " (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1172); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")"); do { *((volatile int*)__null) = 1172; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
1163 if (aName.EqualsLiteral("key")) {do { if ((__builtin_expect(!!(URLParams::Parse(query, true, [
&hasKey, &hasDirectoryLockId]( const nsACString& aName
, const nsACString& aValue) { if (aName.EqualsLiteral("key"
)) { hasKey = true; return true; } if (aName.EqualsLiteral("directoryLockId"
)) { hasDirectoryLockId = true; return true; } return true; }
)), 1))) { } else { do { static_assert( mozilla::detail::AssertionConditionType
<decltype(false)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("false" " (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1172); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")"); do { *((volatile int*)__null) = 1172; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
1164 hasKey = true;do { if ((__builtin_expect(!!(URLParams::Parse(query, true, [
&hasKey, &hasDirectoryLockId]( const nsACString& aName
, const nsACString& aValue) { if (aName.EqualsLiteral("key"
)) { hasKey = true; return true; } if (aName.EqualsLiteral("directoryLockId"
)) { hasDirectoryLockId = true; return true; } return true; }
)), 1))) { } else { do { static_assert( mozilla::detail::AssertionConditionType
<decltype(false)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("false" " (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1172); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")"); do { *((volatile int*)__null) = 1172; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
1165 return true;do { if ((__builtin_expect(!!(URLParams::Parse(query, true, [
&hasKey, &hasDirectoryLockId]( const nsACString& aName
, const nsACString& aValue) { if (aName.EqualsLiteral("key"
)) { hasKey = true; return true; } if (aName.EqualsLiteral("directoryLockId"
)) { hasDirectoryLockId = true; return true; } return true; }
)), 1))) { } else { do { static_assert( mozilla::detail::AssertionConditionType
<decltype(false)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("false" " (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1172); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")"); do { *((volatile int*)__null) = 1172; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
1166 }do { if ((__builtin_expect(!!(URLParams::Parse(query, true, [
&hasKey, &hasDirectoryLockId]( const nsACString& aName
, const nsACString& aValue) { if (aName.EqualsLiteral("key"
)) { hasKey = true; return true; } if (aName.EqualsLiteral("directoryLockId"
)) { hasDirectoryLockId = true; return true; } return true; }
)), 1))) { } else { do { static_assert( mozilla::detail::AssertionConditionType
<decltype(false)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("false" " (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1172); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")"); do { *((volatile int*)__null) = 1172; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
1167 if (aName.EqualsLiteral("directoryLockId")) {do { if ((__builtin_expect(!!(URLParams::Parse(query, true, [
&hasKey, &hasDirectoryLockId]( const nsACString& aName
, const nsACString& aValue) { if (aName.EqualsLiteral("key"
)) { hasKey = true; return true; } if (aName.EqualsLiteral("directoryLockId"
)) { hasDirectoryLockId = true; return true; } return true; }
)), 1))) { } else { do { static_assert( mozilla::detail::AssertionConditionType
<decltype(false)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("false" " (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1172); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")"); do { *((volatile int*)__null) = 1172; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
1168 hasDirectoryLockId = true;do { if ((__builtin_expect(!!(URLParams::Parse(query, true, [
&hasKey, &hasDirectoryLockId]( const nsACString& aName
, const nsACString& aValue) { if (aName.EqualsLiteral("key"
)) { hasKey = true; return true; } if (aName.EqualsLiteral("directoryLockId"
)) { hasDirectoryLockId = true; return true; } return true; }
)), 1))) { } else { do { static_assert( mozilla::detail::AssertionConditionType
<decltype(false)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("false" " (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1172); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")"); do { *((volatile int*)__null) = 1172; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
1169 return true;do { if ((__builtin_expect(!!(URLParams::Parse(query, true, [
&hasKey, &hasDirectoryLockId]( const nsACString& aName
, const nsACString& aValue) { if (aName.EqualsLiteral("key"
)) { hasKey = true; return true; } if (aName.EqualsLiteral("directoryLockId"
)) { hasDirectoryLockId = true; return true; } return true; }
)), 1))) { } else { do { static_assert( mozilla::detail::AssertionConditionType
<decltype(false)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("false" " (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1172); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")"); do { *((volatile int*)__null) = 1172; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
1170 }do { if ((__builtin_expect(!!(URLParams::Parse(query, true, [
&hasKey, &hasDirectoryLockId]( const nsACString& aName
, const nsACString& aValue) { if (aName.EqualsLiteral("key"
)) { hasKey = true; return true; } if (aName.EqualsLiteral("directoryLockId"
)) { hasDirectoryLockId = true; return true; } return true; }
)), 1))) { } else { do { static_assert( mozilla::detail::AssertionConditionType
<decltype(false)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("false" " (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1172); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")"); do { *((volatile int*)__null) = 1172; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
1171 return true;do { if ((__builtin_expect(!!(URLParams::Parse(query, true, [
&hasKey, &hasDirectoryLockId]( const nsACString& aName
, const nsACString& aValue) { if (aName.EqualsLiteral("key"
)) { hasKey = true; return true; } if (aName.EqualsLiteral("directoryLockId"
)) { hasDirectoryLockId = true; return true; } return true; }
)), 1))) { } else { do { static_assert( mozilla::detail::AssertionConditionType
<decltype(false)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("false" " (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1172); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")"); do { *((volatile int*)__null) = 1172; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
1172 }))do { if ((__builtin_expect(!!(URLParams::Parse(query, true, [
&hasKey, &hasDirectoryLockId]( const nsACString& aName
, const nsACString& aValue) { if (aName.EqualsLiteral("key"
)) { hasKey = true; return true; } if (aName.EqualsLiteral("directoryLockId"
)) { hasDirectoryLockId = true; return true; } return true; }
)), 1))) { } else { do { static_assert( mozilla::detail::AssertionConditionType
<decltype(false)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("false" " (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1172); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "URLParams::Parse(query, true, [&hasKey, &hasDirectoryLockId]( const nsACString& aName, const nsACString& aValue) { if (aName.EqualsLiteral(\"key\")) { hasKey = true; return true; } if (aName.EqualsLiteral(\"directoryLockId\")) { hasDirectoryLockId = true; return true; } return true; })"
")"); do { *((volatile int*)__null) = 1172; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
;
1173
1174 bool exclusive =
1175 StaticPrefs::storage_sqlite_exclusiveLock_enabled() && !mOpenNotExclusive;
1176
1177 const char* const vfs = hasKey ? obfsvfs::GetVFSName()
1178 : hasDirectoryLockId ? quotavfs::GetVFSName()
1179 : basevfs::GetVFSName(exclusive);
1180
1181 int srv = ::sqlite3_open_v2(spec.get(), &mDBConn, mFlags, vfs);
1182 if (srv != SQLITE_OK0) {
1183 mDBConn = nullptr;
1184 rv = convertResultCode(srv);
1185 RecordOpenStatus(rv);
1186 return rv;
1187 }
1188
1189 rv = initializeInternal();
1190 RecordOpenStatus(rv);
1191 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1191); return rv; } } while (false)
;
1192
1193 return NS_OK;
1194}
1195
1196nsresult Connection::initializeInternal() {
1197 MOZ_ASSERT(mDBConn)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mDBConn)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mDBConn))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("mDBConn", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1197); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mDBConn" ")"
); do { *((volatile int*)__null) = 1197; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1198 auto guard = MakeScopeExit([&]() { initializeFailed(); });
1199
1200 mConnectionClosed = false;
1201
1202#ifdef MOZ_SQLITE_FTS3_TOKENIZER
1203 DebugOnly<int> srv2 =
1204 ::sqlite3_db_config(mDBConn, SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER1004, 1, 0);
1205 MOZ_ASSERT(srv2 == SQLITE_OK,do { static_assert( mozilla::detail::AssertionConditionType<
decltype(srv2 == 0)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(srv2 == 0))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("srv2 == 0" " (" "SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER should be enabled"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1206); AnnotateMozCrashReason("MOZ_ASSERT" "(" "srv2 == 0" ") ("
"SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER should be enabled" ")"
); do { *((volatile int*)__null) = 1206; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
1206 "SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER should be enabled")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(srv2 == 0)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(srv2 == 0))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("srv2 == 0" " (" "SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER should be enabled"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1206); AnnotateMozCrashReason("MOZ_ASSERT" "(" "srv2 == 0" ") ("
"SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER should be enabled" ")"
); do { *((volatile int*)__null) = 1206; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1207#endif
1208
1209 // Properly wrap the database handle's mutex.
1210 sharedDBMutex.initWithMutex(sqlite3_db_mutex(mDBConn));
1211
1212 // SQLite tracing can slow down queries (especially long queries)
1213 // significantly. Don't trace unless the user is actively monitoring SQLite.
1214 if (MOZ_LOG_TEST(gStorageLog, LogLevel::Debug)(__builtin_expect(!!(mozilla::detail::log_test(gStorageLog, LogLevel
::Debug)), 0))
) {
1215 ::sqlite3_trace_v2(mDBConn, SQLITE_TRACE_STMT0x01 | SQLITE_TRACE_PROFILE0x02,
1216 tracefunc, this);
1217
1218 MOZ_LOG(do { const ::mozilla::LogModule* moz_real_module = gStorageLog
; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Debug)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Debug, "Opening connection to '%s' (%p)", mTelemetryFilename
.get(), this); } } while (0)
1219 gStorageLog, LogLevel::Debug,do { const ::mozilla::LogModule* moz_real_module = gStorageLog
; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Debug)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Debug, "Opening connection to '%s' (%p)", mTelemetryFilename
.get(), this); } } while (0)
1220 ("Opening connection to '%s' (%p)", mTelemetryFilename.get(), this))do { const ::mozilla::LogModule* moz_real_module = gStorageLog
; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Debug)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Debug, "Opening connection to '%s' (%p)", mTelemetryFilename
.get(), this); } } while (0)
;
1221 }
1222
1223 int64_t pageSize = Service::kDefaultPageSize;
1224
1225 // Set page_size to the preferred default value. This is effective only if
1226 // the database has just been created, otherwise, if the database does not
1227 // use WAL journal mode, a VACUUM operation will updated its page_size.
1228 nsAutoCString pageSizeQuery(MOZ_STORAGE_UNIQUIFY_QUERY_STR"/* " "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
" */ "
1229 "PRAGMA page_size = ");
1230 pageSizeQuery.AppendInt(pageSize);
1231 int srv = executeSql(mDBConn, pageSizeQuery.get());
1232 if (srv != SQLITE_OK0) {
1233 return convertResultCode(srv);
1234 }
1235
1236 // Setting the cache_size forces the database open, verifying if it is valid
1237 // or corrupt. So this is executed regardless it being actually needed.
1238 // The cache_size is calculated from the actual page_size, to save memory.
1239 nsAutoCString cacheSizeQuery(MOZ_STORAGE_UNIQUIFY_QUERY_STR"/* " "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
" */ "
1240 "PRAGMA cache_size = ");
1241 cacheSizeQuery.AppendInt(-MAX_CACHE_SIZE_KIBIBYTES2048);
1242 srv = executeSql(mDBConn, cacheSizeQuery.get());
1243 if (srv != SQLITE_OK0) {
1244 return convertResultCode(srv);
1245 }
1246
1247 // Register our built-in SQL functions.
1248 srv = registerFunctions(mDBConn);
1249 if (srv != SQLITE_OK0) {
1250 return convertResultCode(srv);
1251 }
1252
1253 // Register our built-in SQL collating sequences.
1254 srv = registerCollations(mDBConn, mStorageService);
1255 if (srv != SQLITE_OK0) {
1256 return convertResultCode(srv);
1257 }
1258
1259 // Set the default synchronous value. Each consumer can switch this
1260 // accordingly to their needs.
1261#if defined(ANDROID)
1262 // Android prefers synchronous = OFF for performance reasons.
1263 Unused << ExecuteSimpleSQL("PRAGMA synchronous = OFF;"_ns);
1264#else
1265 // Normal is the suggested value for WAL journals.
1266 Unused << ExecuteSimpleSQL("PRAGMA synchronous = NORMAL;"_ns);
1267#endif
1268
1269 // Initialization succeeded, we can stop guarding for failures.
1270 guard.release();
1271 return NS_OK;
1272}
1273
1274nsresult Connection::initializeOnAsyncThread(nsIFile* aStorageFile) {
1275 MOZ_ASSERT(!IsOnCurrentSerialEventTarget(eventTargetOpenedOn))do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!IsOnCurrentSerialEventTarget(eventTargetOpenedOn))>
::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(!IsOnCurrentSerialEventTarget(eventTargetOpenedOn)))
), 0))) { do { } while (false); MOZ_ReportAssertionFailure("!IsOnCurrentSerialEventTarget(eventTargetOpenedOn)"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1275); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!IsOnCurrentSerialEventTarget(eventTargetOpenedOn)"
")"); do { *((volatile int*)__null) = 1275; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1276 nsresult rv = aStorageFile
1277 ? initialize(aStorageFile)
1278 : initialize(kMozStorageMemoryStorageKey, VoidCString());
1279 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
1280 // Shutdown the async thread, since initialization failed.
1281 MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
1282 mAsyncExecutionThreadShuttingDown = true;
1283 nsCOMPtr<nsIRunnable> event =
1284 NewRunnableMethod("Connection::shutdownAsyncThread", this,
1285 &Connection::shutdownAsyncThread);
1286 Unused << NS_DispatchToMainThread(event);
1287 }
1288 return rv;
1289}
1290
1291void Connection::initializeFailed() {
1292 {
1293 MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
1294 mConnectionClosed = true;
1295 }
1296 MOZ_ALWAYS_TRUE(::sqlite3_close(mDBConn) == SQLITE_OK)do { if ((__builtin_expect(!!(::sqlite3_close(mDBConn) == 0),
1))) { } else { do { static_assert( mozilla::detail::AssertionConditionType
<decltype(false)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("false" " (" "::sqlite3_close(mDBConn) == SQLITE_OK"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1296); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "::sqlite3_close(mDBConn) == SQLITE_OK" ")"); do { *((
volatile int*)__null) = 1296; __attribute__((nomerge)) ::abort
(); } while (false); } } while (false); } } while (false)
;
1297 mDBConn = nullptr;
1298 sharedDBMutex.destroy();
1299}
1300
1301nsresult Connection::databaseElementExists(
1302 enum DatabaseElementType aElementType, const nsACString& aElementName,
1303 bool* _exists) {
1304 if (!connectionReady()) {
1305 return NS_ERROR_NOT_AVAILABLE;
1306 }
1307 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
1308 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
1309 return rv;
1310 }
1311
1312 // When constructing the query, make sure to SELECT the correct db's
1313 // sqlite_master if the user is prefixing the element with a specific db. ex:
1314 // sample.test
1315 nsCString query("SELECT name FROM (SELECT * FROM ");
1316 nsDependentCSubstring element;
1317 int32_t ind = aElementName.FindChar('.');
1318 if (ind == kNotFound) {
1319 element.Assign(aElementName);
1320 } else {
1321 nsDependentCSubstring db(Substring(aElementName, 0, ind + 1));
1322 element.Assign(Substring(aElementName, ind + 1, aElementName.Length()));
1323 query.Append(db);
1324 }
1325 query.AppendLiteral(
1326 "sqlite_master UNION ALL SELECT * FROM sqlite_temp_master) WHERE type = "
1327 "'");
1328
1329 switch (aElementType) {
1330 case INDEX:
1331 query.AppendLiteral("index");
1332 break;
1333 case TABLE:
1334 query.AppendLiteral("table");
1335 break;
1336 }
1337 query.AppendLiteral("' AND name ='");
1338 query.Append(element);
1339 query.Append('\'');
1340
1341 sqlite3_stmt* stmt;
1342 int srv = prepareStatement(mDBConn, query, &stmt);
1343 if (srv != SQLITE_OK0) {
1344 RecordQueryStatus(srv);
1345 return convertResultCode(srv);
1346 }
1347
1348 srv = stepStatement(mDBConn, stmt);
1349 // we just care about the return value from step
1350 (void)::sqlite3_finalize(stmt);
1351
1352 RecordQueryStatus(srv);
1353
1354 if (srv == SQLITE_ROW100) {
1355 *_exists = true;
1356 return NS_OK;
1357 }
1358 if (srv == SQLITE_DONE101) {
1359 *_exists = false;
1360 return NS_OK;
1361 }
1362
1363 return convertResultCode(srv);
1364}
1365
1366bool Connection::findFunctionByInstance(mozIStorageFunction* aInstance) {
1367 sharedDBMutex.assertCurrentThreadOwns();
1368
1369 for (const auto& data : mFunctions.Values()) {
1370 if (data.function == aInstance) {
1371 return true;
1372 }
1373 }
1374 return false;
1375}
1376
1377/* static */
1378int Connection::sProgressHelper(void* aArg) {
1379 Connection* _this = static_cast<Connection*>(aArg);
1380 return _this->progressHandler();
1381}
1382
1383int Connection::progressHandler() {
1384 sharedDBMutex.assertCurrentThreadOwns();
1385 if (mProgressHandler) {
1386 bool result;
1387 nsresult rv = mProgressHandler->OnProgress(this, &result);
1388 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) return 0; // Don't break request
1389 return result ? 1 : 0;
1390 }
1391 return 0;
1392}
1393
1394nsresult Connection::setClosedState() {
1395 // Flag that we are shutting down the async thread, so that
1396 // getAsyncExecutionTarget knows not to expose/create the async thread.
1397 MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
1398 NS_ENSURE_FALSE(mAsyncExecutionThreadShuttingDown, NS_ERROR_UNEXPECTED)do { if ((__builtin_expect(!!(!(!(mAsyncExecutionThreadShuttingDown
))), 0))) { NS_DebugBreak(NS_DEBUG_WARNING, "NS_ENSURE_TRUE("
"!(mAsyncExecutionThreadShuttingDown)" ") failed", nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1398); return NS_ERROR_UNEXPECTED; } } while (false)
;
1399
1400 mAsyncExecutionThreadShuttingDown = true;
1401
1402 // Set the property to null before closing the connection, otherwise the
1403 // other functions in the module may try to use the connection after it is
1404 // closed.
1405 mDBConn = nullptr;
1406
1407 return NS_OK;
1408}
1409
1410bool Connection::operationSupported(ConnectionOperation aOperationType) {
1411 if (aOperationType == ASYNCHRONOUS) {
1412 // Async operations are supported for all connections, on any thread.
1413 return true;
1414 }
1415 // Sync operations are supported for sync connections (on any thread), and
1416 // async connections on a background thread.
1417 MOZ_ASSERT(aOperationType == SYNCHRONOUS)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aOperationType == SYNCHRONOUS)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aOperationType == SYNCHRONOUS
))), 0))) { do { } while (false); MOZ_ReportAssertionFailure(
"aOperationType == SYNCHRONOUS", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1417); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aOperationType == SYNCHRONOUS"
")"); do { *((volatile int*)__null) = 1417; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1418 return mSupportedOperations == SYNCHRONOUS || !NS_IsMainThread();
1419}
1420
1421nsresult Connection::ensureOperationSupported(
1422 ConnectionOperation aOperationType) {
1423 if (NS_WARN_IF(!operationSupported(aOperationType))NS_warn_if_impl(!operationSupported(aOperationType), "!operationSupported(aOperationType)"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1423)
) {
1424#ifdef DEBUG1
1425 if (NS_IsMainThread()) {
1426 nsCOMPtr<nsIXPConnect> xpc = nsIXPConnect::XPConnect();
1427 Unused << xpc->DebugDumpJSStack(false, false, false);
1428 }
1429#endif
1430 MOZ_ASSERT(false,do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false" " (" "Don't use async connections synchronously on the main thread"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1431); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") ("
"Don't use async connections synchronously on the main thread"
")"); do { *((volatile int*)__null) = 1431; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
1431 "Don't use async connections synchronously on the main thread")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false" " (" "Don't use async connections synchronously on the main thread"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1431); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") ("
"Don't use async connections synchronously on the main thread"
")"); do { *((volatile int*)__null) = 1431; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1432 return NS_ERROR_NOT_AVAILABLE;
1433 }
1434 return NS_OK;
1435}
1436
1437bool Connection::isConnectionReadyOnThisThread() {
1438 MOZ_ASSERT_IF(connectionReady(), !mConnectionClosed)do { if (connectionReady()) { do { static_assert( mozilla::detail
::AssertionConditionType<decltype(!mConnectionClosed)>::
isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(!mConnectionClosed))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("!mConnectionClosed", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1438); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mConnectionClosed"
")"); do { *((volatile int*)__null) = 1438; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
;
1439 if (mAsyncExecutionThread && mAsyncExecutionThread->IsOnCurrentThread()) {
1440 return true;
1441 }
1442 return connectionReady();
1443}
1444
1445bool Connection::isClosing() {
1446 MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
1447 return mAsyncExecutionThreadShuttingDown && !mConnectionClosed;
1448}
1449
1450bool Connection::isClosed() {
1451 MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
1452 return mConnectionClosed;
1453}
1454
1455bool Connection::isClosed(MutexAutoLock& lock) { return mConnectionClosed; }
1456
1457bool Connection::isAsyncExecutionThreadAvailable() {
1458 MOZ_ASSERT(IsOnCurrentSerialEventTarget(eventTargetOpenedOn))do { static_assert( mozilla::detail::AssertionConditionType<
decltype(IsOnCurrentSerialEventTarget(eventTargetOpenedOn))>
::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(IsOnCurrentSerialEventTarget(eventTargetOpenedOn))))
, 0))) { do { } while (false); MOZ_ReportAssertionFailure("IsOnCurrentSerialEventTarget(eventTargetOpenedOn)"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1458); AnnotateMozCrashReason("MOZ_ASSERT" "(" "IsOnCurrentSerialEventTarget(eventTargetOpenedOn)"
")"); do { *((volatile int*)__null) = 1458; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1459 return mAsyncExecutionThread && !mAsyncExecutionThreadShuttingDown;
1460}
1461
1462void Connection::shutdownAsyncThread() {
1463 MOZ_ASSERT(IsOnCurrentSerialEventTarget(eventTargetOpenedOn))do { static_assert( mozilla::detail::AssertionConditionType<
decltype(IsOnCurrentSerialEventTarget(eventTargetOpenedOn))>
::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(IsOnCurrentSerialEventTarget(eventTargetOpenedOn))))
, 0))) { do { } while (false); MOZ_ReportAssertionFailure("IsOnCurrentSerialEventTarget(eventTargetOpenedOn)"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1463); AnnotateMozCrashReason("MOZ_ASSERT" "(" "IsOnCurrentSerialEventTarget(eventTargetOpenedOn)"
")"); do { *((volatile int*)__null) = 1463; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1464 MOZ_ASSERT(mAsyncExecutionThread)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mAsyncExecutionThread)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mAsyncExecutionThread))), 0)
)) { do { } while (false); MOZ_ReportAssertionFailure("mAsyncExecutionThread"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1464); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mAsyncExecutionThread"
")"); do { *((volatile int*)__null) = 1464; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1465 MOZ_ASSERT(mAsyncExecutionThreadShuttingDown)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mAsyncExecutionThreadShuttingDown)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mAsyncExecutionThreadShuttingDown
))), 0))) { do { } while (false); MOZ_ReportAssertionFailure(
"mAsyncExecutionThreadShuttingDown", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1465); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mAsyncExecutionThreadShuttingDown"
")"); do { *((volatile int*)__null) = 1465; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1466
1467 MOZ_ALWAYS_SUCCEEDS(mAsyncExecutionThread->Shutdown())do { if ((__builtin_expect(!!(((bool)(__builtin_expect(!!(!NS_FAILED_impl
(mAsyncExecutionThread->Shutdown())), 1)))), 1))) { } else
{ do { static_assert( mozilla::detail::AssertionConditionType
<decltype(false)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("false" " (" "NS_SUCCEEDED(mAsyncExecutionThread->Shutdown())"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1467); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "NS_SUCCEEDED(mAsyncExecutionThread->Shutdown())" ")"
); do { *((volatile int*)__null) = 1467; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
;
1468 mAsyncExecutionThread = nullptr;
1469}
1470
1471nsresult Connection::internalClose(sqlite3* aNativeConnection) {
1472#ifdef DEBUG1
1473 { // Make sure we have marked our async thread as shutting down.
1474 MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
1475 MOZ_ASSERT(mAsyncExecutionThreadShuttingDown,do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mAsyncExecutionThreadShuttingDown)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mAsyncExecutionThreadShuttingDown
))), 0))) { do { } while (false); MOZ_ReportAssertionFailure(
"mAsyncExecutionThreadShuttingDown" " (" "Did not call setClosedState!"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1476); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mAsyncExecutionThreadShuttingDown"
") (" "Did not call setClosedState!" ")"); do { *((volatile int
*)__null) = 1476; __attribute__((nomerge)) ::abort(); } while
(false); } } while (false)
1476 "Did not call setClosedState!")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mAsyncExecutionThreadShuttingDown)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mAsyncExecutionThreadShuttingDown
))), 0))) { do { } while (false); MOZ_ReportAssertionFailure(
"mAsyncExecutionThreadShuttingDown" " (" "Did not call setClosedState!"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1476); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mAsyncExecutionThreadShuttingDown"
") (" "Did not call setClosedState!" ")"); do { *((volatile int
*)__null) = 1476; __attribute__((nomerge)) ::abort(); } while
(false); } } while (false)
;
1477 MOZ_ASSERT(!isClosed(lockedScope), "Unexpected closed state")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!isClosed(lockedScope))>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!isClosed(lockedScope)))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("!isClosed(lockedScope)"
" (" "Unexpected closed state" ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1477); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!isClosed(lockedScope)"
") (" "Unexpected closed state" ")"); do { *((volatile int*)
__null) = 1477; __attribute__((nomerge)) ::abort(); } while (
false); } } while (false)
;
1478 }
1479#endif // DEBUG
1480
1481 if (MOZ_LOG_TEST(gStorageLog, LogLevel::Debug)(__builtin_expect(!!(mozilla::detail::log_test(gStorageLog, LogLevel
::Debug)), 0))
) {
1482 nsAutoCString leafName(":memory");
1483 if (mDatabaseFile) (void)mDatabaseFile->GetNativeLeafName(leafName);
1484 MOZ_LOG(gStorageLog, LogLevel::Debug,do { const ::mozilla::LogModule* moz_real_module = gStorageLog
; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Debug)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Debug, "Closing connection to '%s'", leafName.get
()); } } while (0)
1485 ("Closing connection to '%s'", leafName.get()))do { const ::mozilla::LogModule* moz_real_module = gStorageLog
; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Debug)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Debug, "Closing connection to '%s'", leafName.get
()); } } while (0)
;
1486 }
1487
1488 // At this stage, we may still have statements that need to be
1489 // finalized. Attempt to close the database connection. This will
1490 // always disconnect any virtual tables and cleanly finalize their
1491 // internal statements. Once this is done, closing may fail due to
1492 // unfinalized client statements, in which case we need to finalize
1493 // these statements and close again.
1494 {
1495 MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
1496 mConnectionClosed = true;
1497 }
1498
1499 // Nothing else needs to be done if we don't have a connection here.
1500 if (!aNativeConnection) return NS_OK;
1501
1502 int srv = ::sqlite3_close(aNativeConnection);
1503
1504 if (srv == SQLITE_BUSY5) {
1505 {
1506 // Nothing else should change the connection or statements status until we
1507 // are done here.
1508 SQLiteMutexAutoLock lockedScope(sharedDBMutex);
1509 // We still have non-finalized statements. Finalize them.
1510 sqlite3_stmt* stmt = nullptr;
1511 while ((stmt = ::sqlite3_next_stmt(aNativeConnection, stmt))) {
1512 MOZ_LOG(gStorageLog, LogLevel::Debug,do { const ::mozilla::LogModule* moz_real_module = gStorageLog
; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Debug)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Debug, "Auto-finalizing SQL statement '%s' (%p)",
::sqlite3_sql(stmt), stmt); } } while (0)
1513 ("Auto-finalizing SQL statement '%s' (%p)", ::sqlite3_sql(stmt),do { const ::mozilla::LogModule* moz_real_module = gStorageLog
; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Debug)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Debug, "Auto-finalizing SQL statement '%s' (%p)",
::sqlite3_sql(stmt), stmt); } } while (0)
1514 stmt))do { const ::mozilla::LogModule* moz_real_module = gStorageLog
; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Debug)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Debug, "Auto-finalizing SQL statement '%s' (%p)",
::sqlite3_sql(stmt), stmt); } } while (0)
;
1515
1516#ifdef DEBUG1
1517 SmprintfPointer msg = ::mozilla::Smprintf(
1518 "SQL statement '%s' (%p) should have been finalized before closing "
1519 "the connection",
1520 ::sqlite3_sql(stmt), stmt);
1521 NS_WARNING(msg.get())NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1521)
;
1522#endif // DEBUG
1523
1524 srv = ::sqlite3_finalize(stmt);
1525
1526#ifdef DEBUG1
1527 if (srv != SQLITE_OK0) {
1528 SmprintfPointer msg = ::mozilla::Smprintf(
1529 "Could not finalize SQL statement (%p)", stmt);
1530 NS_WARNING(msg.get())NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1530)
;
1531 }
1532#endif // DEBUG
1533
1534 // Ensure that the loop continues properly, whether closing has
1535 // succeeded or not.
1536 if (srv == SQLITE_OK0) {
1537 stmt = nullptr;
1538 }
1539 }
1540 // Scope exiting will unlock the mutex before we invoke sqlite3_close()
1541 // again, since Sqlite will try to acquire it.
1542 }
1543
1544 // Now that all statements have been finalized, we
1545 // should be able to close.
1546 srv = ::sqlite3_close(aNativeConnection);
Value stored to 'srv' is never read
1547 MOZ_ASSERT(false,do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false" " (" "Had to forcibly close the database connection because not all "
"the statements have been finalized." ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1549); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") ("
"Had to forcibly close the database connection because not all "
"the statements have been finalized." ")"); do { *((volatile
int*)__null) = 1549; __attribute__((nomerge)) ::abort(); } while
(false); } } while (false)
1548 "Had to forcibly close the database connection because not all "do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false" " (" "Had to forcibly close the database connection because not all "
"the statements have been finalized." ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1549); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") ("
"Had to forcibly close the database connection because not all "
"the statements have been finalized." ")"); do { *((volatile
int*)__null) = 1549; __attribute__((nomerge)) ::abort(); } while
(false); } } while (false)
1549 "the statements have been finalized.")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false" " (" "Had to forcibly close the database connection because not all "
"the statements have been finalized." ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1549); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") ("
"Had to forcibly close the database connection because not all "
"the statements have been finalized." ")"); do { *((volatile
int*)__null) = 1549; __attribute__((nomerge)) ::abort(); } while
(false); } } while (false)
;
1550 }
1551
1552 if (srv == SQLITE_OK0) {
1553 sharedDBMutex.destroy();
1554 } else {
1555 MOZ_ASSERT(false,do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false" " (" "sqlite3_close failed. There are probably outstanding "
"statements that are listed above!" ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1557); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") ("
"sqlite3_close failed. There are probably outstanding " "statements that are listed above!"
")"); do { *((volatile int*)__null) = 1557; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
1556 "sqlite3_close failed. There are probably outstanding "do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false" " (" "sqlite3_close failed. There are probably outstanding "
"statements that are listed above!" ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1557); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") ("
"sqlite3_close failed. There are probably outstanding " "statements that are listed above!"
")"); do { *((volatile int*)__null) = 1557; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
1557 "statements that are listed above!")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false" " (" "sqlite3_close failed. There are probably outstanding "
"statements that are listed above!" ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1557); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") ("
"sqlite3_close failed. There are probably outstanding " "statements that are listed above!"
")"); do { *((volatile int*)__null) = 1557; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1558 }
1559
1560 return convertResultCode(srv);
1561}
1562
1563nsCString Connection::getFilename() { return mTelemetryFilename; }
1564
1565int Connection::stepStatement(sqlite3* aNativeConnection,
1566 sqlite3_stmt* aStatement) {
1567 MOZ_ASSERT(aStatement)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aStatement)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aStatement))), 0))) { do { }
while (false); MOZ_ReportAssertionFailure("aStatement", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1567); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aStatement"
")"); do { *((volatile int*)__null) = 1567; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1568
1569 AUTO_PROFILER_LABEL_DYNAMIC_CSTR("Connection::stepStatement", OTHER,mozilla::AutoProfilerLabel raiiObject1570( "Connection::stepStatement"
, ::sqlite3_sql(aStatement), JS::ProfilingCategoryPair::OTHER
)
1570 ::sqlite3_sql(aStatement))mozilla::AutoProfilerLabel raiiObject1570( "Connection::stepStatement"
, ::sqlite3_sql(aStatement), JS::ProfilingCategoryPair::OTHER
)
;
1571
1572 bool checkedMainThread = false;
1573 TimeStamp startTime = TimeStamp::Now();
1574
1575 // The connection may have been closed if the executing statement has been
1576 // created and cached after a call to asyncClose() but before the actual
1577 // sqlite3_close(). This usually happens when other tasks using cached
1578 // statements are asynchronously scheduled for execution and any of them ends
1579 // up after asyncClose. See bug 728653 for details.
1580 if (!isConnectionReadyOnThisThread()) return SQLITE_MISUSE21;
1581
1582 (void)::sqlite3_extended_result_codes(aNativeConnection, 1);
1583
1584 int srv;
1585 while ((srv = ::sqlite3_step(aStatement)) == SQLITE_LOCKED_SHAREDCACHE(6 | (1<<8))) {
1586 if (!checkedMainThread) {
1587 checkedMainThread = true;
1588 if (::NS_IsMainThread()) {
1589 NS_WARNING("We won't allow blocking on the main thread!")NS_DebugBreak(NS_DEBUG_WARNING, "We won't allow blocking on the main thread!"
, nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1589)
;
1590 break;
1591 }
1592 }
1593
1594 srv = WaitForUnlockNotify(aNativeConnection);
1595 if (srv != SQLITE_OK0) {
1596 break;
1597 }
1598
1599 ::sqlite3_reset(aStatement);
1600 }
1601
1602 // Report very slow SQL statements to Telemetry
1603 TimeDuration duration = TimeStamp::Now() - startTime;
1604 const uint32_t threshold = NS_IsMainThread()
1605 ? Telemetry::kSlowSQLThresholdForMainThread
1606 : Telemetry::kSlowSQLThresholdForHelperThreads;
1607 if (duration.ToMilliseconds() >= threshold) {
1608 nsDependentCString statementString(::sqlite3_sql(aStatement));
1609 Telemetry::RecordSlowSQLStatement(
1610 statementString, mTelemetryFilename,
1611 static_cast<uint32_t>(duration.ToMilliseconds()));
1612 }
1613
1614 (void)::sqlite3_extended_result_codes(aNativeConnection, 0);
1615 // Drop off the extended result bits of the result code.
1616 return srv & 0xFF;
1617}
1618
1619int Connection::prepareStatement(sqlite3* aNativeConnection,
1620 const nsCString& aSQL, sqlite3_stmt** _stmt) {
1621 // We should not even try to prepare statements after the connection has
1622 // been closed.
1623 if (!isConnectionReadyOnThisThread()) return SQLITE_MISUSE21;
1624
1625 bool checkedMainThread = false;
1626
1627 (void)::sqlite3_extended_result_codes(aNativeConnection, 1);
1628
1629 int srv;
1630 while ((srv = ::sqlite3_prepare_v2(aNativeConnection, aSQL.get(), -1, _stmt,
1631 nullptr)) == SQLITE_LOCKED_SHAREDCACHE(6 | (1<<8))) {
1632 if (!checkedMainThread) {
1633 checkedMainThread = true;
1634 if (::NS_IsMainThread()) {
1635 NS_WARNING("We won't allow blocking on the main thread!")NS_DebugBreak(NS_DEBUG_WARNING, "We won't allow blocking on the main thread!"
, nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1635)
;
1636 break;
1637 }
1638 }
1639
1640 srv = WaitForUnlockNotify(aNativeConnection);
1641 if (srv != SQLITE_OK0) {
1642 break;
1643 }
1644 }
1645
1646 if (srv != SQLITE_OK0) {
1647 nsCString warnMsg;
1648 warnMsg.AppendLiteral("The SQL statement '");
1649 warnMsg.Append(aSQL);
1650 warnMsg.AppendLiteral("' could not be compiled due to an error: ");
1651 warnMsg.Append(::sqlite3_errmsg(aNativeConnection));
1652
1653#ifdef DEBUG1
1654 NS_WARNING(warnMsg.get())NS_DebugBreak(NS_DEBUG_WARNING, warnMsg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1654)
;
1655#endif
1656 MOZ_LOG(gStorageLog, LogLevel::Error, ("%s", warnMsg.get()))do { const ::mozilla::LogModule* moz_real_module = gStorageLog
; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Error)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Error, "%s", warnMsg.get()); } } while (0)
;
1657 }
1658
1659 (void)::sqlite3_extended_result_codes(aNativeConnection, 0);
1660 // Drop off the extended result bits of the result code.
1661 int rc = srv & 0xFF;
1662 // sqlite will return OK on a comment only string and set _stmt to nullptr.
1663 // The callers of this function are used to only checking the return value,
1664 // so it is safer to return an error code.
1665 if (rc == SQLITE_OK0 && *_stmt == nullptr) {
1666 return SQLITE_MISUSE21;
1667 }
1668
1669 return rc;
1670}
1671
1672int Connection::executeSql(sqlite3* aNativeConnection, const char* aSqlString) {
1673 if (!isConnectionReadyOnThisThread()) return SQLITE_MISUSE21;
1674
1675 AUTO_PROFILER_LABEL_DYNAMIC_CSTR("Connection::executeSql", OTHER, aSqlString)mozilla::AutoProfilerLabel raiiObject1675( "Connection::executeSql"
, aSqlString, JS::ProfilingCategoryPair::OTHER)
;
1676
1677 TimeStamp startTime = TimeStamp::Now();
1678 int srv =
1679 ::sqlite3_exec(aNativeConnection, aSqlString, nullptr, nullptr, nullptr);
1680 RecordQueryStatus(srv);
1681
1682 // Report very slow SQL statements to Telemetry
1683 TimeDuration duration = TimeStamp::Now() - startTime;
1684 const uint32_t threshold = NS_IsMainThread()
1685 ? Telemetry::kSlowSQLThresholdForMainThread
1686 : Telemetry::kSlowSQLThresholdForHelperThreads;
1687 if (duration.ToMilliseconds() >= threshold) {
1688 nsDependentCString statementString(aSqlString);
1689 Telemetry::RecordSlowSQLStatement(
1690 statementString, mTelemetryFilename,
1691 static_cast<uint32_t>(duration.ToMilliseconds()));
1692 }
1693
1694 return srv;
1695}
1696
1697////////////////////////////////////////////////////////////////////////////////
1698//// nsIInterfaceRequestor
1699
1700NS_IMETHODIMPnsresult
1701Connection::GetInterface(const nsIID& aIID, void** _result) {
1702 if (aIID.Equals(NS_GET_IID(nsIEventTarget)(nsIEventTarget::COMTypeInfo<nsIEventTarget, void>::kIID
)
)) {
1703 nsIEventTarget* background = getAsyncExecutionTarget();
1704 NS_IF_ADDREF(background)ns_if_addref(background);
1705 *_result = background;
1706 return NS_OK;
1707 }
1708 return NS_ERROR_NO_INTERFACE;
1709}
1710
1711////////////////////////////////////////////////////////////////////////////////
1712//// mozIStorageConnection
1713
1714NS_IMETHODIMPnsresult
1715Connection::Close() {
1716 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
1717 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
1718 return rv;
1719 }
1720 return synchronousClose();
1721}
1722
1723nsresult Connection::synchronousClose() {
1724 if (!connectionReady()) {
1725 return NS_ERROR_NOT_INITIALIZED;
1726 }
1727
1728#ifdef DEBUG1
1729 // Since we're accessing mAsyncExecutionThread, we need to be on the opener
1730 // event target. We make this check outside of debug code below in
1731 // setClosedState, but this is here to be explicit.
1732 MOZ_ASSERT(IsOnCurrentSerialEventTarget(eventTargetOpenedOn))do { static_assert( mozilla::detail::AssertionConditionType<
decltype(IsOnCurrentSerialEventTarget(eventTargetOpenedOn))>
::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(IsOnCurrentSerialEventTarget(eventTargetOpenedOn))))
, 0))) { do { } while (false); MOZ_ReportAssertionFailure("IsOnCurrentSerialEventTarget(eventTargetOpenedOn)"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1732); AnnotateMozCrashReason("MOZ_ASSERT" "(" "IsOnCurrentSerialEventTarget(eventTargetOpenedOn)"
")"); do { *((volatile int*)__null) = 1732; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1733#endif // DEBUG
1734
1735 // Make sure we have not executed any asynchronous statements.
1736 // If this fails, the mDBConn may be left open, resulting in a leak.
1737 // We'll try to finalize the pending statements and close the connection.
1738 if (isAsyncExecutionThreadAvailable()) {
1739#ifdef DEBUG1
1740 if (NS_IsMainThread()) {
1741 nsCOMPtr<nsIXPConnect> xpc = nsIXPConnect::XPConnect();
1742 Unused << xpc->DebugDumpJSStack(false, false, false);
1743 }
1744#endif
1745 MOZ_ASSERT(false,do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false" " (" "Close() was invoked on a connection that executed asynchronous "
"statements. " "Should have used asyncClose()." ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1748); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") ("
"Close() was invoked on a connection that executed asynchronous "
"statements. " "Should have used asyncClose()." ")"); do { *
((volatile int*)__null) = 1748; __attribute__((nomerge)) ::abort
(); } while (false); } } while (false)
1746 "Close() was invoked on a connection that executed asynchronous "do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false" " (" "Close() was invoked on a connection that executed asynchronous "
"statements. " "Should have used asyncClose()." ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1748); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") ("
"Close() was invoked on a connection that executed asynchronous "
"statements. " "Should have used asyncClose()." ")"); do { *
((volatile int*)__null) = 1748; __attribute__((nomerge)) ::abort
(); } while (false); } } while (false)
1747 "statements. "do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false" " (" "Close() was invoked on a connection that executed asynchronous "
"statements. " "Should have used asyncClose()." ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1748); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") ("
"Close() was invoked on a connection that executed asynchronous "
"statements. " "Should have used asyncClose()." ")"); do { *
((volatile int*)__null) = 1748; __attribute__((nomerge)) ::abort
(); } while (false); } } while (false)
1748 "Should have used asyncClose().")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false" " (" "Close() was invoked on a connection that executed asynchronous "
"statements. " "Should have used asyncClose()." ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1748); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") ("
"Close() was invoked on a connection that executed asynchronous "
"statements. " "Should have used asyncClose()." ")"); do { *
((volatile int*)__null) = 1748; __attribute__((nomerge)) ::abort
(); } while (false); } } while (false)
;
1749 // Try to close the database regardless, to free up resources.
1750 Unused << SpinningSynchronousClose();
1751 return NS_ERROR_UNEXPECTED;
1752 }
1753
1754 // setClosedState nullifies our connection pointer, so we take a raw pointer
1755 // off it, to pass it through the close procedure.
1756 sqlite3* nativeConn = mDBConn;
1757 nsresult rv = setClosedState();
1758 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1758); return rv; } } while (false)
;
1759
1760 return internalClose(nativeConn);
1761}
1762
1763NS_IMETHODIMPnsresult
1764Connection::SpinningSynchronousClose() {
1765 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
1766 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
1767 return rv;
1768 }
1769 if (!IsOnCurrentSerialEventTarget(eventTargetOpenedOn)) {
1770 return NS_ERROR_NOT_SAME_THREAD;
1771 }
1772
1773 // As currently implemented, we can't spin to wait for an existing AsyncClose.
1774 // Our only existing caller will never have called close; assert if misused
1775 // so that no new callers assume this works after an AsyncClose.
1776 MOZ_DIAGNOSTIC_ASSERT(connectionReady())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(connectionReady())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(connectionReady()))), 0))) {
do { } while (false); MOZ_ReportAssertionFailure("connectionReady()"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1776); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "connectionReady()"
")"); do { *((volatile int*)__null) = 1776; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1777 if (!connectionReady()) {
1778 return NS_ERROR_UNEXPECTED;
1779 }
1780
1781 RefPtr<CloseListener> listener = new CloseListener();
1782 rv = AsyncClose(listener);
1783 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1783); return rv; } } while (false)
;
1784 MOZ_ALWAYS_TRUE(do { if ((__builtin_expect(!!(SpinEventLoopUntil("storage::Connection::SpinningSynchronousClose"_ns
, [&]() { return listener->mClosed; })), 1))) { } else
{ do { static_assert( mozilla::detail::AssertionConditionType
<decltype(false)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("false" " (" "SpinEventLoopUntil(\"storage::Connection::SpinningSynchronousClose\"_ns, [&]() { return listener->mClosed; })"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1786); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "SpinEventLoopUntil(\"storage::Connection::SpinningSynchronousClose\"_ns, [&]() { return listener->mClosed; })"
")"); do { *((volatile int*)__null) = 1786; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
1785 SpinEventLoopUntil("storage::Connection::SpinningSynchronousClose"_ns,do { if ((__builtin_expect(!!(SpinEventLoopUntil("storage::Connection::SpinningSynchronousClose"_ns
, [&]() { return listener->mClosed; })), 1))) { } else
{ do { static_assert( mozilla::detail::AssertionConditionType
<decltype(false)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("false" " (" "SpinEventLoopUntil(\"storage::Connection::SpinningSynchronousClose\"_ns, [&]() { return listener->mClosed; })"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1786); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "SpinEventLoopUntil(\"storage::Connection::SpinningSynchronousClose\"_ns, [&]() { return listener->mClosed; })"
")"); do { *((volatile int*)__null) = 1786; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
1786 [&]() { return listener->mClosed; }))do { if ((__builtin_expect(!!(SpinEventLoopUntil("storage::Connection::SpinningSynchronousClose"_ns
, [&]() { return listener->mClosed; })), 1))) { } else
{ do { static_assert( mozilla::detail::AssertionConditionType
<decltype(false)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("false" " (" "SpinEventLoopUntil(\"storage::Connection::SpinningSynchronousClose\"_ns, [&]() { return listener->mClosed; })"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1786); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "SpinEventLoopUntil(\"storage::Connection::SpinningSynchronousClose\"_ns, [&]() { return listener->mClosed; })"
")"); do { *((volatile int*)__null) = 1786; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
;
1787 MOZ_ASSERT(isClosed(), "The connection should be closed at this point")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isClosed())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isClosed()))), 0))) { do { }
while (false); MOZ_ReportAssertionFailure("isClosed()" " (" "The connection should be closed at this point"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1787); AnnotateMozCrashReason("MOZ_ASSERT" "(" "isClosed()"
") (" "The connection should be closed at this point" ")"); do
{ *((volatile int*)__null) = 1787; __attribute__((nomerge)) ::
abort(); } while (false); } } while (false)
;
1788
1789 return rv;
1790}
1791
1792NS_IMETHODIMPnsresult
1793Connection::AsyncClose(mozIStorageCompletionCallback* aCallback) {
1794 NS_ENSURE_TRUE(NS_IsMainThread(), NS_ERROR_NOT_SAME_THREAD)do { if ((__builtin_expect(!!(!(NS_IsMainThread())), 0))) { NS_DebugBreak
(NS_DEBUG_WARNING, "NS_ENSURE_TRUE(" "NS_IsMainThread()" ") failed"
, nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1794); return NS_ERROR_NOT_SAME_THREAD; } } while (false)
;
1795 // Check if AsyncClose or Close were already invoked.
1796 if (!connectionReady()) {
1797 return NS_ERROR_NOT_INITIALIZED;
1798 }
1799 nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
1800 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
1801 return rv;
1802 }
1803
1804 // The two relevant factors at this point are whether we have a database
1805 // connection and whether we have an async execution thread. Here's what the
1806 // states mean and how we handle them:
1807 //
1808 // - (mDBConn && asyncThread): The expected case where we are either an
1809 // async connection or a sync connection that has been used asynchronously.
1810 // Either way the caller must call us and not Close(). Nothing surprising
1811 // about this. We'll dispatch AsyncCloseConnection to the already-existing
1812 // async thread.
1813 //
1814 // - (mDBConn && !asyncThread): A somewhat unusual case where the caller
1815 // opened the connection synchronously and was planning to use it
1816 // asynchronously, but never got around to using it asynchronously before
1817 // needing to shutdown. This has been observed to happen for the cookie
1818 // service in a case where Firefox shuts itself down almost immediately
1819 // after startup (for unknown reasons). In the Firefox shutdown case,
1820 // we may also fail to create a new async execution thread if one does not
1821 // already exist. (nsThreadManager will refuse to create new threads when
1822 // it has already been told to shutdown.) As such, we need to handle a
1823 // failure to create the async execution thread by falling back to
1824 // synchronous Close() and also dispatching the completion callback because
1825 // at least Places likes to spin a nested event loop that depends on the
1826 // callback being invoked.
1827 //
1828 // Note that we have considered not trying to spin up the async execution
1829 // thread in this case if it does not already exist, but the overhead of
1830 // thread startup (if successful) is significantly less expensive than the
1831 // worst-case potential I/O hit of synchronously closing a database when we
1832 // could close it asynchronously.
1833 //
1834 // - (!mDBConn && asyncThread): This happens in some but not all cases where
1835 // OpenAsyncDatabase encountered a problem opening the database. If it
1836 // happened in all cases AsyncInitDatabase would just shut down the thread
1837 // directly and we would avoid this case. But it doesn't, so for simplicity
1838 // and consistency AsyncCloseConnection knows how to handle this and we
1839 // act like this was the (mDBConn && asyncThread) case in this method.
1840 //
1841 // - (!mDBConn && !asyncThread): The database was never successfully opened or
1842 // Close() or AsyncClose() has already been called (at least) once. This is
1843 // undeniably a misuse case by the caller. We could optimize for this
1844 // case by adding an additional check of mAsyncExecutionThread without using
1845 // getAsyncExecutionTarget() to avoid wastefully creating a thread just to
1846 // shut it down. But this complicates the method for broken caller code
1847 // whereas we're still correct and safe without the special-case.
1848 nsIEventTarget* asyncThread = getAsyncExecutionTarget();
1849
1850 // Create our callback event if we were given a callback. This will
1851 // eventually be dispatched in all cases, even if we fall back to Close() and
1852 // the database wasn't open and we return an error. The rationale is that
1853 // no existing consumer checks our return value and several of them like to
1854 // spin nested event loops until the callback fires. Given that, it seems
1855 // preferable for us to dispatch the callback in all cases. (Except the
1856 // wrong thread misuse case we bailed on up above. But that's okay because
1857 // that is statically wrong whereas these edge cases are dynamic.)
1858 nsCOMPtr<nsIRunnable> completeEvent;
1859 if (aCallback) {
1860 completeEvent = newCompletionEvent(aCallback);
1861 }
1862
1863 if (!asyncThread) {
1864 // We were unable to create an async thread, so we need to fall back to
1865 // using normal Close(). Since there is no async thread, Close() will
1866 // not complain about that. (Close() may, however, complain if the
1867 // connection is closed, but that's okay.)
1868 if (completeEvent) {
1869 // Closing the database is more important than returning an error code
1870 // about a failure to dispatch, especially because all existing native
1871 // callers ignore our return value.
1872 Unused << NS_DispatchToMainThread(completeEvent.forget());
1873 }
1874 MOZ_ALWAYS_SUCCEEDS(synchronousClose())do { if ((__builtin_expect(!!(((bool)(__builtin_expect(!!(!NS_FAILED_impl
(synchronousClose())), 1)))), 1))) { } else { do { static_assert
( mozilla::detail::AssertionConditionType<decltype(false)>
::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(false))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("false" " (" "NS_SUCCEEDED(synchronousClose())" ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1874); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "NS_SUCCEEDED(synchronousClose())" ")"); do { *((volatile
int*)__null) = 1874; __attribute__((nomerge)) ::abort(); } while
(false); } } while (false); } } while (false)
;
1875 // Return a success inconditionally here, since Close() is unlikely to fail
1876 // and we want to reassure the consumer that its callback will be invoked.
1877 return NS_OK;
1878 }
1879
1880 // If we're closing the connection during shutdown, and there is an
1881 // interruptible statement running on the helper thread, issue a
1882 // sqlite3_interrupt() to avoid crashing when that statement takes a long
1883 // time (for example a vacuum).
1884 if (AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownConfirmed) &&
1885 mInterruptible && mIsStatementOnHelperThreadInterruptible) {
1886 MOZ_ASSERT(!isClosing(), "Must not be closing, see Interrupt()")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!isClosing())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!isClosing()))), 0))) { do {
} while (false); MOZ_ReportAssertionFailure("!isClosing()" " ("
"Must not be closing, see Interrupt()" ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1886); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!isClosing()"
") (" "Must not be closing, see Interrupt()" ")"); do { *((volatile
int*)__null) = 1886; __attribute__((nomerge)) ::abort(); } while
(false); } } while (false)
;
1887 DebugOnly<nsresult> rv2 = Interrupt();
1888 MOZ_ASSERT(NS_SUCCEEDED(rv2))do { static_assert( mozilla::detail::AssertionConditionType<
decltype(((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv2)), 1
))))>::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv2)), 1
)))))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv2)), 1)))", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1888); AnnotateMozCrashReason("MOZ_ASSERT" "(" "((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv2)), 1)))"
")"); do { *((volatile int*)__null) = 1888; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1889 }
1890
1891 // setClosedState nullifies our connection pointer, so we take a raw pointer
1892 // off it, to pass it through the close procedure.
1893 sqlite3* nativeConn = mDBConn;
1894 rv = setClosedState();
1895 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1895); return rv; } } while (false)
;
1896
1897 // Create and dispatch our close event to the background thread.
1898 nsCOMPtr<nsIRunnable> closeEvent =
1899 new AsyncCloseConnection(this, nativeConn, completeEvent);
1900 rv = asyncThread->Dispatch(closeEvent, NS_DISPATCH_NORMALnsIEventTarget::DISPATCH_NORMAL);
1901 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1901); return rv; } } while (false)
;
1902
1903 return NS_OK;
1904}
1905
1906NS_IMETHODIMPnsresult
1907Connection::AsyncClone(bool aReadOnly,
1908 mozIStorageCompletionCallback* aCallback) {
1909 AUTO_PROFILER_LABEL("Connection::AsyncClone", OTHER)mozilla::AutoProfilerLabel raiiObject1909( "Connection::AsyncClone"
, nullptr, JS::ProfilingCategoryPair::OTHER)
;
1910
1911 NS_ENSURE_TRUE(NS_IsMainThread(), NS_ERROR_NOT_SAME_THREAD)do { if ((__builtin_expect(!!(!(NS_IsMainThread())), 0))) { NS_DebugBreak
(NS_DEBUG_WARNING, "NS_ENSURE_TRUE(" "NS_IsMainThread()" ") failed"
, nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1911); return NS_ERROR_NOT_SAME_THREAD; } } while (false)
;
1912 if (!connectionReady()) {
1913 return NS_ERROR_NOT_INITIALIZED;
1914 }
1915 nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
1916 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
1917 return rv;
1918 }
1919 if (!mDatabaseFile) return NS_ERROR_UNEXPECTED;
1920
1921 int flags = mFlags;
1922 if (aReadOnly) {
1923 // Turn off SQLITE_OPEN_READWRITE, and set SQLITE_OPEN_READONLY.
1924 flags = (~SQLITE_OPEN_READWRITE0x00000002 & flags) | SQLITE_OPEN_READONLY0x00000001;
1925 // Turn off SQLITE_OPEN_CREATE.
1926 flags = (~SQLITE_OPEN_CREATE0x00000004 & flags);
1927 }
1928
1929 // The cloned connection will still implement the synchronous API, but throw
1930 // if any synchronous methods are called on the main thread.
1931 RefPtr<Connection> clone =
1932 new Connection(mStorageService, flags, ASYNCHRONOUS, mTelemetryFilename,
1933 mInterruptible, mIgnoreLockingMode, mOpenNotExclusive);
1934
1935 RefPtr<AsyncInitializeClone> initEvent =
1936 new AsyncInitializeClone(this, clone, aReadOnly, aCallback);
1937 // Dispatch to our async thread, since the originating connection must remain
1938 // valid and open for the whole cloning process. This also ensures we are
1939 // properly serialized with a `close` operation, rather than race with it.
1940 nsCOMPtr<nsIEventTarget> target = getAsyncExecutionTarget();
1941 if (!target) {
1942 return NS_ERROR_UNEXPECTED;
1943 }
1944 return target->Dispatch(initEvent, NS_DISPATCH_NORMALnsIEventTarget::DISPATCH_NORMAL);
1945}
1946
1947nsresult Connection::initializeClone(Connection* aClone, bool aReadOnly) {
1948 nsresult rv;
1949 if (!mStorageKey.IsEmpty()) {
1950 rv = aClone->initialize(mStorageKey, mName);
1951 } else if (mFileURL) {
1952 rv = aClone->initialize(mFileURL);
1953 } else {
1954 rv = aClone->initialize(mDatabaseFile);
1955 }
1956 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
1957 return rv;
1958 }
1959
1960 auto guard = MakeScopeExit([&]() { aClone->initializeFailed(); });
1961
1962 rv = aClone->SetDefaultTransactionType(mDefaultTransactionType);
1963 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1963); return rv; } } while (false)
;
1964
1965 // Re-attach on-disk databases that were attached to the original connection.
1966 {
1967 nsCOMPtr<mozIStorageStatement> stmt;
1968 rv = CreateStatement("PRAGMA database_list"_ns, getter_AddRefs(stmt));
1969 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1969); return rv; } } while (false)
;
1970 bool hasResult = false;
1971 while (stmt && NS_SUCCEEDED(stmt->ExecuteStep(&hasResult))((bool)(__builtin_expect(!!(!NS_FAILED_impl(stmt->ExecuteStep
(&hasResult))), 1)))
&& hasResult) {
1972 nsAutoCString name;
1973 rv = stmt->GetUTF8String(1, name);
1974 if (NS_SUCCEEDED(rv)((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1))) && !name.EqualsLiteral("main") &&
1975 !name.EqualsLiteral("temp")) {
1976 nsCString path;
1977 rv = stmt->GetUTF8String(2, path);
1978 if (NS_SUCCEEDED(rv)((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1))) && !path.IsEmpty()) {
1979 nsCOMPtr<mozIStorageStatement> attachStmt;
1980 rv = aClone->CreateStatement("ATTACH DATABASE :path AS "_ns + name,
1981 getter_AddRefs(attachStmt));
1982 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1982); return rv; } } while (false)
;
1983 rv = attachStmt->BindUTF8StringByName("path"_ns, path);
1984 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1984); return rv; } } while (false)
;
1985 rv = attachStmt->Execute();
1986 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 1986); return rv; } } while (false)
;
1987 }
1988 }
1989 }
1990 }
1991
1992 // Copy over pragmas from the original connection.
1993 // LIMITATION WARNING! Many of these pragmas are actually scoped to the
1994 // schema ("main" and any other attached databases), and this implmentation
1995 // fails to propagate them. This is being addressed on trunk.
1996 static const char* pragmas[] = {
1997 "cache_size", "temp_store", "foreign_keys", "journal_size_limit",
1998 "synchronous", "wal_autocheckpoint", "busy_timeout"};
1999 for (auto& pragma : pragmas) {
2000 // Read-only connections just need cache_size and temp_store pragmas.
2001 if (aReadOnly && ::strcmp(pragma, "cache_size") != 0 &&
2002 ::strcmp(pragma, "temp_store") != 0) {
2003 continue;
2004 }
2005
2006 nsAutoCString pragmaQuery("PRAGMA ");
2007 pragmaQuery.Append(pragma);
2008 nsCOMPtr<mozIStorageStatement> stmt;
2009 rv = CreateStatement(pragmaQuery, getter_AddRefs(stmt));
2010 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2010); return rv; } } while (false)
;
2011 bool hasResult = false;
2012 if (stmt && NS_SUCCEEDED(stmt->ExecuteStep(&hasResult))((bool)(__builtin_expect(!!(!NS_FAILED_impl(stmt->ExecuteStep
(&hasResult))), 1)))
&& hasResult) {
2013 pragmaQuery.AppendLiteral(" = ");
2014 pragmaQuery.AppendInt(stmt->AsInt32(0));
2015 rv = aClone->ExecuteSimpleSQL(pragmaQuery);
2016 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2016); return rv; } } while (false)
;
2017 }
2018 }
2019
2020 // Copy over temporary tables, triggers, and views from the original
2021 // connections. Entities in `sqlite_temp_master` are only visible to the
2022 // connection that created them.
2023 if (!aReadOnly) {
2024 rv = aClone->ExecuteSimpleSQL("BEGIN TRANSACTION"_ns);
2025 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2025); return rv; } } while (false)
;
2026
2027 nsCOMPtr<mozIStorageStatement> stmt;
2028 rv = CreateStatement(nsLiteralCString("SELECT sql FROM sqlite_temp_master "
2029 "WHERE type IN ('table', 'view', "
2030 "'index', 'trigger')"),
2031 getter_AddRefs(stmt));
2032 // Propagate errors, because failing to copy triggers might cause schema
2033 // coherency issues when writing to the database from the cloned connection.
2034 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2034); return rv; } } while (false)
;
2035 bool hasResult = false;
2036 while (stmt && NS_SUCCEEDED(stmt->ExecuteStep(&hasResult))((bool)(__builtin_expect(!!(!NS_FAILED_impl(stmt->ExecuteStep
(&hasResult))), 1)))
&& hasResult) {
2037 nsAutoCString query;
2038 rv = stmt->GetUTF8String(0, query);
2039 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2039); return rv; } } while (false)
;
2040
2041 // The `CREATE` SQL statements in `sqlite_temp_master` omit the `TEMP`
2042 // keyword. We need to add it back, or we'll recreate temporary entities
2043 // as persistent ones. `sqlite_temp_master` also holds `CREATE INDEX`
2044 // statements, but those don't need `TEMP` keywords.
2045 if (StringBeginsWith(query, "CREATE TABLE "_ns) ||
2046 StringBeginsWith(query, "CREATE TRIGGER "_ns) ||
2047 StringBeginsWith(query, "CREATE VIEW "_ns)) {
2048 query.Replace(0, 6, "CREATE TEMP");
2049 }
2050
2051 rv = aClone->ExecuteSimpleSQL(query);
2052 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2052); return rv; } } while (false)
;
2053 }
2054
2055 rv = aClone->ExecuteSimpleSQL("COMMIT"_ns);
2056 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2056); return rv; } } while (false)
;
2057 }
2058
2059 // Copy any functions that have been added to this connection.
2060 SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2061 for (const auto& entry : mFunctions) {
2062 const nsACString& key = entry.GetKey();
2063 Connection::FunctionInfo data = entry.GetData();
2064
2065 rv = aClone->CreateFunction(key, data.numArgs, data.function);
2066 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2067 NS_WARNING("Failed to copy function to cloned connection")NS_DebugBreak(NS_DEBUG_WARNING, "Failed to copy function to cloned connection"
, nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2067)
;
2068 }
2069 }
2070
2071 // Load SQLite extensions that were on this connection.
2072 // Copy into an array rather than holding the mutex while we load extensions.
2073 nsTArray<nsCString> loadedExtensions;
2074 {
2075 MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
2076 AppendToArray(loadedExtensions, mLoadedExtensions);
2077 }
2078 for (const auto& extension : loadedExtensions) {
2079 (void)aClone->LoadExtension(extension, nullptr);
2080 }
2081
2082 guard.release();
2083 return NS_OK;
2084}
2085
2086NS_IMETHODIMPnsresult
2087Connection::Clone(bool aReadOnly, mozIStorageConnection** _connection) {
2088 MOZ_ASSERT(IsOnCurrentSerialEventTarget(eventTargetOpenedOn))do { static_assert( mozilla::detail::AssertionConditionType<
decltype(IsOnCurrentSerialEventTarget(eventTargetOpenedOn))>
::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(IsOnCurrentSerialEventTarget(eventTargetOpenedOn))))
, 0))) { do { } while (false); MOZ_ReportAssertionFailure("IsOnCurrentSerialEventTarget(eventTargetOpenedOn)"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2088); AnnotateMozCrashReason("MOZ_ASSERT" "(" "IsOnCurrentSerialEventTarget(eventTargetOpenedOn)"
")"); do { *((volatile int*)__null) = 2088; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
2089
2090 AUTO_PROFILER_LABEL("Connection::Clone", OTHER)mozilla::AutoProfilerLabel raiiObject2090( "Connection::Clone"
, nullptr, JS::ProfilingCategoryPair::OTHER)
;
2091
2092 if (!connectionReady()) {
2093 return NS_ERROR_NOT_INITIALIZED;
2094 }
2095 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2096 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2097 return rv;
2098 }
2099
2100 int flags = mFlags;
2101 if (aReadOnly) {
2102 // Turn off SQLITE_OPEN_READWRITE, and set SQLITE_OPEN_READONLY.
2103 flags = (~SQLITE_OPEN_READWRITE0x00000002 & flags) | SQLITE_OPEN_READONLY0x00000001;
2104 // Turn off SQLITE_OPEN_CREATE.
2105 flags = (~SQLITE_OPEN_CREATE0x00000004 & flags);
2106 }
2107
2108 RefPtr<Connection> clone =
2109 new Connection(mStorageService, flags, mSupportedOperations,
2110 mTelemetryFilename, mInterruptible);
2111
2112 rv = initializeClone(clone, aReadOnly);
2113 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2114 return rv;
2115 }
2116
2117 NS_IF_ADDREF(*_connection = clone)ns_if_addref(*_connection = clone);
2118 return NS_OK;
2119}
2120
2121NS_IMETHODIMPnsresult
2122Connection::Interrupt() {
2123 MOZ_ASSERT(mInterruptible, "Interrupt method not allowed")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mInterruptible)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mInterruptible))), 0))) { do
{ } while (false); MOZ_ReportAssertionFailure("mInterruptible"
" (" "Interrupt method not allowed" ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2123); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mInterruptible"
") (" "Interrupt method not allowed" ")"); do { *((volatile int
*)__null) = 2123; __attribute__((nomerge)) ::abort(); } while
(false); } } while (false)
;
2124 MOZ_ASSERT_IF(SYNCHRONOUS == mSupportedOperations,do { if (SYNCHRONOUS == mSupportedOperations) { do { static_assert
( mozilla::detail::AssertionConditionType<decltype(!IsOnCurrentSerialEventTarget
(eventTargetOpenedOn))>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!IsOnCurrentSerialEventTarget
(eventTargetOpenedOn)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("!IsOnCurrentSerialEventTarget(eventTargetOpenedOn)", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2125); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!IsOnCurrentSerialEventTarget(eventTargetOpenedOn)"
")"); do { *((volatile int*)__null) = 2125; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
2125 !IsOnCurrentSerialEventTarget(eventTargetOpenedOn))do { if (SYNCHRONOUS == mSupportedOperations) { do { static_assert
( mozilla::detail::AssertionConditionType<decltype(!IsOnCurrentSerialEventTarget
(eventTargetOpenedOn))>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!IsOnCurrentSerialEventTarget
(eventTargetOpenedOn)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("!IsOnCurrentSerialEventTarget(eventTargetOpenedOn)", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2125); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!IsOnCurrentSerialEventTarget(eventTargetOpenedOn)"
")"); do { *((volatile int*)__null) = 2125; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
;
2126 MOZ_ASSERT_IF(ASYNCHRONOUS == mSupportedOperations,do { if (ASYNCHRONOUS == mSupportedOperations) { do { static_assert
( mozilla::detail::AssertionConditionType<decltype(IsOnCurrentSerialEventTarget
(eventTargetOpenedOn))>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(IsOnCurrentSerialEventTarget
(eventTargetOpenedOn)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("IsOnCurrentSerialEventTarget(eventTargetOpenedOn)", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2127); AnnotateMozCrashReason("MOZ_ASSERT" "(" "IsOnCurrentSerialEventTarget(eventTargetOpenedOn)"
")"); do { *((volatile int*)__null) = 2127; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
2127 IsOnCurrentSerialEventTarget(eventTargetOpenedOn))do { if (ASYNCHRONOUS == mSupportedOperations) { do { static_assert
( mozilla::detail::AssertionConditionType<decltype(IsOnCurrentSerialEventTarget
(eventTargetOpenedOn))>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(IsOnCurrentSerialEventTarget
(eventTargetOpenedOn)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("IsOnCurrentSerialEventTarget(eventTargetOpenedOn)", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2127); AnnotateMozCrashReason("MOZ_ASSERT" "(" "IsOnCurrentSerialEventTarget(eventTargetOpenedOn)"
")"); do { *((volatile int*)__null) = 2127; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
;
2128
2129 if (!connectionReady()) {
2130 return NS_ERROR_NOT_INITIALIZED;
2131 }
2132
2133 if (isClosing()) { // Closing already in asynchronous case
2134 return NS_OK;
2135 }
2136
2137 {
2138 // As stated on https://www.sqlite.org/c3ref/interrupt.html,
2139 // it is not safe to call sqlite3_interrupt() when
2140 // database connection is closed or might close before
2141 // sqlite3_interrupt() returns.
2142 MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
2143 if (!isClosed(lockedScope)) {
2144 MOZ_ASSERT(mDBConn)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mDBConn)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mDBConn))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("mDBConn", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2144); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mDBConn" ")"
); do { *((volatile int*)__null) = 2144; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
2145 ::sqlite3_interrupt(mDBConn);
2146 }
2147 }
2148
2149 return NS_OK;
2150}
2151
2152NS_IMETHODIMPnsresult
2153Connection::AsyncVacuum(mozIStorageCompletionCallback* aCallback,
2154 bool aUseIncremental, int32_t aSetPageSize) {
2155 NS_ENSURE_TRUE(NS_IsMainThread(), NS_ERROR_NOT_SAME_THREAD)do { if ((__builtin_expect(!!(!(NS_IsMainThread())), 0))) { NS_DebugBreak
(NS_DEBUG_WARNING, "NS_ENSURE_TRUE(" "NS_IsMainThread()" ") failed"
, nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2155); return NS_ERROR_NOT_SAME_THREAD; } } while (false)
;
2156 // Abort if we're shutting down.
2157 if (AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownConfirmed)) {
2158 return NS_ERROR_ABORT;
2159 }
2160 // Check if AsyncClose or Close were already invoked.
2161 if (!connectionReady()) {
2162 return NS_ERROR_NOT_INITIALIZED;
2163 }
2164 nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2165 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2166 return rv;
2167 }
2168 nsIEventTarget* asyncThread = getAsyncExecutionTarget();
2169 if (!asyncThread) {
2170 return NS_ERROR_NOT_INITIALIZED;
2171 }
2172
2173 // Create and dispatch our vacuum event to the background thread.
2174 nsCOMPtr<nsIRunnable> vacuumEvent =
2175 new AsyncVacuumEvent(this, aCallback, aUseIncremental, aSetPageSize);
2176 rv = asyncThread->Dispatch(vacuumEvent, NS_DISPATCH_NORMALnsIEventTarget::DISPATCH_NORMAL);
2177 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2177); return rv; } } while (false)
;
2178
2179 return NS_OK;
2180}
2181
2182NS_IMETHODIMPnsresult
2183Connection::GetDefaultPageSize(int32_t* _defaultPageSize) {
2184 *_defaultPageSize = Service::kDefaultPageSize;
2185 return NS_OK;
2186}
2187
2188NS_IMETHODIMPnsresult
2189Connection::GetConnectionReady(bool* _ready) {
2190 MOZ_ASSERT(IsOnCurrentSerialEventTarget(eventTargetOpenedOn))do { static_assert( mozilla::detail::AssertionConditionType<
decltype(IsOnCurrentSerialEventTarget(eventTargetOpenedOn))>
::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(IsOnCurrentSerialEventTarget(eventTargetOpenedOn))))
, 0))) { do { } while (false); MOZ_ReportAssertionFailure("IsOnCurrentSerialEventTarget(eventTargetOpenedOn)"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2190); AnnotateMozCrashReason("MOZ_ASSERT" "(" "IsOnCurrentSerialEventTarget(eventTargetOpenedOn)"
")"); do { *((volatile int*)__null) = 2190; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
2191 *_ready = connectionReady();
2192 return NS_OK;
2193}
2194
2195NS_IMETHODIMPnsresult
2196Connection::GetDatabaseFile(nsIFile** _dbFile) {
2197 if (!connectionReady()) {
2198 return NS_ERROR_NOT_INITIALIZED;
2199 }
2200 nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2201 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2202 return rv;
2203 }
2204
2205 NS_IF_ADDREF(*_dbFile = mDatabaseFile)ns_if_addref(*_dbFile = mDatabaseFile);
2206
2207 return NS_OK;
2208}
2209
2210NS_IMETHODIMPnsresult
2211Connection::GetLastInsertRowID(int64_t* _id) {
2212 if (!connectionReady()) {
2213 return NS_ERROR_NOT_INITIALIZED;
2214 }
2215 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2216 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2217 return rv;
2218 }
2219
2220 sqlite_int64 id = ::sqlite3_last_insert_rowid(mDBConn);
2221 *_id = id;
2222
2223 return NS_OK;
2224}
2225
2226NS_IMETHODIMPnsresult
2227Connection::GetAffectedRows(int32_t* _rows) {
2228 if (!connectionReady()) {
2229 return NS_ERROR_NOT_INITIALIZED;
2230 }
2231 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2232 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2233 return rv;
2234 }
2235
2236 *_rows = ::sqlite3_changes(mDBConn);
2237
2238 return NS_OK;
2239}
2240
2241NS_IMETHODIMPnsresult
2242Connection::GetLastError(int32_t* _error) {
2243 if (!connectionReady()) {
2244 return NS_ERROR_NOT_INITIALIZED;
2245 }
2246 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2247 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2248 return rv;
2249 }
2250
2251 *_error = ::sqlite3_errcode(mDBConn);
2252
2253 return NS_OK;
2254}
2255
2256NS_IMETHODIMPnsresult
2257Connection::GetLastErrorString(nsACString& _errorString) {
2258 if (!connectionReady()) {
2259 return NS_ERROR_NOT_INITIALIZED;
2260 }
2261 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2262 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2263 return rv;
2264 }
2265
2266 const char* serr = ::sqlite3_errmsg(mDBConn);
2267 _errorString.Assign(serr);
2268
2269 return NS_OK;
2270}
2271
2272NS_IMETHODIMPnsresult
2273Connection::GetSchemaVersion(int32_t* _version) {
2274 if (!connectionReady()) {
2275 return NS_ERROR_NOT_INITIALIZED;
2276 }
2277 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2278 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2279 return rv;
2280 }
2281
2282 nsCOMPtr<mozIStorageStatement> stmt;
2283 (void)CreateStatement("PRAGMA user_version"_ns, getter_AddRefs(stmt));
2284 NS_ENSURE_TRUE(stmt, NS_ERROR_OUT_OF_MEMORY)do { if ((__builtin_expect(!!(!(stmt)), 0))) { NS_DebugBreak(
NS_DEBUG_WARNING, "NS_ENSURE_TRUE(" "stmt" ") failed", nullptr
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2284); return NS_ERROR_OUT_OF_MEMORY; } } while (false)
;
2285
2286 *_version = 0;
2287 bool hasResult;
2288 if (NS_SUCCEEDED(stmt->ExecuteStep(&hasResult))((bool)(__builtin_expect(!!(!NS_FAILED_impl(stmt->ExecuteStep
(&hasResult))), 1)))
&& hasResult) {
2289 *_version = stmt->AsInt32(0);
2290 }
2291
2292 return NS_OK;
2293}
2294
2295NS_IMETHODIMPnsresult
2296Connection::SetSchemaVersion(int32_t aVersion) {
2297 if (!connectionReady()) {
2298 return NS_ERROR_NOT_INITIALIZED;
2299 }
2300 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2301 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2302 return rv;
2303 }
2304
2305 nsAutoCString stmt("PRAGMA user_version = "_ns);
2306 stmt.AppendInt(aVersion);
2307
2308 return ExecuteSimpleSQL(stmt);
2309}
2310
2311NS_IMETHODIMPnsresult
2312Connection::CreateStatement(const nsACString& aSQLStatement,
2313 mozIStorageStatement** _stmt) {
2314 NS_ENSURE_ARG_POINTER(_stmt)do { if ((__builtin_expect(!!(!(_stmt)), 0))) { NS_DebugBreak
(NS_DEBUG_WARNING, "NS_ENSURE_TRUE(" "_stmt" ") failed", nullptr
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2314); return NS_ERROR_INVALID_POINTER; } } while (false)
;
2315 if (!connectionReady()) {
2316 return NS_ERROR_NOT_INITIALIZED;
2317 }
2318 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2319 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2320 return rv;
2321 }
2322
2323 RefPtr<Statement> statement(new Statement());
2324 NS_ENSURE_TRUE(statement, NS_ERROR_OUT_OF_MEMORY)do { if ((__builtin_expect(!!(!(statement)), 0))) { NS_DebugBreak
(NS_DEBUG_WARNING, "NS_ENSURE_TRUE(" "statement" ") failed", nullptr
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2324); return NS_ERROR_OUT_OF_MEMORY; } } while (false)
;
2325
2326 rv = statement->initialize(this, mDBConn, aSQLStatement);
2327 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2327); return rv; } } while (false)
;
2328
2329 Statement* rawPtr;
2330 statement.forget(&rawPtr);
2331 *_stmt = rawPtr;
2332 return NS_OK;
2333}
2334
2335NS_IMETHODIMPnsresult
2336Connection::CreateAsyncStatement(const nsACString& aSQLStatement,
2337 mozIStorageAsyncStatement** _stmt) {
2338 NS_ENSURE_ARG_POINTER(_stmt)do { if ((__builtin_expect(!!(!(_stmt)), 0))) { NS_DebugBreak
(NS_DEBUG_WARNING, "NS_ENSURE_TRUE(" "_stmt" ") failed", nullptr
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2338); return NS_ERROR_INVALID_POINTER; } } while (false)
;
2339 if (!connectionReady()) {
2340 return NS_ERROR_NOT_INITIALIZED;
2341 }
2342 nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2343 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2344 return rv;
2345 }
2346
2347 RefPtr<AsyncStatement> statement(new AsyncStatement());
2348 NS_ENSURE_TRUE(statement, NS_ERROR_OUT_OF_MEMORY)do { if ((__builtin_expect(!!(!(statement)), 0))) { NS_DebugBreak
(NS_DEBUG_WARNING, "NS_ENSURE_TRUE(" "statement" ") failed", nullptr
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2348); return NS_ERROR_OUT_OF_MEMORY; } } while (false)
;
2349
2350 rv = statement->initialize(this, mDBConn, aSQLStatement);
2351 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2351); return rv; } } while (false)
;
2352
2353 AsyncStatement* rawPtr;
2354 statement.forget(&rawPtr);
2355 *_stmt = rawPtr;
2356 return NS_OK;
2357}
2358
2359NS_IMETHODIMPnsresult
2360Connection::ExecuteSimpleSQL(const nsACString& aSQLStatement) {
2361 CHECK_MAINTHREAD_ABUSE()do { do { if (!(eventTargetOpenedOn == GetMainThreadSerialEventTarget
() || !NS_IsMainThread())) { NS_DebugBreak(NS_DEBUG_WARNING, "Using Storage synchronous API on main-thread, but "
"the connection was opened on another thread.", "eventTargetOpenedOn == GetMainThreadSerialEventTarget() || !NS_IsMainThread()"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2361); } } while (false); } while (0)
;
2362 if (!connectionReady()) {
2363 return NS_ERROR_NOT_INITIALIZED;
2364 }
2365 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2366 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2367 return rv;
2368 }
2369
2370 int srv = executeSql(mDBConn, PromiseFlatCStringTPromiseFlatString<char>(aSQLStatement).get());
2371 return convertResultCode(srv);
2372}
2373
2374NS_IMETHODIMPnsresult
2375Connection::ExecuteAsync(
2376 const nsTArray<RefPtr<mozIStorageBaseStatement>>& aStatements,
2377 mozIStorageStatementCallback* aCallback,
2378 mozIStoragePendingStatement** _handle) {
2379 nsTArray<StatementData> stmts(aStatements.Length());
2380 for (uint32_t i = 0; i < aStatements.Length(); i++) {
2381 nsCOMPtr<StorageBaseStatementInternal> stmt =
2382 do_QueryInterface(aStatements[i]);
2383 NS_ENSURE_STATE(stmt)do { if ((__builtin_expect(!!(!(stmt)), 0))) { NS_DebugBreak(
NS_DEBUG_WARNING, "NS_ENSURE_TRUE(" "stmt" ") failed", nullptr
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2383); return NS_ERROR_UNEXPECTED; } } while (false)
;
2384
2385 // Obtain our StatementData.
2386 StatementData data;
2387 nsresult rv = stmt->getAsynchronousStatementData(data);
2388 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2388); return rv; } } while (false)
;
2389
2390 NS_ASSERTION(stmt->getOwner() == this,do { if (!(stmt->getOwner() == this)) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "Statement must be from this database connection!", "stmt->getOwner() == this"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2391); MOZ_PretendNoReturn(); } } while (0)
2391 "Statement must be from this database connection!")do { if (!(stmt->getOwner() == this)) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "Statement must be from this database connection!", "stmt->getOwner() == this"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2391); MOZ_PretendNoReturn(); } } while (0)
;
2392
2393 // Now append it to our array.
2394 stmts.AppendElement(data);
2395 }
2396
2397 // Dispatch to the background
2398 return AsyncExecuteStatements::execute(std::move(stmts), this, mDBConn,
2399 aCallback, _handle);
2400}
2401
2402NS_IMETHODIMPnsresult
2403Connection::ExecuteSimpleSQLAsync(const nsACString& aSQLStatement,
2404 mozIStorageStatementCallback* aCallback,
2405 mozIStoragePendingStatement** _handle) {
2406 NS_ENSURE_TRUE(NS_IsMainThread(), NS_ERROR_NOT_SAME_THREAD)do { if ((__builtin_expect(!!(!(NS_IsMainThread())), 0))) { NS_DebugBreak
(NS_DEBUG_WARNING, "NS_ENSURE_TRUE(" "NS_IsMainThread()" ") failed"
, nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2406); return NS_ERROR_NOT_SAME_THREAD; } } while (false)
;
2407
2408 nsCOMPtr<mozIStorageAsyncStatement> stmt;
2409 nsresult rv = CreateAsyncStatement(aSQLStatement, getter_AddRefs(stmt));
2410 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2411 return rv;
2412 }
2413
2414 nsCOMPtr<mozIStoragePendingStatement> pendingStatement;
2415 rv = stmt->ExecuteAsync(aCallback, getter_AddRefs(pendingStatement));
2416 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2417 return rv;
2418 }
2419
2420 pendingStatement.forget(_handle);
2421 return rv;
2422}
2423
2424NS_IMETHODIMPnsresult
2425Connection::TableExists(const nsACString& aTableName, bool* _exists) {
2426 return databaseElementExists(TABLE, aTableName, _exists);
2427}
2428
2429NS_IMETHODIMPnsresult
2430Connection::IndexExists(const nsACString& aIndexName, bool* _exists) {
2431 return databaseElementExists(INDEX, aIndexName, _exists);
2432}
2433
2434NS_IMETHODIMPnsresult
2435Connection::GetTransactionInProgress(bool* _inProgress) {
2436 if (!connectionReady()) {
2437 return NS_ERROR_NOT_INITIALIZED;
2438 }
2439 nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2440 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2441 return rv;
2442 }
2443
2444 SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2445 *_inProgress = transactionInProgress(lockedScope);
2446 return NS_OK;
2447}
2448
2449NS_IMETHODIMPnsresult
2450Connection::GetDefaultTransactionType(int32_t* _type) {
2451 *_type = mDefaultTransactionType;
2452 return NS_OK;
2453}
2454
2455NS_IMETHODIMPnsresult
2456Connection::SetDefaultTransactionType(int32_t aType) {
2457 NS_ENSURE_ARG_RANGE(aType, TRANSACTION_DEFERRED, TRANSACTION_EXCLUSIVE)do { if ((__builtin_expect(!!(!(((aType) >= TRANSACTION_DEFERRED
) && ((aType) <= TRANSACTION_EXCLUSIVE))), 0))) { NS_DebugBreak
(NS_DEBUG_WARNING, "NS_ENSURE_TRUE(" "((aType) >= TRANSACTION_DEFERRED) && ((aType) <= TRANSACTION_EXCLUSIVE)"
") failed", nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2457); return NS_ERROR_INVALID_ARG; } } while (false)
;
2458 mDefaultTransactionType = aType;
2459 return NS_OK;
2460}
2461
2462NS_IMETHODIMPnsresult
2463Connection::GetVariableLimit(int32_t* _limit) {
2464 if (!connectionReady()) {
2465 return NS_ERROR_NOT_INITIALIZED;
2466 }
2467 int limit = ::sqlite3_limit(mDBConn, SQLITE_LIMIT_VARIABLE_NUMBER9, -1);
2468 if (limit < 0) {
2469 return NS_ERROR_UNEXPECTED;
2470 }
2471 *_limit = limit;
2472 return NS_OK;
2473}
2474
2475NS_IMETHODIMPnsresult
2476Connection::SetVariableLimit(int32_t limit) {
2477 if (!connectionReady()) {
2478 return NS_ERROR_NOT_INITIALIZED;
2479 }
2480 int oldLimit = ::sqlite3_limit(mDBConn, SQLITE_LIMIT_VARIABLE_NUMBER9, limit);
2481 if (oldLimit < 0) {
2482 return NS_ERROR_UNEXPECTED;
2483 }
2484 return NS_OK;
2485}
2486
2487NS_IMETHODIMPnsresult
2488Connection::BeginTransaction() {
2489 if (!connectionReady()) {
2490 return NS_ERROR_NOT_INITIALIZED;
2491 }
2492 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2493 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2494 return rv;
2495 }
2496
2497 SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2498 return beginTransactionInternal(lockedScope, mDBConn,
2499 mDefaultTransactionType);
2500}
2501
2502nsresult Connection::beginTransactionInternal(
2503 const SQLiteMutexAutoLock& aProofOfLock, sqlite3* aNativeConnection,
2504 int32_t aTransactionType) {
2505 if (transactionInProgress(aProofOfLock)) {
2506 return NS_ERROR_FAILURE;
2507 }
2508 nsresult rv;
2509 switch (aTransactionType) {
2510 case TRANSACTION_DEFERRED:
2511 rv = convertResultCode(executeSql(aNativeConnection, "BEGIN DEFERRED"));
2512 break;
2513 case TRANSACTION_IMMEDIATE:
2514 rv = convertResultCode(executeSql(aNativeConnection, "BEGIN IMMEDIATE"));
2515 break;
2516 case TRANSACTION_EXCLUSIVE:
2517 rv = convertResultCode(executeSql(aNativeConnection, "BEGIN EXCLUSIVE"));
2518 break;
2519 default:
2520 return NS_ERROR_ILLEGAL_VALUE;
2521 }
2522 return rv;
2523}
2524
2525NS_IMETHODIMPnsresult
2526Connection::CommitTransaction() {
2527 if (!connectionReady()) {
2528 return NS_ERROR_NOT_INITIALIZED;
2529 }
2530 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2531 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2532 return rv;
2533 }
2534
2535 SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2536 return commitTransactionInternal(lockedScope, mDBConn);
2537}
2538
2539nsresult Connection::commitTransactionInternal(
2540 const SQLiteMutexAutoLock& aProofOfLock, sqlite3* aNativeConnection) {
2541 if (!transactionInProgress(aProofOfLock)) {
2542 return NS_ERROR_UNEXPECTED;
2543 }
2544 nsresult rv =
2545 convertResultCode(executeSql(aNativeConnection, "COMMIT TRANSACTION"));
2546 return rv;
2547}
2548
2549NS_IMETHODIMPnsresult
2550Connection::RollbackTransaction() {
2551 if (!connectionReady()) {
2552 return NS_ERROR_NOT_INITIALIZED;
2553 }
2554 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2555 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2556 return rv;
2557 }
2558
2559 SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2560 return rollbackTransactionInternal(lockedScope, mDBConn);
2561}
2562
2563nsresult Connection::rollbackTransactionInternal(
2564 const SQLiteMutexAutoLock& aProofOfLock, sqlite3* aNativeConnection) {
2565 if (!transactionInProgress(aProofOfLock)) {
2566 return NS_ERROR_UNEXPECTED;
2567 }
2568
2569 nsresult rv =
2570 convertResultCode(executeSql(aNativeConnection, "ROLLBACK TRANSACTION"));
2571 return rv;
2572}
2573
2574NS_IMETHODIMPnsresult
2575Connection::CreateTable(const char* aTableName, const char* aTableSchema) {
2576 if (!connectionReady()) {
2577 return NS_ERROR_NOT_INITIALIZED;
2578 }
2579 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2580 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2581 return rv;
2582 }
2583
2584 SmprintfPointer buf =
2585 ::mozilla::Smprintf("CREATE TABLE %s (%s)", aTableName, aTableSchema);
2586 if (!buf) return NS_ERROR_OUT_OF_MEMORY;
2587
2588 int srv = executeSql(mDBConn, buf.get());
2589
2590 return convertResultCode(srv);
2591}
2592
2593NS_IMETHODIMPnsresult
2594Connection::CreateFunction(const nsACString& aFunctionName,
2595 int32_t aNumArguments,
2596 mozIStorageFunction* aFunction) {
2597 if (!connectionReady()) {
2598 return NS_ERROR_NOT_INITIALIZED;
2599 }
2600 nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2601 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2602 return rv;
2603 }
2604
2605 // Check to see if this function is already defined. We only check the name
2606 // because a function can be defined with the same body but different names.
2607 SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2608 NS_ENSURE_FALSE(mFunctions.Contains(aFunctionName), NS_ERROR_FAILURE)do { if ((__builtin_expect(!!(!(!(mFunctions.Contains(aFunctionName
)))), 0))) { NS_DebugBreak(NS_DEBUG_WARNING, "NS_ENSURE_TRUE("
"!(mFunctions.Contains(aFunctionName))" ") failed", nullptr,
"/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2608); return NS_ERROR_FAILURE; } } while (false)
;
2609
2610 int srv = ::sqlite3_create_function(
2611 mDBConn, nsPromiseFlatCString(aFunctionName).get(), aNumArguments,
2612 SQLITE_ANY5, aFunction, basicFunctionHelper, nullptr, nullptr);
2613 if (srv != SQLITE_OK0) return convertResultCode(srv);
2614
2615 FunctionInfo info = {aFunction, aNumArguments};
2616 mFunctions.InsertOrUpdate(aFunctionName, info);
2617
2618 return NS_OK;
2619}
2620
2621NS_IMETHODIMPnsresult
2622Connection::RemoveFunction(const nsACString& aFunctionName) {
2623 if (!connectionReady()) {
2624 return NS_ERROR_NOT_INITIALIZED;
2625 }
2626 nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2627 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2628 return rv;
2629 }
2630
2631 SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2632 NS_ENSURE_TRUE(mFunctions.Get(aFunctionName, nullptr), NS_ERROR_FAILURE)do { if ((__builtin_expect(!!(!(mFunctions.Get(aFunctionName,
nullptr))), 0))) { NS_DebugBreak(NS_DEBUG_WARNING, "NS_ENSURE_TRUE("
"mFunctions.Get(aFunctionName, nullptr)" ") failed", nullptr
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2632); return NS_ERROR_FAILURE; } } while (false)
;
2633
2634 int srv = ::sqlite3_create_function(
2635 mDBConn, nsPromiseFlatCString(aFunctionName).get(), 0, SQLITE_ANY5,
2636 nullptr, nullptr, nullptr, nullptr);
2637 if (srv != SQLITE_OK0) return convertResultCode(srv);
2638
2639 mFunctions.Remove(aFunctionName);
2640
2641 return NS_OK;
2642}
2643
2644NS_IMETHODIMPnsresult
2645Connection::SetProgressHandler(int32_t aGranularity,
2646 mozIStorageProgressHandler* aHandler,
2647 mozIStorageProgressHandler** _oldHandler) {
2648 if (!connectionReady()) {
2649 return NS_ERROR_NOT_INITIALIZED;
2650 }
2651 nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2652 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2653 return rv;
2654 }
2655
2656 // Return previous one
2657 SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2658 NS_IF_ADDREF(*_oldHandler = mProgressHandler)ns_if_addref(*_oldHandler = mProgressHandler);
2659
2660 if (!aHandler || aGranularity <= 0) {
2661 aHandler = nullptr;
2662 aGranularity = 0;
2663 }
2664 mProgressHandler = aHandler;
2665 ::sqlite3_progress_handler(mDBConn, aGranularity, sProgressHelper, this);
2666
2667 return NS_OK;
2668}
2669
2670NS_IMETHODIMPnsresult
2671Connection::RemoveProgressHandler(mozIStorageProgressHandler** _oldHandler) {
2672 if (!connectionReady()) {
2673 return NS_ERROR_NOT_INITIALIZED;
2674 }
2675 nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2676 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2677 return rv;
2678 }
2679
2680 // Return previous one
2681 SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2682 NS_IF_ADDREF(*_oldHandler = mProgressHandler)ns_if_addref(*_oldHandler = mProgressHandler);
2683
2684 mProgressHandler = nullptr;
2685 ::sqlite3_progress_handler(mDBConn, 0, nullptr, nullptr);
2686
2687 return NS_OK;
2688}
2689
2690NS_IMETHODIMPnsresult
2691Connection::SetGrowthIncrement(int32_t aChunkSize,
2692 const nsACString& aDatabaseName) {
2693 if (!connectionReady()) {
2694 return NS_ERROR_NOT_INITIALIZED;
2695 }
2696 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2697 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2698 return rv;
2699 }
2700
2701 // Bug 597215: Disk space is extremely limited on Android
2702 // so don't preallocate space. This is also not effective
2703 // on log structured file systems used by Android devices
2704#if !defined(ANDROID) && !defined(MOZ_PLATFORM_MAEMO)
2705 // Don't preallocate if less than 500MiB is available.
2706 int64_t bytesAvailable;
2707 rv = mDatabaseFile->GetDiskSpaceAvailable(&bytesAvailable);
2708 NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl
(__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName
(__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with "
"result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t
>(__rv), name ? " (" : "", name ? name : "", name ? ")" : ""
); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2708); return rv; } } while (false)
;
2709 if (bytesAvailable < MIN_AVAILABLE_BYTES_PER_CHUNKED_GROWTH524288000) {
2710 return NS_ERROR_FILE_TOO_BIG;
2711 }
2712
2713 int srv = ::sqlite3_file_control(
2714 mDBConn,
2715 aDatabaseName.Length() ? nsPromiseFlatCString(aDatabaseName).get()
2716 : nullptr,
2717 SQLITE_FCNTL_CHUNK_SIZE6, &aChunkSize);
2718 if (srv == SQLITE_OK0) {
2719 mGrowthChunkSize = aChunkSize;
2720 }
2721#endif
2722 return NS_OK;
2723}
2724
2725int32_t Connection::RemovablePagesInFreeList(const nsACString& aSchemaName) {
2726 int32_t freeListPagesCount = 0;
2727 if (!isConnectionReadyOnThisThread()) {
2728 MOZ_ASSERT(false, "Database connection is not ready")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false" " (" "Database connection is not ready"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2728); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") ("
"Database connection is not ready" ")"); do { *((volatile int
*)__null) = 2728; __attribute__((nomerge)) ::abort(); } while
(false); } } while (false)
;
2729 return freeListPagesCount;
2730 }
2731 {
2732 nsAutoCString query(MOZ_STORAGE_UNIQUIFY_QUERY_STR"/* " "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
" */ "
"PRAGMA ");
2733 query.Append(aSchemaName);
2734 query.AppendLiteral(".freelist_count");
2735 nsCOMPtr<mozIStorageStatement> stmt;
2736 DebugOnly<nsresult> rv = CreateStatement(query, getter_AddRefs(stmt));
2737 MOZ_ASSERT(NS_SUCCEEDED(rv))do { static_assert( mozilla::detail::AssertionConditionType<
decltype(((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1)
)))>::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1)
))))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1)))", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2737); AnnotateMozCrashReason("MOZ_ASSERT" "(" "((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1)))"
")"); do { *((volatile int*)__null) = 2737; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
2738 bool hasResult = false;
2739 if (stmt && NS_SUCCEEDED(stmt->ExecuteStep(&hasResult))((bool)(__builtin_expect(!!(!NS_FAILED_impl(stmt->ExecuteStep
(&hasResult))), 1)))
&& hasResult) {
2740 freeListPagesCount = stmt->AsInt32(0);
2741 }
2742 }
2743 // If there's no chunk size set, any page is good to be removed.
2744 if (mGrowthChunkSize == 0 || freeListPagesCount == 0) {
2745 return freeListPagesCount;
2746 }
2747 int32_t pageSize;
2748 {
2749 nsAutoCString query(MOZ_STORAGE_UNIQUIFY_QUERY_STR"/* " "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
" */ "
"PRAGMA ");
2750 query.Append(aSchemaName);
2751 query.AppendLiteral(".page_size");
2752 nsCOMPtr<mozIStorageStatement> stmt;
2753 DebugOnly<nsresult> rv = CreateStatement(query, getter_AddRefs(stmt));
2754 MOZ_ASSERT(NS_SUCCEEDED(rv))do { static_assert( mozilla::detail::AssertionConditionType<
decltype(((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1)
)))>::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1)
))))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1)))", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2754); AnnotateMozCrashReason("MOZ_ASSERT" "(" "((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1)))"
")"); do { *((volatile int*)__null) = 2754; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
2755 bool hasResult = false;
2756 if (stmt && NS_SUCCEEDED(stmt->ExecuteStep(&hasResult))((bool)(__builtin_expect(!!(!NS_FAILED_impl(stmt->ExecuteStep
(&hasResult))), 1)))
&& hasResult) {
2757 pageSize = stmt->AsInt32(0);
2758 } else {
2759 MOZ_ASSERT(false, "Couldn't get page_size")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false" " (" "Couldn't get page_size"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2759); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") ("
"Couldn't get page_size" ")"); do { *((volatile int*)__null)
= 2759; __attribute__((nomerge)) ::abort(); } while (false);
} } while (false)
;
2760 return 0;
2761 }
2762 }
2763 return std::max(0, freeListPagesCount - (mGrowthChunkSize / pageSize));
2764}
2765
2766NS_IMETHODIMPnsresult
2767Connection::LoadExtension(const nsACString& aExtensionName,
2768 mozIStorageCompletionCallback* aCallback) {
2769 AUTO_PROFILER_LABEL("Connection::LoadExtension", OTHER)mozilla::AutoProfilerLabel raiiObject2769( "Connection::LoadExtension"
, nullptr, JS::ProfilingCategoryPair::OTHER)
;
2770
2771 // This is a static list of extensions we can load.
2772 // Please use lowercase ASCII names and keep this list alphabetically ordered.
2773 static constexpr nsLiteralCString sSupportedExtensions[] = {
2774 // clang-format off
2775 "fts5"_ns,
2776 // clang-format on
2777 };
2778 if (std::find(std::begin(sSupportedExtensions),
2779 std::end(sSupportedExtensions),
2780 aExtensionName) == std::end(sSupportedExtensions)) {
2781 return NS_ERROR_INVALID_ARG;
2782 }
2783
2784 if (!connectionReady()) {
2785 return NS_ERROR_NOT_INITIALIZED;
2786 }
2787
2788 int srv = ::sqlite3_db_config(mDBConn, SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION1005,
2789 1, nullptr);
2790 if (srv != SQLITE_OK0) {
2791 return NS_ERROR_UNEXPECTED;
2792 }
2793
2794 // Track the loaded extension for later connection cloning operations.
2795 {
2796 MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
2797 if (!mLoadedExtensions.EnsureInserted(aExtensionName)) {
2798 // Already loaded, bail out but issue a warning.
2799 NS_WARNING(nsPrintfCString(NS_DebugBreak(NS_DEBUG_WARNING, nsPrintfCString( "Tried to register '%s' SQLite extension multiple times!"
, TPromiseFlatString<char>(aExtensionName).get()) .get(
), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2802)
2800 "Tried to register '%s' SQLite extension multiple times!",NS_DebugBreak(NS_DEBUG_WARNING, nsPrintfCString( "Tried to register '%s' SQLite extension multiple times!"
, TPromiseFlatString<char>(aExtensionName).get()) .get(
), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2802)
2801 PromiseFlatCString(aExtensionName).get())NS_DebugBreak(NS_DEBUG_WARNING, nsPrintfCString( "Tried to register '%s' SQLite extension multiple times!"
, TPromiseFlatString<char>(aExtensionName).get()) .get(
), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2802)
2802 .get())NS_DebugBreak(NS_DEBUG_WARNING, nsPrintfCString( "Tried to register '%s' SQLite extension multiple times!"
, TPromiseFlatString<char>(aExtensionName).get()) .get(
), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2802)
;
2803 return NS_OK;
2804 }
2805 }
2806
2807 nsAutoCString entryPoint("sqlite3_");
2808 entryPoint.Append(aExtensionName);
2809 entryPoint.AppendLiteral("_init");
2810
2811 RefPtr<Runnable> loadTask = NS_NewRunnableFunction(
2812 "mozStorageConnection::LoadExtension",
2813 [this, self = RefPtr(this), entryPoint,
2814 callback = RefPtr(aCallback)]() mutable {
2815 MOZ_ASSERT(do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!NS_IsMainThread() || (operationSupported(Connection
::SYNCHRONOUS) && eventTargetOpenedOn == GetMainThreadSerialEventTarget
()))>::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(!NS_IsMainThread() || (operationSupported(Connection
::SYNCHRONOUS) && eventTargetOpenedOn == GetMainThreadSerialEventTarget
())))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("!NS_IsMainThread() || (operationSupported(Connection::SYNCHRONOUS) && eventTargetOpenedOn == GetMainThreadSerialEventTarget())"
" (" "Should happen on main-thread only for synchronous connections "
"opened on the main thread" ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2820); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!NS_IsMainThread() || (operationSupported(Connection::SYNCHRONOUS) && eventTargetOpenedOn == GetMainThreadSerialEventTarget())"
") (" "Should happen on main-thread only for synchronous connections "
"opened on the main thread" ")"); do { *((volatile int*)__null
) = 2820; __attribute__((nomerge)) ::abort(); } while (false)
; } } while (false)
2816 !NS_IsMainThread() ||do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!NS_IsMainThread() || (operationSupported(Connection
::SYNCHRONOUS) && eventTargetOpenedOn == GetMainThreadSerialEventTarget
()))>::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(!NS_IsMainThread() || (operationSupported(Connection
::SYNCHRONOUS) && eventTargetOpenedOn == GetMainThreadSerialEventTarget
())))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("!NS_IsMainThread() || (operationSupported(Connection::SYNCHRONOUS) && eventTargetOpenedOn == GetMainThreadSerialEventTarget())"
" (" "Should happen on main-thread only for synchronous connections "
"opened on the main thread" ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2820); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!NS_IsMainThread() || (operationSupported(Connection::SYNCHRONOUS) && eventTargetOpenedOn == GetMainThreadSerialEventTarget())"
") (" "Should happen on main-thread only for synchronous connections "
"opened on the main thread" ")"); do { *((volatile int*)__null
) = 2820; __attribute__((nomerge)) ::abort(); } while (false)
; } } while (false)
2817 (operationSupported(Connection::SYNCHRONOUS) &&do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!NS_IsMainThread() || (operationSupported(Connection
::SYNCHRONOUS) && eventTargetOpenedOn == GetMainThreadSerialEventTarget
()))>::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(!NS_IsMainThread() || (operationSupported(Connection
::SYNCHRONOUS) && eventTargetOpenedOn == GetMainThreadSerialEventTarget
())))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("!NS_IsMainThread() || (operationSupported(Connection::SYNCHRONOUS) && eventTargetOpenedOn == GetMainThreadSerialEventTarget())"
" (" "Should happen on main-thread only for synchronous connections "
"opened on the main thread" ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2820); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!NS_IsMainThread() || (operationSupported(Connection::SYNCHRONOUS) && eventTargetOpenedOn == GetMainThreadSerialEventTarget())"
") (" "Should happen on main-thread only for synchronous connections "
"opened on the main thread" ")"); do { *((volatile int*)__null
) = 2820; __attribute__((nomerge)) ::abort(); } while (false)
; } } while (false)
2818 eventTargetOpenedOn == GetMainThreadSerialEventTarget()),do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!NS_IsMainThread() || (operationSupported(Connection
::SYNCHRONOUS) && eventTargetOpenedOn == GetMainThreadSerialEventTarget
()))>::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(!NS_IsMainThread() || (operationSupported(Connection
::SYNCHRONOUS) && eventTargetOpenedOn == GetMainThreadSerialEventTarget
())))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("!NS_IsMainThread() || (operationSupported(Connection::SYNCHRONOUS) && eventTargetOpenedOn == GetMainThreadSerialEventTarget())"
" (" "Should happen on main-thread only for synchronous connections "
"opened on the main thread" ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2820); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!NS_IsMainThread() || (operationSupported(Connection::SYNCHRONOUS) && eventTargetOpenedOn == GetMainThreadSerialEventTarget())"
") (" "Should happen on main-thread only for synchronous connections "
"opened on the main thread" ")"); do { *((volatile int*)__null
) = 2820; __attribute__((nomerge)) ::abort(); } while (false)
; } } while (false)
2819 "Should happen on main-thread only for synchronous connections "do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!NS_IsMainThread() || (operationSupported(Connection
::SYNCHRONOUS) && eventTargetOpenedOn == GetMainThreadSerialEventTarget
()))>::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(!NS_IsMainThread() || (operationSupported(Connection
::SYNCHRONOUS) && eventTargetOpenedOn == GetMainThreadSerialEventTarget
())))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("!NS_IsMainThread() || (operationSupported(Connection::SYNCHRONOUS) && eventTargetOpenedOn == GetMainThreadSerialEventTarget())"
" (" "Should happen on main-thread only for synchronous connections "
"opened on the main thread" ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2820); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!NS_IsMainThread() || (operationSupported(Connection::SYNCHRONOUS) && eventTargetOpenedOn == GetMainThreadSerialEventTarget())"
") (" "Should happen on main-thread only for synchronous connections "
"opened on the main thread" ")"); do { *((volatile int*)__null
) = 2820; __attribute__((nomerge)) ::abort(); } while (false)
; } } while (false)
2820 "opened on the main thread")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!NS_IsMainThread() || (operationSupported(Connection
::SYNCHRONOUS) && eventTargetOpenedOn == GetMainThreadSerialEventTarget
()))>::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(!NS_IsMainThread() || (operationSupported(Connection
::SYNCHRONOUS) && eventTargetOpenedOn == GetMainThreadSerialEventTarget
())))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("!NS_IsMainThread() || (operationSupported(Connection::SYNCHRONOUS) && eventTargetOpenedOn == GetMainThreadSerialEventTarget())"
" (" "Should happen on main-thread only for synchronous connections "
"opened on the main thread" ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2820); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!NS_IsMainThread() || (operationSupported(Connection::SYNCHRONOUS) && eventTargetOpenedOn == GetMainThreadSerialEventTarget())"
") (" "Should happen on main-thread only for synchronous connections "
"opened on the main thread" ")"); do { *((volatile int*)__null
) = 2820; __attribute__((nomerge)) ::abort(); } while (false)
; } } while (false)
;
2821#ifdef MOZ_FOLD_LIBS
2822 int srv = ::sqlite3_load_extension(mDBConn,
2823 MOZ_DLL_PREFIX"lib" "nss3" MOZ_DLL_SUFFIX".so",
2824 entryPoint.get(), nullptr);
2825#else
2826 int srv = ::sqlite3_load_extension(
2827 mDBConn, MOZ_DLL_PREFIX"lib" "mozsqlite3" MOZ_DLL_SUFFIX".so",
2828 entryPoint.get(), nullptr);
2829#endif
2830 if (!callback) {
2831 return;
2832 };
2833 RefPtr<Runnable> callbackTask = NS_NewRunnableFunction(
2834 "mozStorageConnection::LoadExtension_callback",
2835 [callback = std::move(callback), srv]() {
2836 (void)callback->Complete(convertResultCode(srv), nullptr);
2837 });
2838 if (IsOnCurrentSerialEventTarget(eventTargetOpenedOn)) {
2839 MOZ_ALWAYS_SUCCEEDS(callbackTask->Run())do { if ((__builtin_expect(!!(((bool)(__builtin_expect(!!(!NS_FAILED_impl
(callbackTask->Run())), 1)))), 1))) { } else { do { static_assert
( mozilla::detail::AssertionConditionType<decltype(false)>
::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(false))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("false" " (" "NS_SUCCEEDED(callbackTask->Run())" ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2839); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "NS_SUCCEEDED(callbackTask->Run())" ")"); do { *((volatile
int*)__null) = 2839; __attribute__((nomerge)) ::abort(); } while
(false); } } while (false); } } while (false)
;
2840 } else {
2841 // Redispatch the callback to the calling thread.
2842 MOZ_ALWAYS_SUCCEEDS(eventTargetOpenedOn->Dispatch(do { if ((__builtin_expect(!!(((bool)(__builtin_expect(!!(!NS_FAILED_impl
(eventTargetOpenedOn->Dispatch( callbackTask.forget(), nsIEventTarget
::DISPATCH_NORMAL))), 1)))), 1))) { } else { do { static_assert
( mozilla::detail::AssertionConditionType<decltype(false)>
::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(false))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("false" " (" "NS_SUCCEEDED(eventTargetOpenedOn->Dispatch( callbackTask.forget(), nsIEventTarget::DISPATCH_NORMAL))"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2843); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "NS_SUCCEEDED(eventTargetOpenedOn->Dispatch( callbackTask.forget(), nsIEventTarget::DISPATCH_NORMAL))"
")"); do { *((volatile int*)__null) = 2843; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
2843 callbackTask.forget(), NS_DISPATCH_NORMAL))do { if ((__builtin_expect(!!(((bool)(__builtin_expect(!!(!NS_FAILED_impl
(eventTargetOpenedOn->Dispatch( callbackTask.forget(), nsIEventTarget
::DISPATCH_NORMAL))), 1)))), 1))) { } else { do { static_assert
( mozilla::detail::AssertionConditionType<decltype(false)>
::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(false))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("false" " (" "NS_SUCCEEDED(eventTargetOpenedOn->Dispatch( callbackTask.forget(), nsIEventTarget::DISPATCH_NORMAL))"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2843); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "NS_SUCCEEDED(eventTargetOpenedOn->Dispatch( callbackTask.forget(), nsIEventTarget::DISPATCH_NORMAL))"
")"); do { *((volatile int*)__null) = 2843; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
;
2844 }
2845 });
2846
2847 if (NS_IsMainThread() && !operationSupported(Connection::SYNCHRONOUS)) {
2848 // This is a main-thread call to an async-only connection, thus we should
2849 // load the library in the helper thread.
2850 nsIEventTarget* helperThread = getAsyncExecutionTarget();
2851 if (!helperThread) {
2852 return NS_ERROR_NOT_INITIALIZED;
2853 }
2854 MOZ_ALWAYS_SUCCEEDS(do { if ((__builtin_expect(!!(((bool)(__builtin_expect(!!(!NS_FAILED_impl
(helperThread->Dispatch(loadTask.forget(), nsIEventTarget::
DISPATCH_NORMAL))), 1)))), 1))) { } else { do { static_assert
( mozilla::detail::AssertionConditionType<decltype(false)>
::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(false))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("false" " (" "NS_SUCCEEDED(helperThread->Dispatch(loadTask.forget(), nsIEventTarget::DISPATCH_NORMAL))"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2855); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "NS_SUCCEEDED(helperThread->Dispatch(loadTask.forget(), nsIEventTarget::DISPATCH_NORMAL))"
")"); do { *((volatile int*)__null) = 2855; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
2855 helperThread->Dispatch(loadTask.forget(), NS_DISPATCH_NORMAL))do { if ((__builtin_expect(!!(((bool)(__builtin_expect(!!(!NS_FAILED_impl
(helperThread->Dispatch(loadTask.forget(), nsIEventTarget::
DISPATCH_NORMAL))), 1)))), 1))) { } else { do { static_assert
( mozilla::detail::AssertionConditionType<decltype(false)>
::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(false))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("false" " (" "NS_SUCCEEDED(helperThread->Dispatch(loadTask.forget(), nsIEventTarget::DISPATCH_NORMAL))"
")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2855); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "NS_SUCCEEDED(helperThread->Dispatch(loadTask.forget(), nsIEventTarget::DISPATCH_NORMAL))"
")"); do { *((volatile int*)__null) = 2855; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
;
2856 } else {
2857 // In any other case we just load the extension on the current thread.
2858 MOZ_ALWAYS_SUCCEEDS(loadTask->Run())do { if ((__builtin_expect(!!(((bool)(__builtin_expect(!!(!NS_FAILED_impl
(loadTask->Run())), 1)))), 1))) { } else { do { static_assert
( mozilla::detail::AssertionConditionType<decltype(false)>
::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(false))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("false" " (" "NS_SUCCEEDED(loadTask->Run())" ")", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2858); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
") (" "NS_SUCCEEDED(loadTask->Run())" ")"); do { *((volatile
int*)__null) = 2858; __attribute__((nomerge)) ::abort(); } while
(false); } } while (false); } } while (false)
;
2859 }
2860 return NS_OK;
2861}
2862
2863NS_IMETHODIMPnsresult
2864Connection::EnableModule(const nsACString& aModuleName) {
2865 if (!connectionReady()) {
2866 return NS_ERROR_NOT_INITIALIZED;
2867 }
2868 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2869 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2870 return rv;
2871 }
2872
2873 for (auto& gModule : gModules) {
2874 struct Module* m = &gModule;
2875 if (aModuleName.Equals(m->name)) {
2876 int srv = m->registerFunc(mDBConn, m->name);
2877 if (srv != SQLITE_OK0) return convertResultCode(srv);
2878
2879 return NS_OK;
2880 }
2881 }
2882
2883 return NS_ERROR_FAILURE;
2884}
2885
2886NS_IMETHODIMPnsresult
2887Connection::GetQuotaObjects(QuotaObject** aDatabaseQuotaObject,
2888 QuotaObject** aJournalQuotaObject) {
2889 MOZ_ASSERT(aDatabaseQuotaObject)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aDatabaseQuotaObject)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aDatabaseQuotaObject))), 0))
) { do { } while (false); MOZ_ReportAssertionFailure("aDatabaseQuotaObject"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2889); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aDatabaseQuotaObject"
")"); do { *((volatile int*)__null) = 2889; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
2890 MOZ_ASSERT(aJournalQuotaObject)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aJournalQuotaObject)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aJournalQuotaObject))), 0)))
{ do { } while (false); MOZ_ReportAssertionFailure("aJournalQuotaObject"
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2890); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aJournalQuotaObject"
")"); do { *((volatile int*)__null) = 2890; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
2891
2892 if (!connectionReady()) {
2893 return NS_ERROR_NOT_INITIALIZED;
2894 }
2895 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2896 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2897 return rv;
2898 }
2899
2900 sqlite3_file* file;
2901 int srv = ::sqlite3_file_control(mDBConn, nullptr, SQLITE_FCNTL_FILE_POINTER7,
2902 &file);
2903 if (srv != SQLITE_OK0) {
2904 return convertResultCode(srv);
2905 }
2906
2907 sqlite3_vfs* vfs;
2908 srv =
2909 ::sqlite3_file_control(mDBConn, nullptr, SQLITE_FCNTL_VFS_POINTER27, &vfs);
2910 if (srv != SQLITE_OK0) {
2911 return convertResultCode(srv);
2912 }
2913
2914 bool obfusactingVFS = false;
2915
2916 {
2917 const nsDependentCString vfsName{vfs->zName};
2918
2919 if (vfsName == obfsvfs::GetVFSName()) {
2920 obfusactingVFS = true;
2921 } else if (vfsName != quotavfs::GetVFSName()) {
2922 NS_WARNING("Got unexpected vfs")NS_DebugBreak(NS_DEBUG_WARNING, "Got unexpected vfs", nullptr
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2922)
;
2923 return NS_ERROR_FAILURE;
2924 }
2925 }
2926
2927 RefPtr<QuotaObject> databaseQuotaObject =
2928 GetQuotaObject(file, obfusactingVFS);
2929 if (NS_WARN_IF(!databaseQuotaObject)NS_warn_if_impl(!databaseQuotaObject, "!databaseQuotaObject",
"/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2929)
) {
2930 return NS_ERROR_FAILURE;
2931 }
2932
2933 srv = ::sqlite3_file_control(mDBConn, nullptr, SQLITE_FCNTL_JOURNAL_POINTER28,
2934 &file);
2935 if (srv != SQLITE_OK0) {
2936 return convertResultCode(srv);
2937 }
2938
2939 RefPtr<QuotaObject> journalQuotaObject = GetQuotaObject(file, obfusactingVFS);
2940 if (NS_WARN_IF(!journalQuotaObject)NS_warn_if_impl(!journalQuotaObject, "!journalQuotaObject", "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2940)
) {
2941 return NS_ERROR_FAILURE;
2942 }
2943
2944 databaseQuotaObject.forget(aDatabaseQuotaObject);
2945 journalQuotaObject.forget(aJournalQuotaObject);
2946 return NS_OK;
2947}
2948
2949SQLiteMutex& Connection::GetSharedDBMutex() { return sharedDBMutex; }
2950
2951uint32_t Connection::GetTransactionNestingLevel(
2952 const mozilla::storage::SQLiteMutexAutoLock& aProofOfLock) {
2953 return mTransactionNestingLevel;
2954}
2955
2956uint32_t Connection::IncreaseTransactionNestingLevel(
2957 const mozilla::storage::SQLiteMutexAutoLock& aProofOfLock) {
2958 return ++mTransactionNestingLevel;
2959}
2960
2961uint32_t Connection::DecreaseTransactionNestingLevel(
2962 const mozilla::storage::SQLiteMutexAutoLock& aProofOfLock) {
2963 return --mTransactionNestingLevel;
2964}
2965
2966NS_IMETHODIMPnsresult
2967Connection::BackupToFileAsync(nsIFile* aDestinationFile,
2968 mozIStorageCompletionCallback* aCallback,
2969 uint32_t aPagesPerStep, uint32_t aStepDelayMs) {
2970 NS_ENSURE_ARG(aDestinationFile)do { if ((__builtin_expect(!!(!(aDestinationFile)), 0))) { NS_DebugBreak
(NS_DEBUG_WARNING, "NS_ENSURE_TRUE(" "aDestinationFile" ") failed"
, nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2970); return NS_ERROR_INVALID_ARG; } } while (false)
;
2971 NS_ENSURE_ARG(aCallback)do { if ((__builtin_expect(!!(!(aCallback)), 0))) { NS_DebugBreak
(NS_DEBUG_WARNING, "NS_ENSURE_TRUE(" "aCallback" ") failed", nullptr
, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2971); return NS_ERROR_INVALID_ARG; } } while (false)
;
2972 NS_ENSURE_TRUE(NS_IsMainThread(), NS_ERROR_NOT_SAME_THREAD)do { if ((__builtin_expect(!!(!(NS_IsMainThread())), 0))) { NS_DebugBreak
(NS_DEBUG_WARNING, "NS_ENSURE_TRUE(" "NS_IsMainThread()" ") failed"
, nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/storage/mozStorageConnection.cpp"
, 2972); return NS_ERROR_NOT_SAME_THREAD; } } while (false)
;
2973
2974 // Abort if we're shutting down.
2975 if (AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownConfirmed)) {
2976 return NS_ERROR_ABORT;
2977 }
2978 // Check if AsyncClose or Close were already invoked.
2979 if (!connectionReady()) {
2980 return NS_ERROR_NOT_INITIALIZED;
2981 }
2982 nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2983 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2984 return rv;
2985 }
2986 nsIEventTarget* asyncThread = getAsyncExecutionTarget();
2987 if (!asyncThread) {
2988 return NS_ERROR_NOT_INITIALIZED;
2989 }
2990
2991 // The number of pages of the database to copy per step
2992 static constexpr int32_t DEFAULT_PAGES_PER_STEP = 5;
2993 // The number of milliseconds to wait between each step.
2994 static constexpr uint32_t DEFAULT_STEP_DELAY_MS = 250;
2995
2996 CheckedInt<int32_t> pagesPerStep(aPagesPerStep);
2997 if (!pagesPerStep.isValid()) {
2998 return NS_ERROR_INVALID_ARG;
2999 }
3000
3001 if (!pagesPerStep.value()) {
3002 pagesPerStep = DEFAULT_PAGES_PER_STEP;
3003 }
3004
3005 if (!aStepDelayMs) {
3006 aStepDelayMs = DEFAULT_STEP_DELAY_MS;
3007 }
3008
3009 // Create and dispatch our backup event to the execution thread.
3010 nsCOMPtr<nsIRunnable> backupEvent =
3011 new AsyncBackupDatabaseFile(this, mDBConn, aDestinationFile, aCallback,
3012 pagesPerStep.value(), aStepDelayMs);
3013 rv = asyncThread->Dispatch(backupEvent, NS_DISPATCH_NORMALnsIEventTarget::DISPATCH_NORMAL);
3014 return rv;
3015}
3016
3017} // namespace mozilla::storage