Bug 1885580 - Add a MenuGroup component for the menu redesign r=android-reviewers,007
[gecko.git] / storage / mozStorageConnection.cpp
blob5dd2c9223e0c97e14b771bf94a6c1a1760ef90dd
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/. */
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"
27 #include "mozIStorageCompletionCallback.h"
28 #include "mozIStorageFunction.h"
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"
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"
56 #define MIN_AVAILABLE_BYTES_PER_CHUNKED_GROWTH 524288000 // 500 MiB
58 // Maximum size of the pages cache per connection.
59 #define MAX_CACHE_SIZE_KIBIBYTES 2048 // 2 MiB
61 mozilla::LazyLogModule gStorageLog("mozStorage");
63 // Checks that the protected code is running on the main-thread only if the
64 // connection was also opened on it.
65 #ifdef DEBUG
66 # define CHECK_MAINTHREAD_ABUSE() \
67 do { \
68 NS_WARNING_ASSERTION( \
69 eventTargetOpenedOn == GetMainThreadSerialEventTarget() || \
70 !NS_IsMainThread(), \
71 "Using Storage synchronous API on main-thread, but " \
72 "the connection was opened on another thread."); \
73 } while (0)
74 #else
75 # define CHECK_MAINTHREAD_ABUSE() \
76 do { /* Nothing */ \
77 } while (0)
78 #endif
80 namespace mozilla::storage {
82 using mozilla::dom::quota::QuotaObject;
83 using mozilla::Telemetry::AccumulateCategoricalKeyed;
84 using mozilla::Telemetry::LABELS_SQLITE_STORE_OPEN;
85 using mozilla::Telemetry::LABELS_SQLITE_STORE_QUERY;
87 namespace {
89 int nsresultToSQLiteResult(nsresult aXPCOMResultCode) {
90 if (NS_SUCCEEDED(aXPCOMResultCode)) {
91 return SQLITE_OK;
94 switch (aXPCOMResultCode) {
95 case NS_ERROR_FILE_CORRUPTED:
96 return SQLITE_CORRUPT;
97 case NS_ERROR_FILE_ACCESS_DENIED:
98 return SQLITE_CANTOPEN;
99 case NS_ERROR_STORAGE_BUSY:
100 return SQLITE_BUSY;
101 case NS_ERROR_FILE_IS_LOCKED:
102 return SQLITE_LOCKED;
103 case NS_ERROR_FILE_READ_ONLY:
104 return SQLITE_READONLY;
105 case NS_ERROR_STORAGE_IOERR:
106 return SQLITE_IOERR;
107 case NS_ERROR_FILE_NO_DEVICE_SPACE:
108 return SQLITE_FULL;
109 case NS_ERROR_OUT_OF_MEMORY:
110 return SQLITE_NOMEM;
111 case NS_ERROR_UNEXPECTED:
112 return SQLITE_MISUSE;
113 case NS_ERROR_ABORT:
114 return SQLITE_ABORT;
115 case NS_ERROR_STORAGE_CONSTRAINT:
116 return SQLITE_CONSTRAINT;
117 default:
118 return SQLITE_ERROR;
121 MOZ_MAKE_COMPILER_ASSUME_IS_UNREACHABLE("Must return in switch above!");
124 ////////////////////////////////////////////////////////////////////////////////
125 //// Variant Specialization Functions (variantToSQLiteT)
127 int sqlite3_T_int(sqlite3_context* aCtx, int aValue) {
128 ::sqlite3_result_int(aCtx, aValue);
129 return SQLITE_OK;
132 int sqlite3_T_int64(sqlite3_context* aCtx, sqlite3_int64 aValue) {
133 ::sqlite3_result_int64(aCtx, aValue);
134 return SQLITE_OK;
137 int sqlite3_T_double(sqlite3_context* aCtx, double aValue) {
138 ::sqlite3_result_double(aCtx, aValue);
139 return SQLITE_OK;
142 int sqlite3_T_text(sqlite3_context* aCtx, const nsCString& aValue) {
143 CheckedInt<int32_t> length(aValue.Length());
144 if (!length.isValid()) {
145 return SQLITE_MISUSE;
147 ::sqlite3_result_text(aCtx, aValue.get(), length.value(), SQLITE_TRANSIENT);
148 return SQLITE_OK;
151 int 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_MISUSE;
157 ::sqlite3_result_text16(aCtx, aValue.get(), n_bytes.value(),
158 SQLITE_TRANSIENT);
159 return SQLITE_OK;
162 int sqlite3_T_null(sqlite3_context* aCtx) {
163 ::sqlite3_result_null(aCtx);
164 return SQLITE_OK;
167 int sqlite3_T_blob(sqlite3_context* aCtx, const void* aData, int aSize) {
168 ::sqlite3_result_blob(aCtx, aData, aSize, free);
169 return SQLITE_OK;
172 #include "variantToSQLiteT_impl.h"
174 ////////////////////////////////////////////////////////////////////////////////
175 //// Modules
177 struct Module {
178 const char* name;
179 int (*registerFunc)(sqlite3*, const char*);
182 Module gModules[] = {{"filesystem", RegisterFileSystemModule}};
184 ////////////////////////////////////////////////////////////////////////////////
185 //// Local Functions
187 int tracefunc(unsigned aReason, void* aClosure, void* aP, void* aX) {
188 switch (aReason) {
189 case SQLITE_TRACE_STMT: {
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,
198 ("TRACE_STMT on %p: '%s'", aClosure, expanded));
199 } else {
200 char* sql = ::sqlite3_expanded_sql(stmt);
201 MOZ_LOG(gStorageLog, LogLevel::Debug,
202 ("TRACE_STMT on %p: '%s'", aClosure, sql));
203 ::sqlite3_free(sql);
205 break;
207 case SQLITE_TRACE_PROFILE: {
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,
213 ("TRACE_TIME on %p: %lldms", aClosure, time));
215 break;
218 return 0;
221 void basicFunctionHelper(sqlite3_context* aCtx, int aArgc,
222 sqlite3_value** aArgv) {
223 void* userData = ::sqlite3_user_data(aCtx);
225 mozIStorageFunction* func = static_cast<mozIStorageFunction*>(userData);
227 RefPtr<ArgValueArray> arguments(new ArgValueArray(aArgc, aArgv));
228 if (!arguments) return;
230 nsCOMPtr<nsIVariant> result;
231 nsresult rv = func->OnFunctionCall(arguments, getter_AddRefs(result));
232 if (NS_FAILED(rv)) {
233 nsAutoCString errorMessage;
234 GetErrorName(rv, errorMessage);
235 errorMessage.InsertLiteral("User function returned ", 0);
236 errorMessage.Append('!');
238 NS_WARNING(errorMessage.get());
240 ::sqlite3_result_error(aCtx, errorMessage.get(), -1);
241 ::sqlite3_result_error_code(aCtx, nsresultToSQLiteResult(rv));
242 return;
244 int retcode = variantToSQLiteT(aCtx, result);
245 if (retcode != SQLITE_OK) {
246 NS_WARNING("User function returned invalid data type!");
247 ::sqlite3_result_error(aCtx, "User function returned invalid data type",
248 -1);
252 RefPtr<QuotaObject> GetQuotaObject(sqlite3_file* aFile, bool obfuscatingVFS) {
253 return obfuscatingVFS
254 ? mozilla::storage::obfsvfs::GetQuotaObjectForFile(aFile)
255 : mozilla::storage::quotavfs::GetQuotaObjectForFile(aFile);
259 * This code is heavily based on the sample at:
260 * http://www.sqlite.org/unlock_notify.html
262 class UnlockNotification {
263 public:
264 UnlockNotification()
265 : mMutex("UnlockNotification mMutex"),
266 mCondVar(mMutex, "UnlockNotification condVar"),
267 mSignaled(false) {}
269 void Wait() {
270 MutexAutoLock lock(mMutex);
271 while (!mSignaled) {
272 (void)mCondVar.Wait();
276 void Signal() {
277 MutexAutoLock lock(mMutex);
278 mSignaled = true;
279 (void)mCondVar.Notify();
282 private:
283 Mutex mMutex MOZ_UNANNOTATED;
284 CondVar mCondVar;
285 bool mSignaled;
288 void 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();
296 int 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);
301 if (srv == SQLITE_OK) {
302 notification.Wait();
305 return srv;
308 ////////////////////////////////////////////////////////////////////////////////
309 //// Local Classes
311 class 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) {}
320 NS_IMETHOD Run() override {
321 // Make sure we don't dispatch to the current thread.
322 MOZ_ASSERT(!IsOnCurrentSerialEventTarget(mConnection->eventTargetOpenedOn));
324 nsCOMPtr<nsIRunnable> event =
325 NewRunnableMethod("storage::Connection::shutdownAsyncThread",
326 mConnection, &Connection::shutdownAsyncThread);
327 MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(event));
329 // Internal close.
330 (void)mConnection->internalClose(mNativeConnection);
332 // Callback
333 if (mCallbackEvent) {
334 nsCOMPtr<nsIThread> thread;
335 (void)NS_GetMainThread(getter_AddRefs(thread));
336 (void)thread->Dispatch(mCallbackEvent, NS_DISPATCH_NORMAL);
339 return NS_OK;
342 ~AsyncCloseConnection() override {
343 NS_ReleaseOnMainThread("AsyncCloseConnection::mConnection",
344 mConnection.forget());
345 NS_ReleaseOnMainThread("AsyncCloseConnection::mCallbackEvent",
346 mCallbackEvent.forget());
349 private:
350 RefPtr<Connection> mConnection;
351 sqlite3* mNativeConnection;
352 nsCOMPtr<nsIRunnable> mCallbackEvent;
356 * An event used to initialize the clone of a connection.
358 * Must be executed on the clone's async execution thread.
360 class AsyncInitializeClone final : public Runnable {
361 public:
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.
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());
381 NS_IMETHOD Run() override {
382 MOZ_ASSERT(!NS_IsMainThread());
383 nsresult rv = mConnection->initializeClone(mClone, mReadOnly);
384 if (NS_FAILED(rv)) {
385 return Dispatch(rv, nullptr);
387 return Dispatch(NS_OK,
388 NS_ISUPPORTS_CAST(mozIStorageAsyncConnection*, mClone));
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_NORMAL);
398 ~AsyncInitializeClone() override {
399 nsCOMPtr<nsIThread> thread;
400 DebugOnly<nsresult> rv = NS_GetMainThread(getter_AddRefs(thread));
401 MOZ_ASSERT(NS_SUCCEEDED(rv));
403 // Handle ambiguous nsISupports inheritance.
404 NS_ProxyRelease("AsyncInitializeClone::mConnection", thread,
405 mConnection.forget());
406 NS_ProxyRelease("AsyncInitializeClone::mClone", thread, mClone.forget());
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());
415 RefPtr<Connection> mConnection;
416 RefPtr<Connection> mClone;
417 const bool mReadOnly;
418 nsCOMPtr<mozIStorageCompletionCallback> mCallback;
422 * A listener for async connection closing.
424 class CloseListener final : public mozIStorageCompletionCallback {
425 public:
426 NS_DECL_ISUPPORTS
427 CloseListener() : mClosed(false) {}
429 NS_IMETHOD Complete(nsresult, nsISupports*) override {
430 mClosed = true;
431 return NS_OK;
434 bool mClosed;
436 private:
437 ~CloseListener() = default;
440 NS_IMPL_ISUPPORTS(CloseListener, mozIStorageCompletionCallback)
442 class 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) {}
454 NS_IMETHOD 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);
462 return NS_OK;
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_NORMAL);
472 // Get list of attached databases.
473 nsCOMPtr<mozIStorageStatement> stmt;
474 nsresult rv = mConnection->CreateStatement(MOZ_STORAGE_UNIQUIFY_QUERY_STR
475 "PRAGMA database_list"_ns,
476 getter_AddRefs(stmt));
477 NS_ENSURE_SUCCESS(rv, rv);
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)) && hasResult) {
483 nsAutoCString name;
484 rv = stmt->GetUTF8String(1, name);
485 if (NS_SUCCEEDED(rv) && !name.EqualsLiteral("temp")) {
486 schemaNames.AppendElement(name);
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)) {
496 // This is sub-optimal since it's only keeping the last error reason,
497 // but it will do for now.
498 mStatus = rv;
501 return mStatus;
504 nsresult Vacuum(const nsACString& aSchemaName) {
505 // Abort if we're in shutdown.
506 if (AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownConfirmed)) {
507 return NS_ERROR_ABORT;
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;
514 nsresult rv;
515 bool needsFullVacuum = true;
517 if (mSetPageSize) {
518 nsAutoCString query(MOZ_STORAGE_UNIQUIFY_QUERY_STR "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);
527 // Check auto_vacuum.
529 nsAutoCString query(MOZ_STORAGE_UNIQUIFY_QUERY_STR "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);
535 bool hasResult = false;
536 bool changeAutoVacuum = false;
537 if (stmt && NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)) && hasResult) {
538 bool isIncrementalVacuum = stmt->AsInt32(0) == 2;
539 changeAutoVacuum = isIncrementalVacuum != mUseIncremental;
540 if (isIncrementalVacuum && !changeAutoVacuum) {
541 needsFullVacuum = false;
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 "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);
555 if (needsFullVacuum) {
556 nsAutoCString query(MOZ_STORAGE_UNIQUIFY_QUERY_STR "VACUUM ");
557 query.Append(aSchemaName);
558 rv = mConnection->ExecuteSimpleSQL(query);
559 // TODO (Bug 1818039): Report failed vacuum telemetry.
560 NS_ENSURE_SUCCESS(rv, rv);
561 } else {
562 nsAutoCString query(MOZ_STORAGE_UNIQUIFY_QUERY_STR "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);
571 return NS_OK;
574 ~AsyncVacuumEvent() override {
575 NS_ReleaseOnMainThread("AsyncVacuum::mConnection", mConnection.forget());
576 NS_ReleaseOnMainThread("AsyncVacuum::mCallback", mCallback.forget());
579 private:
580 RefPtr<Connection> mConnection;
581 nsCOMPtr<mozIStorageCompletionCallback> mCallback;
582 bool mUseIncremental;
583 int32_t mSetPageSize;
584 Atomic<nsresult> mStatus;
588 * A runnable to perform an SQLite database backup when there may be one or more
589 * open connections on that database.
591 class AsyncBackupDatabaseFile final : public Runnable, public nsITimerCallback {
592 public:
593 NS_DECL_ISUPPORTS_INHERITED
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
607 AsyncBackupDatabaseFile(Connection* aConnection, sqlite3* aNativeConnection,
608 nsIFile* aDestinationFile,
609 mozIStorageCompletionCallback* aCallback)
610 : Runnable("storage::AsyncBackupDatabaseFile"),
611 mConnection(aConnection),
612 mNativeConnection(aNativeConnection),
613 mDestinationFile(aDestinationFile),
614 mCallback(aCallback),
615 mBackupFile(nullptr),
616 mBackupHandle(nullptr) {
617 MOZ_ASSERT(NS_IsMainThread());
620 NS_IMETHOD Run() override {
621 MOZ_ASSERT(!NS_IsMainThread());
623 nsAutoString path;
624 nsresult rv = mDestinationFile->GetPath(path);
625 if (NS_FAILED(rv)) {
626 return Dispatch(rv, nullptr);
628 // Put a .tmp on the end of the destination while the backup is underway.
629 // This extension will be stripped off after the backup successfully
630 // completes.
631 path.AppendLiteral(".tmp");
633 int srv = ::sqlite3_open(NS_ConvertUTF16toUTF8(path).get(), &mBackupFile);
634 if (srv != SQLITE_OK) {
635 return Dispatch(NS_ERROR_FAILURE, nullptr);
638 static const char* mainDBName = "main";
640 mBackupHandle = ::sqlite3_backup_init(mBackupFile, mainDBName,
641 mNativeConnection, mainDBName);
642 if (!mBackupHandle) {
643 MOZ_ALWAYS_TRUE(::sqlite3_close(mBackupFile) == SQLITE_OK);
644 return Dispatch(NS_ERROR_FAILURE, nullptr);
647 return DoStep();
650 NS_IMETHOD
651 Notify(nsITimer* aTimer) override { return DoStep(); }
653 private:
654 nsresult DoStep() {
655 #define DISPATCH_AND_RETURN_IF_FAILED(rv) \
656 if (NS_FAILED(rv)) { \
657 return Dispatch(rv, nullptr); \
660 // This guard is used to close the backup database in the event of
661 // some failure throughout this process. We release the exit guard
662 // only if we complete the backup successfully, or defer to another
663 // later call to DoStep.
664 auto guard = MakeScopeExit([&]() {
665 MOZ_ALWAYS_TRUE(::sqlite3_close(mBackupFile) == SQLITE_OK);
666 mBackupFile = nullptr;
669 MOZ_ASSERT(!NS_IsMainThread());
670 nsAutoString originalPath;
671 nsresult rv = mDestinationFile->GetPath(originalPath);
672 DISPATCH_AND_RETURN_IF_FAILED(rv);
674 nsAutoString tempPath = originalPath;
675 tempPath.AppendLiteral(".tmp");
677 nsCOMPtr<nsIFile> file =
678 do_CreateInstance("@mozilla.org/file/local;1", &rv);
679 DISPATCH_AND_RETURN_IF_FAILED(rv);
681 rv = file->InitWithPath(tempPath);
682 DISPATCH_AND_RETURN_IF_FAILED(rv);
684 // The number of milliseconds to wait between each batch of copies.
685 static constexpr uint32_t STEP_DELAY_MS = 250;
686 // The number of pages to copy per step
687 static constexpr int COPY_PAGES = 5;
689 int srv = ::sqlite3_backup_step(mBackupHandle, COPY_PAGES);
690 if (srv == SQLITE_OK || srv == SQLITE_BUSY || srv == SQLITE_LOCKED) {
691 // We're continuing the backup later. Release the guard to avoid closing
692 // the database.
693 guard.release();
694 // Queue up the next step
695 return NS_NewTimerWithCallback(getter_AddRefs(mTimer), this,
696 STEP_DELAY_MS, nsITimer::TYPE_ONE_SHOT,
697 GetCurrentSerialEventTarget());
699 #ifdef DEBUG
700 if (srv != SQLITE_DONE) {
701 nsCString warnMsg;
702 warnMsg.AppendLiteral(
703 "The SQLite database copy could not be completed due to an error: ");
704 warnMsg.Append(::sqlite3_errmsg(mBackupFile));
705 NS_WARNING(warnMsg.get());
707 #endif
709 (void)::sqlite3_backup_finish(mBackupHandle);
710 MOZ_ALWAYS_TRUE(::sqlite3_close(mBackupFile) == SQLITE_OK);
711 mBackupFile = nullptr;
713 // The database is already closed, so we can release this guard now.
714 guard.release();
716 if (srv != SQLITE_DONE) {
717 NS_WARNING("Failed to create database copy.");
719 // The partially created database file is not useful. Let's remove it.
720 rv = file->Remove(false);
721 if (NS_FAILED(rv)) {
722 NS_WARNING(
723 "Removing a partially backed up SQLite database file failed.");
726 return Dispatch(convertResultCode(srv), nullptr);
729 // Now that we've successfully created the copy, we'll strip off the .tmp
730 // extension.
732 nsAutoString leafName;
733 rv = mDestinationFile->GetLeafName(leafName);
734 DISPATCH_AND_RETURN_IF_FAILED(rv);
736 rv = file->RenameTo(nullptr, leafName);
737 DISPATCH_AND_RETURN_IF_FAILED(rv);
739 #undef DISPATCH_AND_RETURN_IF_FAILED
740 return Dispatch(NS_OK, nullptr);
743 nsresult Dispatch(nsresult aResult, nsISupports* aValue) {
744 RefPtr<CallbackComplete> event =
745 new CallbackComplete(aResult, aValue, mCallback.forget());
746 return mConnection->eventTargetOpenedOn->Dispatch(event,
747 NS_DISPATCH_NORMAL);
750 ~AsyncBackupDatabaseFile() override {
751 nsresult rv;
752 nsCOMPtr<nsIThread> thread =
753 do_QueryInterface(mConnection->eventTargetOpenedOn, &rv);
754 MOZ_ASSERT(NS_SUCCEEDED(rv));
756 // Handle ambiguous nsISupports inheritance.
757 NS_ProxyRelease("AsyncBackupDatabaseFile::mConnection", thread,
758 mConnection.forget());
759 NS_ProxyRelease("AsyncBackupDatabaseFile::mDestinationFile", thread,
760 mDestinationFile.forget());
762 // Generally, the callback will be released by CallbackComplete.
763 // However, if for some reason Run() is not executed, we still
764 // need to ensure that it is released here.
765 NS_ProxyRelease("AsyncInitializeClone::mCallback", thread,
766 mCallback.forget());
769 RefPtr<Connection> mConnection;
770 sqlite3* mNativeConnection;
771 nsCOMPtr<nsITimer> mTimer;
772 nsCOMPtr<nsIFile> mDestinationFile;
773 nsCOMPtr<mozIStorageCompletionCallback> mCallback;
774 sqlite3* mBackupFile;
775 sqlite3_backup* mBackupHandle;
778 NS_IMPL_ISUPPORTS_INHERITED(AsyncBackupDatabaseFile, Runnable, nsITimerCallback)
780 } // namespace
782 ////////////////////////////////////////////////////////////////////////////////
783 //// Connection
785 Connection::Connection(Service* aService, int aFlags,
786 ConnectionOperation aSupportedOperations,
787 const nsCString& aTelemetryFilename, bool aInterruptible,
788 bool aIgnoreLockingMode)
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 mAsyncExecutionThreadShuttingDown(false),
805 mConnectionClosed(false),
806 mGrowthChunkSize(0) {
807 MOZ_ASSERT(!mIgnoreLockingMode || mFlags & SQLITE_OPEN_READONLY,
808 "Can't ignore locking for a non-readonly connection!");
809 mStorageService->registerConnection(this);
810 MOZ_ASSERT(!aTelemetryFilename.IsEmpty(),
811 "A telemetry filename should have been passed-in.");
812 mTelemetryFilename.Assign(aTelemetryFilename);
815 Connection::~Connection() {
816 // Failsafe Close() occurs in our custom Release method because of
817 // complications related to Close() potentially invoking AsyncClose() which
818 // will increment our refcount.
819 MOZ_ASSERT(!mAsyncExecutionThread,
820 "The async thread has not been shutdown properly!");
823 NS_IMPL_ADDREF(Connection)
825 NS_INTERFACE_MAP_BEGIN(Connection)
826 NS_INTERFACE_MAP_ENTRY(mozIStorageAsyncConnection)
827 NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor)
828 NS_INTERFACE_MAP_ENTRY(mozIStorageConnection)
829 NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, mozIStorageConnection)
830 NS_INTERFACE_MAP_END
832 // This is identical to what NS_IMPL_RELEASE provides, but with the
833 // extra |1 == count| case.
834 NS_IMETHODIMP_(MozExternalRefCountType) Connection::Release(void) {
835 MOZ_ASSERT(0 != mRefCnt, "dup release");
836 nsrefcnt count = --mRefCnt;
837 NS_LOG_RELEASE(this, count, "Connection");
838 if (1 == count) {
839 // If the refcount went to 1, the single reference must be from
840 // gService->mConnections (in class |Service|). And the code calling
841 // Release is either:
842 // - The "user" code that had created the connection, releasing on any
843 // thread.
844 // - One of Service's getConnections() callers had acquired a strong
845 // reference to the Connection that out-lived the last "user" reference,
846 // and now that just got dropped. Note that this reference could be
847 // getting dropped on the main thread or Connection->eventTargetOpenedOn
848 // (because of the NewRunnableMethod used by minimizeMemory).
850 // Either way, we should now perform our failsafe Close() and unregister.
851 // However, we only want to do this once, and the reality is that our
852 // refcount could go back up above 1 and down again at any time if we are
853 // off the main thread and getConnections() gets called on the main thread,
854 // so we use an atomic here to do this exactly once.
855 if (mDestroying.compareExchange(false, true)) {
856 // Close the connection, dispatching to the opening event target if we're
857 // not on that event target already and that event target is still
858 // accepting runnables. We do this because it's possible we're on the main
859 // thread because of getConnections(), and we REALLY don't want to
860 // transfer I/O to the main thread if we can avoid it.
861 if (IsOnCurrentSerialEventTarget(eventTargetOpenedOn)) {
862 // This could cause SpinningSynchronousClose() to be invoked and AddRef
863 // triggered for AsyncCloseConnection's strong ref if the conn was ever
864 // use for async purposes. (Main-thread only, though.)
865 Unused << synchronousClose();
866 } else {
867 nsCOMPtr<nsIRunnable> event =
868 NewRunnableMethod("storage::Connection::synchronousClose", this,
869 &Connection::synchronousClose);
870 if (NS_FAILED(eventTargetOpenedOn->Dispatch(event.forget(),
871 NS_DISPATCH_NORMAL))) {
872 // The event target was dead and so we've just leaked our runnable.
873 // This should not happen because our non-main-thread consumers should
874 // be explicitly closing their connections, not relying on us to close
875 // them for them. (It's okay to let a statement go out of scope for
876 // automatic cleanup, but not a Connection.)
877 MOZ_ASSERT(false,
878 "Leaked Connection::synchronousClose(), ownership fail.");
879 Unused << synchronousClose();
883 // This will drop its strong reference right here, right now.
884 mStorageService->unregisterConnection(this);
886 } else if (0 == count) {
887 mRefCnt = 1; /* stabilize */
888 #if 0 /* enable this to find non-threadsafe destructors: */
889 NS_ASSERT_OWNINGTHREAD(Connection);
890 #endif
891 delete (this);
892 return 0;
894 return count;
897 int32_t Connection::getSqliteRuntimeStatus(int32_t aStatusOption,
898 int32_t* aMaxValue) {
899 MOZ_ASSERT(connectionReady(), "A connection must exist at this point");
900 int curr = 0, max = 0;
901 DebugOnly<int> rc =
902 ::sqlite3_db_status(mDBConn, aStatusOption, &curr, &max, 0);
903 MOZ_ASSERT(NS_SUCCEEDED(convertResultCode(rc)));
904 if (aMaxValue) *aMaxValue = max;
905 return curr;
908 nsIEventTarget* Connection::getAsyncExecutionTarget() {
909 NS_ENSURE_TRUE(IsOnCurrentSerialEventTarget(eventTargetOpenedOn), nullptr);
911 // Don't return the asynchronous event target if we are shutting down.
912 if (mAsyncExecutionThreadShuttingDown) {
913 return nullptr;
916 // Create the async event target if there's none yet.
917 if (!mAsyncExecutionThread) {
918 // Names start with "sqldb:" followed by a recognizable name, like the
919 // database file name, or a specially crafted name like "memory".
920 // This name will be surfaced on https://crash-stats.mozilla.org, so any
921 // sensitive part of the file name (e.g. an URL origin) should be replaced
922 // by passing an explicit telemetryName to openDatabaseWithFileURL.
923 nsAutoCString name("sqldb:"_ns);
924 name.Append(mTelemetryFilename);
925 static nsThreadPoolNaming naming;
926 nsresult rv = NS_NewNamedThread(naming.GetNextThreadName(name),
927 getter_AddRefs(mAsyncExecutionThread));
928 if (NS_FAILED(rv)) {
929 NS_WARNING("Failed to create async thread.");
930 return nullptr;
932 mAsyncExecutionThread->SetNameForWakeupTelemetry("mozStorage (all)"_ns);
935 return mAsyncExecutionThread;
938 void Connection::RecordOpenStatus(nsresult rv) {
939 nsCString histogramKey = mTelemetryFilename;
941 if (histogramKey.IsEmpty()) {
942 histogramKey.AssignLiteral("unknown");
945 if (NS_SUCCEEDED(rv)) {
946 AccumulateCategoricalKeyed(histogramKey, LABELS_SQLITE_STORE_OPEN::success);
947 return;
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);
975 void Connection::RecordQueryStatus(int srv) {
976 nsCString histogramKey = mTelemetryFilename;
978 if (histogramKey.IsEmpty()) {
979 histogramKey.AssignLiteral("unknown");
982 switch (srv) {
983 case SQLITE_OK:
984 case SQLITE_ROW:
985 case SQLITE_DONE:
987 // Note that these are returned when we intentionally cancel a statement so
988 // they aren't indicating a failure.
989 case SQLITE_ABORT:
990 case SQLITE_INTERRUPT:
991 AccumulateCategoricalKeyed(histogramKey,
992 LABELS_SQLITE_STORE_QUERY::success);
993 break;
994 case SQLITE_CORRUPT:
995 case SQLITE_NOTADB:
996 AccumulateCategoricalKeyed(histogramKey,
997 LABELS_SQLITE_STORE_QUERY::corrupt);
998 break;
999 case SQLITE_PERM:
1000 case SQLITE_CANTOPEN:
1001 case SQLITE_LOCKED:
1002 case SQLITE_READONLY:
1003 AccumulateCategoricalKeyed(histogramKey,
1004 LABELS_SQLITE_STORE_QUERY::access);
1005 break;
1006 case SQLITE_IOERR:
1007 case SQLITE_NOLFS:
1008 AccumulateCategoricalKeyed(histogramKey,
1009 LABELS_SQLITE_STORE_QUERY::diskio);
1010 break;
1011 case SQLITE_FULL:
1012 case SQLITE_TOOBIG:
1013 AccumulateCategoricalKeyed(histogramKey,
1014 LABELS_SQLITE_STORE_QUERY::diskspace);
1015 break;
1016 case SQLITE_CONSTRAINT:
1017 case SQLITE_RANGE:
1018 case SQLITE_MISMATCH:
1019 case SQLITE_MISUSE:
1020 AccumulateCategoricalKeyed(histogramKey,
1021 LABELS_SQLITE_STORE_QUERY::misuse);
1022 break;
1023 case SQLITE_BUSY:
1024 AccumulateCategoricalKeyed(histogramKey, LABELS_SQLITE_STORE_QUERY::busy);
1025 break;
1026 default:
1027 AccumulateCategoricalKeyed(histogramKey,
1028 LABELS_SQLITE_STORE_QUERY::failure);
1032 nsresult Connection::initialize(const nsACString& aStorageKey,
1033 const nsACString& aName) {
1034 MOZ_ASSERT(aStorageKey.Equals(kMozStorageMemoryStorageKey));
1035 NS_ASSERTION(!connectionReady(),
1036 "Initialize called on already opened database!");
1037 MOZ_ASSERT(!mIgnoreLockingMode, "Can't ignore locking on an in-memory db.");
1038 AUTO_PROFILER_LABEL("Connection::initialize", OTHER);
1040 mStorageKey = aStorageKey;
1041 mName = aName;
1043 // in memory database requested, sqlite uses a magic file name
1045 const nsAutoCString path =
1046 mName.IsEmpty() ? nsAutoCString(":memory:"_ns)
1047 : "file:"_ns + mName + "?mode=memory&cache=shared"_ns;
1049 int srv = ::sqlite3_open_v2(path.get(), &mDBConn, mFlags,
1050 basevfs::GetVFSName(true));
1051 if (srv != SQLITE_OK) {
1052 mDBConn = nullptr;
1053 nsresult rv = convertResultCode(srv);
1054 RecordOpenStatus(rv);
1055 return rv;
1058 #ifdef MOZ_SQLITE_FTS3_TOKENIZER
1059 srv =
1060 ::sqlite3_db_config(mDBConn, SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, 1, 0);
1061 MOZ_ASSERT(srv == SQLITE_OK,
1062 "SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER should be enabled");
1063 #endif
1065 // Do not set mDatabaseFile or mFileURL here since this is a "memory"
1066 // database.
1068 nsresult rv = initializeInternal();
1069 RecordOpenStatus(rv);
1070 NS_ENSURE_SUCCESS(rv, rv);
1072 return NS_OK;
1075 nsresult Connection::initialize(nsIFile* aDatabaseFile) {
1076 NS_ASSERTION(aDatabaseFile, "Passed null file!");
1077 NS_ASSERTION(!connectionReady(),
1078 "Initialize called on already opened database!");
1079 AUTO_PROFILER_LABEL("Connection::initialize", OTHER);
1081 // Do not set mFileURL here since this is database does not have an associated
1082 // URL.
1083 mDatabaseFile = aDatabaseFile;
1085 nsAutoString path;
1086 nsresult rv = aDatabaseFile->GetPath(path);
1087 NS_ENSURE_SUCCESS(rv, rv);
1089 bool exclusive = StaticPrefs::storage_sqlite_exclusiveLock_enabled();
1090 int srv;
1091 if (mIgnoreLockingMode) {
1092 exclusive = false;
1093 srv = ::sqlite3_open_v2(NS_ConvertUTF16toUTF8(path).get(), &mDBConn, mFlags,
1094 "readonly-immutable-nolock");
1095 } else {
1096 srv = ::sqlite3_open_v2(NS_ConvertUTF16toUTF8(path).get(), &mDBConn, mFlags,
1097 basevfs::GetVFSName(exclusive));
1098 if (exclusive && (srv == SQLITE_LOCKED || srv == SQLITE_BUSY)) {
1099 // Retry without trying to get an exclusive lock.
1100 exclusive = false;
1101 srv = ::sqlite3_open_v2(NS_ConvertUTF16toUTF8(path).get(), &mDBConn,
1102 mFlags, basevfs::GetVFSName(false));
1105 if (srv != SQLITE_OK) {
1106 mDBConn = nullptr;
1107 rv = convertResultCode(srv);
1108 RecordOpenStatus(rv);
1109 return rv;
1112 rv = initializeInternal();
1113 if (exclusive &&
1114 (rv == NS_ERROR_STORAGE_BUSY || rv == NS_ERROR_FILE_IS_LOCKED)) {
1115 // Usually SQLite will fail to acquire an exclusive lock on opening, but in
1116 // some cases it may successfully open the database and then lock on the
1117 // first query execution. When initializeInternal fails it closes the
1118 // connection, so we can try to restart it in non-exclusive mode.
1119 srv = ::sqlite3_open_v2(NS_ConvertUTF16toUTF8(path).get(), &mDBConn, mFlags,
1120 basevfs::GetVFSName(false));
1121 if (srv == SQLITE_OK) {
1122 rv = initializeInternal();
1126 RecordOpenStatus(rv);
1127 NS_ENSURE_SUCCESS(rv, rv);
1129 return NS_OK;
1132 nsresult Connection::initialize(nsIFileURL* aFileURL) {
1133 NS_ASSERTION(aFileURL, "Passed null file URL!");
1134 NS_ASSERTION(!connectionReady(),
1135 "Initialize called on already opened database!");
1136 AUTO_PROFILER_LABEL("Connection::initialize", OTHER);
1138 nsCOMPtr<nsIFile> databaseFile;
1139 nsresult rv = aFileURL->GetFile(getter_AddRefs(databaseFile));
1140 NS_ENSURE_SUCCESS(rv, rv);
1142 // Set both mDatabaseFile and mFileURL here.
1143 mFileURL = aFileURL;
1144 mDatabaseFile = databaseFile;
1146 nsAutoCString spec;
1147 rv = aFileURL->GetSpec(spec);
1148 NS_ENSURE_SUCCESS(rv, rv);
1150 // If there is a key specified, we need to use the obfuscating VFS.
1151 nsAutoCString query;
1152 rv = aFileURL->GetQuery(query);
1153 NS_ENSURE_SUCCESS(rv, rv);
1155 bool hasKey = false;
1156 bool hasDirectoryLockId = false;
1158 MOZ_ALWAYS_TRUE(
1159 URLParams::Parse(query, true,
1160 [&hasKey, &hasDirectoryLockId](const nsAString& aName,
1161 const nsAString& aValue) {
1162 if (aName.EqualsLiteral("key")) {
1163 hasKey = true;
1164 return true;
1166 if (aName.EqualsLiteral("directoryLockId")) {
1167 hasDirectoryLockId = true;
1168 return true;
1170 return true;
1171 }));
1173 bool exclusive = StaticPrefs::storage_sqlite_exclusiveLock_enabled();
1175 const char* const vfs = hasKey ? obfsvfs::GetVFSName()
1176 : hasDirectoryLockId ? quotavfs::GetVFSName()
1177 : basevfs::GetVFSName(exclusive);
1179 int srv = ::sqlite3_open_v2(spec.get(), &mDBConn, mFlags, vfs);
1180 if (srv != SQLITE_OK) {
1181 mDBConn = nullptr;
1182 rv = convertResultCode(srv);
1183 RecordOpenStatus(rv);
1184 return rv;
1187 rv = initializeInternal();
1188 RecordOpenStatus(rv);
1189 NS_ENSURE_SUCCESS(rv, rv);
1191 return NS_OK;
1194 nsresult Connection::initializeInternal() {
1195 MOZ_ASSERT(mDBConn);
1196 auto guard = MakeScopeExit([&]() { initializeFailed(); });
1198 mConnectionClosed = false;
1200 #ifdef MOZ_SQLITE_FTS3_TOKENIZER
1201 DebugOnly<int> srv2 =
1202 ::sqlite3_db_config(mDBConn, SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, 1, 0);
1203 MOZ_ASSERT(srv2 == SQLITE_OK,
1204 "SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER should be enabled");
1205 #endif
1207 // Properly wrap the database handle's mutex.
1208 sharedDBMutex.initWithMutex(sqlite3_db_mutex(mDBConn));
1210 // SQLite tracing can slow down queries (especially long queries)
1211 // significantly. Don't trace unless the user is actively monitoring SQLite.
1212 if (MOZ_LOG_TEST(gStorageLog, LogLevel::Debug)) {
1213 ::sqlite3_trace_v2(mDBConn, SQLITE_TRACE_STMT | SQLITE_TRACE_PROFILE,
1214 tracefunc, this);
1216 MOZ_LOG(
1217 gStorageLog, LogLevel::Debug,
1218 ("Opening connection to '%s' (%p)", mTelemetryFilename.get(), this));
1221 int64_t pageSize = Service::kDefaultPageSize;
1223 // Set page_size to the preferred default value. This is effective only if
1224 // the database has just been created, otherwise, if the database does not
1225 // use WAL journal mode, a VACUUM operation will updated its page_size.
1226 nsAutoCString pageSizeQuery(MOZ_STORAGE_UNIQUIFY_QUERY_STR
1227 "PRAGMA page_size = ");
1228 pageSizeQuery.AppendInt(pageSize);
1229 int srv = executeSql(mDBConn, pageSizeQuery.get());
1230 if (srv != SQLITE_OK) {
1231 return convertResultCode(srv);
1234 // Setting the cache_size forces the database open, verifying if it is valid
1235 // or corrupt. So this is executed regardless it being actually needed.
1236 // The cache_size is calculated from the actual page_size, to save memory.
1237 nsAutoCString cacheSizeQuery(MOZ_STORAGE_UNIQUIFY_QUERY_STR
1238 "PRAGMA cache_size = ");
1239 cacheSizeQuery.AppendInt(-MAX_CACHE_SIZE_KIBIBYTES);
1240 srv = executeSql(mDBConn, cacheSizeQuery.get());
1241 if (srv != SQLITE_OK) {
1242 return convertResultCode(srv);
1245 // Register our built-in SQL functions.
1246 srv = registerFunctions(mDBConn);
1247 if (srv != SQLITE_OK) {
1248 return convertResultCode(srv);
1251 // Register our built-in SQL collating sequences.
1252 srv = registerCollations(mDBConn, mStorageService);
1253 if (srv != SQLITE_OK) {
1254 return convertResultCode(srv);
1257 // Set the default synchronous value. Each consumer can switch this
1258 // accordingly to their needs.
1259 #if defined(ANDROID)
1260 // Android prefers synchronous = OFF for performance reasons.
1261 Unused << ExecuteSimpleSQL("PRAGMA synchronous = OFF;"_ns);
1262 #else
1263 // Normal is the suggested value for WAL journals.
1264 Unused << ExecuteSimpleSQL("PRAGMA synchronous = NORMAL;"_ns);
1265 #endif
1267 // Initialization succeeded, we can stop guarding for failures.
1268 guard.release();
1269 return NS_OK;
1272 nsresult Connection::initializeOnAsyncThread(nsIFile* aStorageFile) {
1273 MOZ_ASSERT(!IsOnCurrentSerialEventTarget(eventTargetOpenedOn));
1274 nsresult rv = aStorageFile
1275 ? initialize(aStorageFile)
1276 : initialize(kMozStorageMemoryStorageKey, VoidCString());
1277 if (NS_FAILED(rv)) {
1278 // Shutdown the async thread, since initialization failed.
1279 MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
1280 mAsyncExecutionThreadShuttingDown = true;
1281 nsCOMPtr<nsIRunnable> event =
1282 NewRunnableMethod("Connection::shutdownAsyncThread", this,
1283 &Connection::shutdownAsyncThread);
1284 Unused << NS_DispatchToMainThread(event);
1286 return rv;
1289 void Connection::initializeFailed() {
1291 MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
1292 mConnectionClosed = true;
1294 MOZ_ALWAYS_TRUE(::sqlite3_close(mDBConn) == SQLITE_OK);
1295 mDBConn = nullptr;
1296 sharedDBMutex.destroy();
1299 nsresult Connection::databaseElementExists(
1300 enum DatabaseElementType aElementType, const nsACString& aElementName,
1301 bool* _exists) {
1302 if (!connectionReady()) {
1303 return NS_ERROR_NOT_AVAILABLE;
1305 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
1306 if (NS_FAILED(rv)) {
1307 return rv;
1310 // When constructing the query, make sure to SELECT the correct db's
1311 // sqlite_master if the user is prefixing the element with a specific db. ex:
1312 // sample.test
1313 nsCString query("SELECT name FROM (SELECT * FROM ");
1314 nsDependentCSubstring element;
1315 int32_t ind = aElementName.FindChar('.');
1316 if (ind == kNotFound) {
1317 element.Assign(aElementName);
1318 } else {
1319 nsDependentCSubstring db(Substring(aElementName, 0, ind + 1));
1320 element.Assign(Substring(aElementName, ind + 1, aElementName.Length()));
1321 query.Append(db);
1323 query.AppendLiteral(
1324 "sqlite_master UNION ALL SELECT * FROM sqlite_temp_master) WHERE type = "
1325 "'");
1327 switch (aElementType) {
1328 case INDEX:
1329 query.AppendLiteral("index");
1330 break;
1331 case TABLE:
1332 query.AppendLiteral("table");
1333 break;
1335 query.AppendLiteral("' AND name ='");
1336 query.Append(element);
1337 query.Append('\'');
1339 sqlite3_stmt* stmt;
1340 int srv = prepareStatement(mDBConn, query, &stmt);
1341 if (srv != SQLITE_OK) {
1342 RecordQueryStatus(srv);
1343 return convertResultCode(srv);
1346 srv = stepStatement(mDBConn, stmt);
1347 // we just care about the return value from step
1348 (void)::sqlite3_finalize(stmt);
1350 RecordQueryStatus(srv);
1352 if (srv == SQLITE_ROW) {
1353 *_exists = true;
1354 return NS_OK;
1356 if (srv == SQLITE_DONE) {
1357 *_exists = false;
1358 return NS_OK;
1361 return convertResultCode(srv);
1364 bool Connection::findFunctionByInstance(mozIStorageFunction* aInstance) {
1365 sharedDBMutex.assertCurrentThreadOwns();
1367 for (const auto& data : mFunctions.Values()) {
1368 if (data.function == aInstance) {
1369 return true;
1372 return false;
1375 /* static */
1376 int Connection::sProgressHelper(void* aArg) {
1377 Connection* _this = static_cast<Connection*>(aArg);
1378 return _this->progressHandler();
1381 int Connection::progressHandler() {
1382 sharedDBMutex.assertCurrentThreadOwns();
1383 if (mProgressHandler) {
1384 bool result;
1385 nsresult rv = mProgressHandler->OnProgress(this, &result);
1386 if (NS_FAILED(rv)) return 0; // Don't break request
1387 return result ? 1 : 0;
1389 return 0;
1392 nsresult Connection::setClosedState() {
1393 // Flag that we are shutting down the async thread, so that
1394 // getAsyncExecutionTarget knows not to expose/create the async thread.
1395 MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
1396 NS_ENSURE_FALSE(mAsyncExecutionThreadShuttingDown, NS_ERROR_UNEXPECTED);
1398 mAsyncExecutionThreadShuttingDown = true;
1400 // Set the property to null before closing the connection, otherwise the
1401 // other functions in the module may try to use the connection after it is
1402 // closed.
1403 mDBConn = nullptr;
1405 return NS_OK;
1408 bool Connection::operationSupported(ConnectionOperation aOperationType) {
1409 if (aOperationType == ASYNCHRONOUS) {
1410 // Async operations are supported for all connections, on any thread.
1411 return true;
1413 // Sync operations are supported for sync connections (on any thread), and
1414 // async connections on a background thread.
1415 MOZ_ASSERT(aOperationType == SYNCHRONOUS);
1416 return mSupportedOperations == SYNCHRONOUS || !NS_IsMainThread();
1419 nsresult Connection::ensureOperationSupported(
1420 ConnectionOperation aOperationType) {
1421 if (NS_WARN_IF(!operationSupported(aOperationType))) {
1422 #ifdef DEBUG
1423 if (NS_IsMainThread()) {
1424 nsCOMPtr<nsIXPConnect> xpc = nsIXPConnect::XPConnect();
1425 Unused << xpc->DebugDumpJSStack(false, false, false);
1427 #endif
1428 MOZ_ASSERT(false,
1429 "Don't use async connections synchronously on the main thread");
1430 return NS_ERROR_NOT_AVAILABLE;
1432 return NS_OK;
1435 bool Connection::isConnectionReadyOnThisThread() {
1436 MOZ_ASSERT_IF(connectionReady(), !mConnectionClosed);
1437 if (mAsyncExecutionThread && mAsyncExecutionThread->IsOnCurrentThread()) {
1438 return true;
1440 return connectionReady();
1443 bool Connection::isClosing() {
1444 MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
1445 return mAsyncExecutionThreadShuttingDown && !mConnectionClosed;
1448 bool Connection::isClosed() {
1449 MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
1450 return mConnectionClosed;
1453 bool Connection::isClosed(MutexAutoLock& lock) { return mConnectionClosed; }
1455 bool Connection::isAsyncExecutionThreadAvailable() {
1456 MOZ_ASSERT(IsOnCurrentSerialEventTarget(eventTargetOpenedOn));
1457 return mAsyncExecutionThread && !mAsyncExecutionThreadShuttingDown;
1460 void Connection::shutdownAsyncThread() {
1461 MOZ_ASSERT(IsOnCurrentSerialEventTarget(eventTargetOpenedOn));
1462 MOZ_ASSERT(mAsyncExecutionThread);
1463 MOZ_ASSERT(mAsyncExecutionThreadShuttingDown);
1465 MOZ_ALWAYS_SUCCEEDS(mAsyncExecutionThread->Shutdown());
1466 mAsyncExecutionThread = nullptr;
1469 nsresult Connection::internalClose(sqlite3* aNativeConnection) {
1470 #ifdef DEBUG
1471 { // Make sure we have marked our async thread as shutting down.
1472 MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
1473 MOZ_ASSERT(mAsyncExecutionThreadShuttingDown,
1474 "Did not call setClosedState!");
1475 MOZ_ASSERT(!isClosed(lockedScope), "Unexpected closed state");
1477 #endif // DEBUG
1479 if (MOZ_LOG_TEST(gStorageLog, LogLevel::Debug)) {
1480 nsAutoCString leafName(":memory");
1481 if (mDatabaseFile) (void)mDatabaseFile->GetNativeLeafName(leafName);
1482 MOZ_LOG(gStorageLog, LogLevel::Debug,
1483 ("Closing connection to '%s'", leafName.get()));
1486 // At this stage, we may still have statements that need to be
1487 // finalized. Attempt to close the database connection. This will
1488 // always disconnect any virtual tables and cleanly finalize their
1489 // internal statements. Once this is done, closing may fail due to
1490 // unfinalized client statements, in which case we need to finalize
1491 // these statements and close again.
1493 MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
1494 mConnectionClosed = true;
1497 // Nothing else needs to be done if we don't have a connection here.
1498 if (!aNativeConnection) return NS_OK;
1500 int srv = ::sqlite3_close(aNativeConnection);
1502 if (srv == SQLITE_BUSY) {
1504 // Nothing else should change the connection or statements status until we
1505 // are done here.
1506 SQLiteMutexAutoLock lockedScope(sharedDBMutex);
1507 // We still have non-finalized statements. Finalize them.
1508 sqlite3_stmt* stmt = nullptr;
1509 while ((stmt = ::sqlite3_next_stmt(aNativeConnection, stmt))) {
1510 MOZ_LOG(gStorageLog, LogLevel::Debug,
1511 ("Auto-finalizing SQL statement '%s' (%p)", ::sqlite3_sql(stmt),
1512 stmt));
1514 #ifdef DEBUG
1515 SmprintfPointer msg = ::mozilla::Smprintf(
1516 "SQL statement '%s' (%p) should have been finalized before closing "
1517 "the connection",
1518 ::sqlite3_sql(stmt), stmt);
1519 NS_WARNING(msg.get());
1520 #endif // DEBUG
1522 srv = ::sqlite3_finalize(stmt);
1524 #ifdef DEBUG
1525 if (srv != SQLITE_OK) {
1526 SmprintfPointer msg = ::mozilla::Smprintf(
1527 "Could not finalize SQL statement (%p)", stmt);
1528 NS_WARNING(msg.get());
1530 #endif // DEBUG
1532 // Ensure that the loop continues properly, whether closing has
1533 // succeeded or not.
1534 if (srv == SQLITE_OK) {
1535 stmt = nullptr;
1538 // Scope exiting will unlock the mutex before we invoke sqlite3_close()
1539 // again, since Sqlite will try to acquire it.
1542 // Now that all statements have been finalized, we
1543 // should be able to close.
1544 srv = ::sqlite3_close(aNativeConnection);
1545 MOZ_ASSERT(false,
1546 "Had to forcibly close the database connection because not all "
1547 "the statements have been finalized.");
1550 if (srv == SQLITE_OK) {
1551 sharedDBMutex.destroy();
1552 } else {
1553 MOZ_ASSERT(false,
1554 "sqlite3_close failed. There are probably outstanding "
1555 "statements that are listed above!");
1558 return convertResultCode(srv);
1561 nsCString Connection::getFilename() { return mTelemetryFilename; }
1563 int Connection::stepStatement(sqlite3* aNativeConnection,
1564 sqlite3_stmt* aStatement) {
1565 MOZ_ASSERT(aStatement);
1567 AUTO_PROFILER_LABEL_DYNAMIC_CSTR("Connection::stepStatement", OTHER,
1568 ::sqlite3_sql(aStatement));
1570 bool checkedMainThread = false;
1571 TimeStamp startTime = TimeStamp::Now();
1573 // The connection may have been closed if the executing statement has been
1574 // created and cached after a call to asyncClose() but before the actual
1575 // sqlite3_close(). This usually happens when other tasks using cached
1576 // statements are asynchronously scheduled for execution and any of them ends
1577 // up after asyncClose. See bug 728653 for details.
1578 if (!isConnectionReadyOnThisThread()) return SQLITE_MISUSE;
1580 (void)::sqlite3_extended_result_codes(aNativeConnection, 1);
1582 int srv;
1583 while ((srv = ::sqlite3_step(aStatement)) == SQLITE_LOCKED_SHAREDCACHE) {
1584 if (!checkedMainThread) {
1585 checkedMainThread = true;
1586 if (::NS_IsMainThread()) {
1587 NS_WARNING("We won't allow blocking on the main thread!");
1588 break;
1592 srv = WaitForUnlockNotify(aNativeConnection);
1593 if (srv != SQLITE_OK) {
1594 break;
1597 ::sqlite3_reset(aStatement);
1600 // Report very slow SQL statements to Telemetry
1601 TimeDuration duration = TimeStamp::Now() - startTime;
1602 const uint32_t threshold = NS_IsMainThread()
1603 ? Telemetry::kSlowSQLThresholdForMainThread
1604 : Telemetry::kSlowSQLThresholdForHelperThreads;
1605 if (duration.ToMilliseconds() >= threshold) {
1606 nsDependentCString statementString(::sqlite3_sql(aStatement));
1607 Telemetry::RecordSlowSQLStatement(
1608 statementString, mTelemetryFilename,
1609 static_cast<uint32_t>(duration.ToMilliseconds()));
1612 (void)::sqlite3_extended_result_codes(aNativeConnection, 0);
1613 // Drop off the extended result bits of the result code.
1614 return srv & 0xFF;
1617 int Connection::prepareStatement(sqlite3* aNativeConnection,
1618 const nsCString& aSQL, sqlite3_stmt** _stmt) {
1619 // We should not even try to prepare statements after the connection has
1620 // been closed.
1621 if (!isConnectionReadyOnThisThread()) return SQLITE_MISUSE;
1623 bool checkedMainThread = false;
1625 (void)::sqlite3_extended_result_codes(aNativeConnection, 1);
1627 int srv;
1628 while ((srv = ::sqlite3_prepare_v2(aNativeConnection, aSQL.get(), -1, _stmt,
1629 nullptr)) == SQLITE_LOCKED_SHAREDCACHE) {
1630 if (!checkedMainThread) {
1631 checkedMainThread = true;
1632 if (::NS_IsMainThread()) {
1633 NS_WARNING("We won't allow blocking on the main thread!");
1634 break;
1638 srv = WaitForUnlockNotify(aNativeConnection);
1639 if (srv != SQLITE_OK) {
1640 break;
1644 if (srv != SQLITE_OK) {
1645 nsCString warnMsg;
1646 warnMsg.AppendLiteral("The SQL statement '");
1647 warnMsg.Append(aSQL);
1648 warnMsg.AppendLiteral("' could not be compiled due to an error: ");
1649 warnMsg.Append(::sqlite3_errmsg(aNativeConnection));
1651 #ifdef DEBUG
1652 NS_WARNING(warnMsg.get());
1653 #endif
1654 MOZ_LOG(gStorageLog, LogLevel::Error, ("%s", warnMsg.get()));
1657 (void)::sqlite3_extended_result_codes(aNativeConnection, 0);
1658 // Drop off the extended result bits of the result code.
1659 int rc = srv & 0xFF;
1660 // sqlite will return OK on a comment only string and set _stmt to nullptr.
1661 // The callers of this function are used to only checking the return value,
1662 // so it is safer to return an error code.
1663 if (rc == SQLITE_OK && *_stmt == nullptr) {
1664 return SQLITE_MISUSE;
1667 return rc;
1670 int Connection::executeSql(sqlite3* aNativeConnection, const char* aSqlString) {
1671 if (!isConnectionReadyOnThisThread()) return SQLITE_MISUSE;
1673 AUTO_PROFILER_LABEL_DYNAMIC_CSTR("Connection::executeSql", OTHER, aSqlString);
1675 TimeStamp startTime = TimeStamp::Now();
1676 int srv =
1677 ::sqlite3_exec(aNativeConnection, aSqlString, nullptr, nullptr, nullptr);
1678 RecordQueryStatus(srv);
1680 // Report very slow SQL statements to Telemetry
1681 TimeDuration duration = TimeStamp::Now() - startTime;
1682 const uint32_t threshold = NS_IsMainThread()
1683 ? Telemetry::kSlowSQLThresholdForMainThread
1684 : Telemetry::kSlowSQLThresholdForHelperThreads;
1685 if (duration.ToMilliseconds() >= threshold) {
1686 nsDependentCString statementString(aSqlString);
1687 Telemetry::RecordSlowSQLStatement(
1688 statementString, mTelemetryFilename,
1689 static_cast<uint32_t>(duration.ToMilliseconds()));
1692 return srv;
1695 ////////////////////////////////////////////////////////////////////////////////
1696 //// nsIInterfaceRequestor
1698 NS_IMETHODIMP
1699 Connection::GetInterface(const nsIID& aIID, void** _result) {
1700 if (aIID.Equals(NS_GET_IID(nsIEventTarget))) {
1701 nsIEventTarget* background = getAsyncExecutionTarget();
1702 NS_IF_ADDREF(background);
1703 *_result = background;
1704 return NS_OK;
1706 return NS_ERROR_NO_INTERFACE;
1709 ////////////////////////////////////////////////////////////////////////////////
1710 //// mozIStorageConnection
1712 NS_IMETHODIMP
1713 Connection::Close() {
1714 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
1715 if (NS_FAILED(rv)) {
1716 return rv;
1718 return synchronousClose();
1721 nsresult Connection::synchronousClose() {
1722 if (!connectionReady()) {
1723 return NS_ERROR_NOT_INITIALIZED;
1726 #ifdef DEBUG
1727 // Since we're accessing mAsyncExecutionThread, we need to be on the opener
1728 // event target. We make this check outside of debug code below in
1729 // setClosedState, but this is here to be explicit.
1730 MOZ_ASSERT(IsOnCurrentSerialEventTarget(eventTargetOpenedOn));
1731 #endif // DEBUG
1733 // Make sure we have not executed any asynchronous statements.
1734 // If this fails, the mDBConn may be left open, resulting in a leak.
1735 // We'll try to finalize the pending statements and close the connection.
1736 if (isAsyncExecutionThreadAvailable()) {
1737 #ifdef DEBUG
1738 if (NS_IsMainThread()) {
1739 nsCOMPtr<nsIXPConnect> xpc = nsIXPConnect::XPConnect();
1740 Unused << xpc->DebugDumpJSStack(false, false, false);
1742 #endif
1743 MOZ_ASSERT(false,
1744 "Close() was invoked on a connection that executed asynchronous "
1745 "statements. "
1746 "Should have used asyncClose().");
1747 // Try to close the database regardless, to free up resources.
1748 Unused << SpinningSynchronousClose();
1749 return NS_ERROR_UNEXPECTED;
1752 // setClosedState nullifies our connection pointer, so we take a raw pointer
1753 // off it, to pass it through the close procedure.
1754 sqlite3* nativeConn = mDBConn;
1755 nsresult rv = setClosedState();
1756 NS_ENSURE_SUCCESS(rv, rv);
1758 return internalClose(nativeConn);
1761 NS_IMETHODIMP
1762 Connection::SpinningSynchronousClose() {
1763 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
1764 if (NS_FAILED(rv)) {
1765 return rv;
1767 if (!IsOnCurrentSerialEventTarget(eventTargetOpenedOn)) {
1768 return NS_ERROR_NOT_SAME_THREAD;
1771 // As currently implemented, we can't spin to wait for an existing AsyncClose.
1772 // Our only existing caller will never have called close; assert if misused
1773 // so that no new callers assume this works after an AsyncClose.
1774 MOZ_DIAGNOSTIC_ASSERT(connectionReady());
1775 if (!connectionReady()) {
1776 return NS_ERROR_UNEXPECTED;
1779 RefPtr<CloseListener> listener = new CloseListener();
1780 rv = AsyncClose(listener);
1781 NS_ENSURE_SUCCESS(rv, rv);
1782 MOZ_ALWAYS_TRUE(
1783 SpinEventLoopUntil("storage::Connection::SpinningSynchronousClose"_ns,
1784 [&]() { return listener->mClosed; }));
1785 MOZ_ASSERT(isClosed(), "The connection should be closed at this point");
1787 return rv;
1790 NS_IMETHODIMP
1791 Connection::AsyncClose(mozIStorageCompletionCallback* aCallback) {
1792 NS_ENSURE_TRUE(NS_IsMainThread(), NS_ERROR_NOT_SAME_THREAD);
1793 // Check if AsyncClose or Close were already invoked.
1794 if (!connectionReady()) {
1795 return NS_ERROR_NOT_INITIALIZED;
1797 nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
1798 if (NS_FAILED(rv)) {
1799 return rv;
1802 // The two relevant factors at this point are whether we have a database
1803 // connection and whether we have an async execution thread. Here's what the
1804 // states mean and how we handle them:
1806 // - (mDBConn && asyncThread): The expected case where we are either an
1807 // async connection or a sync connection that has been used asynchronously.
1808 // Either way the caller must call us and not Close(). Nothing surprising
1809 // about this. We'll dispatch AsyncCloseConnection to the already-existing
1810 // async thread.
1812 // - (mDBConn && !asyncThread): A somewhat unusual case where the caller
1813 // opened the connection synchronously and was planning to use it
1814 // asynchronously, but never got around to using it asynchronously before
1815 // needing to shutdown. This has been observed to happen for the cookie
1816 // service in a case where Firefox shuts itself down almost immediately
1817 // after startup (for unknown reasons). In the Firefox shutdown case,
1818 // we may also fail to create a new async execution thread if one does not
1819 // already exist. (nsThreadManager will refuse to create new threads when
1820 // it has already been told to shutdown.) As such, we need to handle a
1821 // failure to create the async execution thread by falling back to
1822 // synchronous Close() and also dispatching the completion callback because
1823 // at least Places likes to spin a nested event loop that depends on the
1824 // callback being invoked.
1826 // Note that we have considered not trying to spin up the async execution
1827 // thread in this case if it does not already exist, but the overhead of
1828 // thread startup (if successful) is significantly less expensive than the
1829 // worst-case potential I/O hit of synchronously closing a database when we
1830 // could close it asynchronously.
1832 // - (!mDBConn && asyncThread): This happens in some but not all cases where
1833 // OpenAsyncDatabase encountered a problem opening the database. If it
1834 // happened in all cases AsyncInitDatabase would just shut down the thread
1835 // directly and we would avoid this case. But it doesn't, so for simplicity
1836 // and consistency AsyncCloseConnection knows how to handle this and we
1837 // act like this was the (mDBConn && asyncThread) case in this method.
1839 // - (!mDBConn && !asyncThread): The database was never successfully opened or
1840 // Close() or AsyncClose() has already been called (at least) once. This is
1841 // undeniably a misuse case by the caller. We could optimize for this
1842 // case by adding an additional check of mAsyncExecutionThread without using
1843 // getAsyncExecutionTarget() to avoid wastefully creating a thread just to
1844 // shut it down. But this complicates the method for broken caller code
1845 // whereas we're still correct and safe without the special-case.
1846 nsIEventTarget* asyncThread = getAsyncExecutionTarget();
1848 // Create our callback event if we were given a callback. This will
1849 // eventually be dispatched in all cases, even if we fall back to Close() and
1850 // the database wasn't open and we return an error. The rationale is that
1851 // no existing consumer checks our return value and several of them like to
1852 // spin nested event loops until the callback fires. Given that, it seems
1853 // preferable for us to dispatch the callback in all cases. (Except the
1854 // wrong thread misuse case we bailed on up above. But that's okay because
1855 // that is statically wrong whereas these edge cases are dynamic.)
1856 nsCOMPtr<nsIRunnable> completeEvent;
1857 if (aCallback) {
1858 completeEvent = newCompletionEvent(aCallback);
1861 if (!asyncThread) {
1862 // We were unable to create an async thread, so we need to fall back to
1863 // using normal Close(). Since there is no async thread, Close() will
1864 // not complain about that. (Close() may, however, complain if the
1865 // connection is closed, but that's okay.)
1866 if (completeEvent) {
1867 // Closing the database is more important than returning an error code
1868 // about a failure to dispatch, especially because all existing native
1869 // callers ignore our return value.
1870 Unused << NS_DispatchToMainThread(completeEvent.forget());
1872 MOZ_ALWAYS_SUCCEEDS(synchronousClose());
1873 // Return a success inconditionally here, since Close() is unlikely to fail
1874 // and we want to reassure the consumer that its callback will be invoked.
1875 return NS_OK;
1878 // If we're closing the connection during shutdown, and there is an
1879 // interruptible statement running on the helper thread, issue a
1880 // sqlite3_interrupt() to avoid crashing when that statement takes a long
1881 // time (for example a vacuum).
1882 if (AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownConfirmed) &&
1883 mInterruptible && mIsStatementOnHelperThreadInterruptible) {
1884 MOZ_ASSERT(!isClosing(), "Must not be closing, see Interrupt()");
1885 DebugOnly<nsresult> rv2 = Interrupt();
1886 MOZ_ASSERT(NS_SUCCEEDED(rv2));
1889 // setClosedState nullifies our connection pointer, so we take a raw pointer
1890 // off it, to pass it through the close procedure.
1891 sqlite3* nativeConn = mDBConn;
1892 rv = setClosedState();
1893 NS_ENSURE_SUCCESS(rv, rv);
1895 // Create and dispatch our close event to the background thread.
1896 nsCOMPtr<nsIRunnable> closeEvent =
1897 new AsyncCloseConnection(this, nativeConn, completeEvent);
1898 rv = asyncThread->Dispatch(closeEvent, NS_DISPATCH_NORMAL);
1899 NS_ENSURE_SUCCESS(rv, rv);
1901 return NS_OK;
1904 NS_IMETHODIMP
1905 Connection::AsyncClone(bool aReadOnly,
1906 mozIStorageCompletionCallback* aCallback) {
1907 AUTO_PROFILER_LABEL("Connection::AsyncClone", OTHER);
1909 NS_ENSURE_TRUE(NS_IsMainThread(), NS_ERROR_NOT_SAME_THREAD);
1910 if (!connectionReady()) {
1911 return NS_ERROR_NOT_INITIALIZED;
1913 nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
1914 if (NS_FAILED(rv)) {
1915 return rv;
1917 if (!mDatabaseFile) return NS_ERROR_UNEXPECTED;
1919 int flags = mFlags;
1920 if (aReadOnly) {
1921 // Turn off SQLITE_OPEN_READWRITE, and set SQLITE_OPEN_READONLY.
1922 flags = (~SQLITE_OPEN_READWRITE & flags) | SQLITE_OPEN_READONLY;
1923 // Turn off SQLITE_OPEN_CREATE.
1924 flags = (~SQLITE_OPEN_CREATE & flags);
1927 // The cloned connection will still implement the synchronous API, but throw
1928 // if any synchronous methods are called on the main thread.
1929 RefPtr<Connection> clone =
1930 new Connection(mStorageService, flags, ASYNCHRONOUS, mTelemetryFilename);
1932 RefPtr<AsyncInitializeClone> initEvent =
1933 new AsyncInitializeClone(this, clone, aReadOnly, aCallback);
1934 // Dispatch to our async thread, since the originating connection must remain
1935 // valid and open for the whole cloning process. This also ensures we are
1936 // properly serialized with a `close` operation, rather than race with it.
1937 nsCOMPtr<nsIEventTarget> target = getAsyncExecutionTarget();
1938 if (!target) {
1939 return NS_ERROR_UNEXPECTED;
1941 return target->Dispatch(initEvent, NS_DISPATCH_NORMAL);
1944 nsresult Connection::initializeClone(Connection* aClone, bool aReadOnly) {
1945 nsresult rv;
1946 if (!mStorageKey.IsEmpty()) {
1947 rv = aClone->initialize(mStorageKey, mName);
1948 } else if (mFileURL) {
1949 rv = aClone->initialize(mFileURL);
1950 } else {
1951 rv = aClone->initialize(mDatabaseFile);
1953 if (NS_FAILED(rv)) {
1954 return rv;
1957 auto guard = MakeScopeExit([&]() { aClone->initializeFailed(); });
1959 rv = aClone->SetDefaultTransactionType(mDefaultTransactionType);
1960 NS_ENSURE_SUCCESS(rv, rv);
1962 // Re-attach on-disk databases that were attached to the original connection.
1964 nsCOMPtr<mozIStorageStatement> stmt;
1965 rv = CreateStatement("PRAGMA database_list"_ns, getter_AddRefs(stmt));
1966 NS_ENSURE_SUCCESS(rv, rv);
1967 bool hasResult = false;
1968 while (stmt && NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)) && hasResult) {
1969 nsAutoCString name;
1970 rv = stmt->GetUTF8String(1, name);
1971 if (NS_SUCCEEDED(rv) && !name.EqualsLiteral("main") &&
1972 !name.EqualsLiteral("temp")) {
1973 nsCString path;
1974 rv = stmt->GetUTF8String(2, path);
1975 if (NS_SUCCEEDED(rv) && !path.IsEmpty()) {
1976 nsCOMPtr<mozIStorageStatement> attachStmt;
1977 rv = aClone->CreateStatement("ATTACH DATABASE :path AS "_ns + name,
1978 getter_AddRefs(attachStmt));
1979 NS_ENSURE_SUCCESS(rv, rv);
1980 rv = attachStmt->BindUTF8StringByName("path"_ns, path);
1981 NS_ENSURE_SUCCESS(rv, rv);
1982 rv = attachStmt->Execute();
1983 NS_ENSURE_SUCCESS(rv, rv);
1989 // Copy over pragmas from the original connection.
1990 // LIMITATION WARNING! Many of these pragmas are actually scoped to the
1991 // schema ("main" and any other attached databases), and this implmentation
1992 // fails to propagate them. This is being addressed on trunk.
1993 static const char* pragmas[] = {
1994 "cache_size", "temp_store", "foreign_keys", "journal_size_limit",
1995 "synchronous", "wal_autocheckpoint", "busy_timeout"};
1996 for (auto& pragma : pragmas) {
1997 // Read-only connections just need cache_size and temp_store pragmas.
1998 if (aReadOnly && ::strcmp(pragma, "cache_size") != 0 &&
1999 ::strcmp(pragma, "temp_store") != 0) {
2000 continue;
2003 nsAutoCString pragmaQuery("PRAGMA ");
2004 pragmaQuery.Append(pragma);
2005 nsCOMPtr<mozIStorageStatement> stmt;
2006 rv = CreateStatement(pragmaQuery, getter_AddRefs(stmt));
2007 NS_ENSURE_SUCCESS(rv, rv);
2008 bool hasResult = false;
2009 if (stmt && NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)) && hasResult) {
2010 pragmaQuery.AppendLiteral(" = ");
2011 pragmaQuery.AppendInt(stmt->AsInt32(0));
2012 rv = aClone->ExecuteSimpleSQL(pragmaQuery);
2013 NS_ENSURE_SUCCESS(rv, rv);
2017 // Copy over temporary tables, triggers, and views from the original
2018 // connections. Entities in `sqlite_temp_master` are only visible to the
2019 // connection that created them.
2020 if (!aReadOnly) {
2021 rv = aClone->ExecuteSimpleSQL("BEGIN TRANSACTION"_ns);
2022 NS_ENSURE_SUCCESS(rv, rv);
2024 nsCOMPtr<mozIStorageStatement> stmt;
2025 rv = CreateStatement(nsLiteralCString("SELECT sql FROM sqlite_temp_master "
2026 "WHERE type IN ('table', 'view', "
2027 "'index', 'trigger')"),
2028 getter_AddRefs(stmt));
2029 // Propagate errors, because failing to copy triggers might cause schema
2030 // coherency issues when writing to the database from the cloned connection.
2031 NS_ENSURE_SUCCESS(rv, rv);
2032 bool hasResult = false;
2033 while (stmt && NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)) && hasResult) {
2034 nsAutoCString query;
2035 rv = stmt->GetUTF8String(0, query);
2036 NS_ENSURE_SUCCESS(rv, rv);
2038 // The `CREATE` SQL statements in `sqlite_temp_master` omit the `TEMP`
2039 // keyword. We need to add it back, or we'll recreate temporary entities
2040 // as persistent ones. `sqlite_temp_master` also holds `CREATE INDEX`
2041 // statements, but those don't need `TEMP` keywords.
2042 if (StringBeginsWith(query, "CREATE TABLE "_ns) ||
2043 StringBeginsWith(query, "CREATE TRIGGER "_ns) ||
2044 StringBeginsWith(query, "CREATE VIEW "_ns)) {
2045 query.Replace(0, 6, "CREATE TEMP");
2048 rv = aClone->ExecuteSimpleSQL(query);
2049 NS_ENSURE_SUCCESS(rv, rv);
2052 rv = aClone->ExecuteSimpleSQL("COMMIT"_ns);
2053 NS_ENSURE_SUCCESS(rv, rv);
2056 // Copy any functions that have been added to this connection.
2057 SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2058 for (const auto& entry : mFunctions) {
2059 const nsACString& key = entry.GetKey();
2060 Connection::FunctionInfo data = entry.GetData();
2062 rv = aClone->CreateFunction(key, data.numArgs, data.function);
2063 if (NS_FAILED(rv)) {
2064 NS_WARNING("Failed to copy function to cloned connection");
2068 // Load SQLite extensions that were on this connection.
2069 // Copy into an array rather than holding the mutex while we load extensions.
2070 nsTArray<nsCString> loadedExtensions;
2072 MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
2073 AppendToArray(loadedExtensions, mLoadedExtensions);
2075 for (const auto& extension : loadedExtensions) {
2076 (void)aClone->LoadExtension(extension, nullptr);
2079 guard.release();
2080 return NS_OK;
2083 NS_IMETHODIMP
2084 Connection::Clone(bool aReadOnly, mozIStorageConnection** _connection) {
2085 MOZ_ASSERT(IsOnCurrentSerialEventTarget(eventTargetOpenedOn));
2087 AUTO_PROFILER_LABEL("Connection::Clone", OTHER);
2089 if (!connectionReady()) {
2090 return NS_ERROR_NOT_INITIALIZED;
2092 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2093 if (NS_FAILED(rv)) {
2094 return rv;
2097 int flags = mFlags;
2098 if (aReadOnly) {
2099 // Turn off SQLITE_OPEN_READWRITE, and set SQLITE_OPEN_READONLY.
2100 flags = (~SQLITE_OPEN_READWRITE & flags) | SQLITE_OPEN_READONLY;
2101 // Turn off SQLITE_OPEN_CREATE.
2102 flags = (~SQLITE_OPEN_CREATE & flags);
2105 RefPtr<Connection> clone =
2106 new Connection(mStorageService, flags, mSupportedOperations,
2107 mTelemetryFilename, mInterruptible);
2109 rv = initializeClone(clone, aReadOnly);
2110 if (NS_FAILED(rv)) {
2111 return rv;
2114 NS_IF_ADDREF(*_connection = clone);
2115 return NS_OK;
2118 NS_IMETHODIMP
2119 Connection::Interrupt() {
2120 MOZ_ASSERT(mInterruptible, "Interrupt method not allowed");
2121 MOZ_ASSERT_IF(SYNCHRONOUS == mSupportedOperations,
2122 !IsOnCurrentSerialEventTarget(eventTargetOpenedOn));
2123 MOZ_ASSERT_IF(ASYNCHRONOUS == mSupportedOperations,
2124 IsOnCurrentSerialEventTarget(eventTargetOpenedOn));
2126 if (!connectionReady()) {
2127 return NS_ERROR_NOT_INITIALIZED;
2130 if (isClosing()) { // Closing already in asynchronous case
2131 return NS_OK;
2135 // As stated on https://www.sqlite.org/c3ref/interrupt.html,
2136 // it is not safe to call sqlite3_interrupt() when
2137 // database connection is closed or might close before
2138 // sqlite3_interrupt() returns.
2139 MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
2140 if (!isClosed(lockedScope)) {
2141 MOZ_ASSERT(mDBConn);
2142 ::sqlite3_interrupt(mDBConn);
2146 return NS_OK;
2149 NS_IMETHODIMP
2150 Connection::AsyncVacuum(mozIStorageCompletionCallback* aCallback,
2151 bool aUseIncremental, int32_t aSetPageSize) {
2152 NS_ENSURE_TRUE(NS_IsMainThread(), NS_ERROR_NOT_SAME_THREAD);
2153 // Abort if we're shutting down.
2154 if (AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownConfirmed)) {
2155 return NS_ERROR_ABORT;
2157 // Check if AsyncClose or Close were already invoked.
2158 if (!connectionReady()) {
2159 return NS_ERROR_NOT_INITIALIZED;
2161 nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2162 if (NS_FAILED(rv)) {
2163 return rv;
2165 nsIEventTarget* asyncThread = getAsyncExecutionTarget();
2166 if (!asyncThread) {
2167 return NS_ERROR_NOT_INITIALIZED;
2170 // Create and dispatch our vacuum event to the background thread.
2171 nsCOMPtr<nsIRunnable> vacuumEvent =
2172 new AsyncVacuumEvent(this, aCallback, aUseIncremental, aSetPageSize);
2173 rv = asyncThread->Dispatch(vacuumEvent, NS_DISPATCH_NORMAL);
2174 NS_ENSURE_SUCCESS(rv, rv);
2176 return NS_OK;
2179 NS_IMETHODIMP
2180 Connection::GetDefaultPageSize(int32_t* _defaultPageSize) {
2181 *_defaultPageSize = Service::kDefaultPageSize;
2182 return NS_OK;
2185 NS_IMETHODIMP
2186 Connection::GetConnectionReady(bool* _ready) {
2187 MOZ_ASSERT(IsOnCurrentSerialEventTarget(eventTargetOpenedOn));
2188 *_ready = connectionReady();
2189 return NS_OK;
2192 NS_IMETHODIMP
2193 Connection::GetDatabaseFile(nsIFile** _dbFile) {
2194 if (!connectionReady()) {
2195 return NS_ERROR_NOT_INITIALIZED;
2197 nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2198 if (NS_FAILED(rv)) {
2199 return rv;
2202 NS_IF_ADDREF(*_dbFile = mDatabaseFile);
2204 return NS_OK;
2207 NS_IMETHODIMP
2208 Connection::GetLastInsertRowID(int64_t* _id) {
2209 if (!connectionReady()) {
2210 return NS_ERROR_NOT_INITIALIZED;
2212 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2213 if (NS_FAILED(rv)) {
2214 return rv;
2217 sqlite_int64 id = ::sqlite3_last_insert_rowid(mDBConn);
2218 *_id = id;
2220 return NS_OK;
2223 NS_IMETHODIMP
2224 Connection::GetAffectedRows(int32_t* _rows) {
2225 if (!connectionReady()) {
2226 return NS_ERROR_NOT_INITIALIZED;
2228 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2229 if (NS_FAILED(rv)) {
2230 return rv;
2233 *_rows = ::sqlite3_changes(mDBConn);
2235 return NS_OK;
2238 NS_IMETHODIMP
2239 Connection::GetLastError(int32_t* _error) {
2240 if (!connectionReady()) {
2241 return NS_ERROR_NOT_INITIALIZED;
2243 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2244 if (NS_FAILED(rv)) {
2245 return rv;
2248 *_error = ::sqlite3_errcode(mDBConn);
2250 return NS_OK;
2253 NS_IMETHODIMP
2254 Connection::GetLastErrorString(nsACString& _errorString) {
2255 if (!connectionReady()) {
2256 return NS_ERROR_NOT_INITIALIZED;
2258 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2259 if (NS_FAILED(rv)) {
2260 return rv;
2263 const char* serr = ::sqlite3_errmsg(mDBConn);
2264 _errorString.Assign(serr);
2266 return NS_OK;
2269 NS_IMETHODIMP
2270 Connection::GetSchemaVersion(int32_t* _version) {
2271 if (!connectionReady()) {
2272 return NS_ERROR_NOT_INITIALIZED;
2274 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2275 if (NS_FAILED(rv)) {
2276 return rv;
2279 nsCOMPtr<mozIStorageStatement> stmt;
2280 (void)CreateStatement("PRAGMA user_version"_ns, getter_AddRefs(stmt));
2281 NS_ENSURE_TRUE(stmt, NS_ERROR_OUT_OF_MEMORY);
2283 *_version = 0;
2284 bool hasResult;
2285 if (NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)) && hasResult) {
2286 *_version = stmt->AsInt32(0);
2289 return NS_OK;
2292 NS_IMETHODIMP
2293 Connection::SetSchemaVersion(int32_t aVersion) {
2294 if (!connectionReady()) {
2295 return NS_ERROR_NOT_INITIALIZED;
2297 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2298 if (NS_FAILED(rv)) {
2299 return rv;
2302 nsAutoCString stmt("PRAGMA user_version = "_ns);
2303 stmt.AppendInt(aVersion);
2305 return ExecuteSimpleSQL(stmt);
2308 NS_IMETHODIMP
2309 Connection::CreateStatement(const nsACString& aSQLStatement,
2310 mozIStorageStatement** _stmt) {
2311 NS_ENSURE_ARG_POINTER(_stmt);
2312 if (!connectionReady()) {
2313 return NS_ERROR_NOT_INITIALIZED;
2315 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2316 if (NS_FAILED(rv)) {
2317 return rv;
2320 RefPtr<Statement> statement(new Statement());
2321 NS_ENSURE_TRUE(statement, NS_ERROR_OUT_OF_MEMORY);
2323 rv = statement->initialize(this, mDBConn, aSQLStatement);
2324 NS_ENSURE_SUCCESS(rv, rv);
2326 Statement* rawPtr;
2327 statement.forget(&rawPtr);
2328 *_stmt = rawPtr;
2329 return NS_OK;
2332 NS_IMETHODIMP
2333 Connection::CreateAsyncStatement(const nsACString& aSQLStatement,
2334 mozIStorageAsyncStatement** _stmt) {
2335 NS_ENSURE_ARG_POINTER(_stmt);
2336 if (!connectionReady()) {
2337 return NS_ERROR_NOT_INITIALIZED;
2339 nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2340 if (NS_FAILED(rv)) {
2341 return rv;
2344 RefPtr<AsyncStatement> statement(new AsyncStatement());
2345 NS_ENSURE_TRUE(statement, NS_ERROR_OUT_OF_MEMORY);
2347 rv = statement->initialize(this, mDBConn, aSQLStatement);
2348 NS_ENSURE_SUCCESS(rv, rv);
2350 AsyncStatement* rawPtr;
2351 statement.forget(&rawPtr);
2352 *_stmt = rawPtr;
2353 return NS_OK;
2356 NS_IMETHODIMP
2357 Connection::ExecuteSimpleSQL(const nsACString& aSQLStatement) {
2358 CHECK_MAINTHREAD_ABUSE();
2359 if (!connectionReady()) {
2360 return NS_ERROR_NOT_INITIALIZED;
2362 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2363 if (NS_FAILED(rv)) {
2364 return rv;
2367 int srv = executeSql(mDBConn, PromiseFlatCString(aSQLStatement).get());
2368 return convertResultCode(srv);
2371 NS_IMETHODIMP
2372 Connection::ExecuteAsync(
2373 const nsTArray<RefPtr<mozIStorageBaseStatement>>& aStatements,
2374 mozIStorageStatementCallback* aCallback,
2375 mozIStoragePendingStatement** _handle) {
2376 nsTArray<StatementData> stmts(aStatements.Length());
2377 for (uint32_t i = 0; i < aStatements.Length(); i++) {
2378 nsCOMPtr<StorageBaseStatementInternal> stmt =
2379 do_QueryInterface(aStatements[i]);
2380 NS_ENSURE_STATE(stmt);
2382 // Obtain our StatementData.
2383 StatementData data;
2384 nsresult rv = stmt->getAsynchronousStatementData(data);
2385 NS_ENSURE_SUCCESS(rv, rv);
2387 NS_ASSERTION(stmt->getOwner() == this,
2388 "Statement must be from this database connection!");
2390 // Now append it to our array.
2391 stmts.AppendElement(data);
2394 // Dispatch to the background
2395 return AsyncExecuteStatements::execute(std::move(stmts), this, mDBConn,
2396 aCallback, _handle);
2399 NS_IMETHODIMP
2400 Connection::ExecuteSimpleSQLAsync(const nsACString& aSQLStatement,
2401 mozIStorageStatementCallback* aCallback,
2402 mozIStoragePendingStatement** _handle) {
2403 NS_ENSURE_TRUE(NS_IsMainThread(), NS_ERROR_NOT_SAME_THREAD);
2405 nsCOMPtr<mozIStorageAsyncStatement> stmt;
2406 nsresult rv = CreateAsyncStatement(aSQLStatement, getter_AddRefs(stmt));
2407 if (NS_FAILED(rv)) {
2408 return rv;
2411 nsCOMPtr<mozIStoragePendingStatement> pendingStatement;
2412 rv = stmt->ExecuteAsync(aCallback, getter_AddRefs(pendingStatement));
2413 if (NS_FAILED(rv)) {
2414 return rv;
2417 pendingStatement.forget(_handle);
2418 return rv;
2421 NS_IMETHODIMP
2422 Connection::TableExists(const nsACString& aTableName, bool* _exists) {
2423 return databaseElementExists(TABLE, aTableName, _exists);
2426 NS_IMETHODIMP
2427 Connection::IndexExists(const nsACString& aIndexName, bool* _exists) {
2428 return databaseElementExists(INDEX, aIndexName, _exists);
2431 NS_IMETHODIMP
2432 Connection::GetTransactionInProgress(bool* _inProgress) {
2433 if (!connectionReady()) {
2434 return NS_ERROR_NOT_INITIALIZED;
2436 nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2437 if (NS_FAILED(rv)) {
2438 return rv;
2441 SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2442 *_inProgress = transactionInProgress(lockedScope);
2443 return NS_OK;
2446 NS_IMETHODIMP
2447 Connection::GetDefaultTransactionType(int32_t* _type) {
2448 *_type = mDefaultTransactionType;
2449 return NS_OK;
2452 NS_IMETHODIMP
2453 Connection::SetDefaultTransactionType(int32_t aType) {
2454 NS_ENSURE_ARG_RANGE(aType, TRANSACTION_DEFERRED, TRANSACTION_EXCLUSIVE);
2455 mDefaultTransactionType = aType;
2456 return NS_OK;
2459 NS_IMETHODIMP
2460 Connection::GetVariableLimit(int32_t* _limit) {
2461 if (!connectionReady()) {
2462 return NS_ERROR_NOT_INITIALIZED;
2464 int limit = ::sqlite3_limit(mDBConn, SQLITE_LIMIT_VARIABLE_NUMBER, -1);
2465 if (limit < 0) {
2466 return NS_ERROR_UNEXPECTED;
2468 *_limit = limit;
2469 return NS_OK;
2472 NS_IMETHODIMP
2473 Connection::SetVariableLimit(int32_t limit) {
2474 if (!connectionReady()) {
2475 return NS_ERROR_NOT_INITIALIZED;
2477 int oldLimit = ::sqlite3_limit(mDBConn, SQLITE_LIMIT_VARIABLE_NUMBER, limit);
2478 if (oldLimit < 0) {
2479 return NS_ERROR_UNEXPECTED;
2481 return NS_OK;
2484 NS_IMETHODIMP
2485 Connection::BeginTransaction() {
2486 if (!connectionReady()) {
2487 return NS_ERROR_NOT_INITIALIZED;
2489 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2490 if (NS_FAILED(rv)) {
2491 return rv;
2494 SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2495 return beginTransactionInternal(lockedScope, mDBConn,
2496 mDefaultTransactionType);
2499 nsresult Connection::beginTransactionInternal(
2500 const SQLiteMutexAutoLock& aProofOfLock, sqlite3* aNativeConnection,
2501 int32_t aTransactionType) {
2502 if (transactionInProgress(aProofOfLock)) {
2503 return NS_ERROR_FAILURE;
2505 nsresult rv;
2506 switch (aTransactionType) {
2507 case TRANSACTION_DEFERRED:
2508 rv = convertResultCode(executeSql(aNativeConnection, "BEGIN DEFERRED"));
2509 break;
2510 case TRANSACTION_IMMEDIATE:
2511 rv = convertResultCode(executeSql(aNativeConnection, "BEGIN IMMEDIATE"));
2512 break;
2513 case TRANSACTION_EXCLUSIVE:
2514 rv = convertResultCode(executeSql(aNativeConnection, "BEGIN EXCLUSIVE"));
2515 break;
2516 default:
2517 return NS_ERROR_ILLEGAL_VALUE;
2519 return rv;
2522 NS_IMETHODIMP
2523 Connection::CommitTransaction() {
2524 if (!connectionReady()) {
2525 return NS_ERROR_NOT_INITIALIZED;
2527 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2528 if (NS_FAILED(rv)) {
2529 return rv;
2532 SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2533 return commitTransactionInternal(lockedScope, mDBConn);
2536 nsresult Connection::commitTransactionInternal(
2537 const SQLiteMutexAutoLock& aProofOfLock, sqlite3* aNativeConnection) {
2538 if (!transactionInProgress(aProofOfLock)) {
2539 return NS_ERROR_UNEXPECTED;
2541 nsresult rv =
2542 convertResultCode(executeSql(aNativeConnection, "COMMIT TRANSACTION"));
2543 return rv;
2546 NS_IMETHODIMP
2547 Connection::RollbackTransaction() {
2548 if (!connectionReady()) {
2549 return NS_ERROR_NOT_INITIALIZED;
2551 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2552 if (NS_FAILED(rv)) {
2553 return rv;
2556 SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2557 return rollbackTransactionInternal(lockedScope, mDBConn);
2560 nsresult Connection::rollbackTransactionInternal(
2561 const SQLiteMutexAutoLock& aProofOfLock, sqlite3* aNativeConnection) {
2562 if (!transactionInProgress(aProofOfLock)) {
2563 return NS_ERROR_UNEXPECTED;
2566 nsresult rv =
2567 convertResultCode(executeSql(aNativeConnection, "ROLLBACK TRANSACTION"));
2568 return rv;
2571 NS_IMETHODIMP
2572 Connection::CreateTable(const char* aTableName, const char* aTableSchema) {
2573 if (!connectionReady()) {
2574 return NS_ERROR_NOT_INITIALIZED;
2576 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2577 if (NS_FAILED(rv)) {
2578 return rv;
2581 SmprintfPointer buf =
2582 ::mozilla::Smprintf("CREATE TABLE %s (%s)", aTableName, aTableSchema);
2583 if (!buf) return NS_ERROR_OUT_OF_MEMORY;
2585 int srv = executeSql(mDBConn, buf.get());
2587 return convertResultCode(srv);
2590 NS_IMETHODIMP
2591 Connection::CreateFunction(const nsACString& aFunctionName,
2592 int32_t aNumArguments,
2593 mozIStorageFunction* aFunction) {
2594 if (!connectionReady()) {
2595 return NS_ERROR_NOT_INITIALIZED;
2597 nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2598 if (NS_FAILED(rv)) {
2599 return rv;
2602 // Check to see if this function is already defined. We only check the name
2603 // because a function can be defined with the same body but different names.
2604 SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2605 NS_ENSURE_FALSE(mFunctions.Contains(aFunctionName), NS_ERROR_FAILURE);
2607 int srv = ::sqlite3_create_function(
2608 mDBConn, nsPromiseFlatCString(aFunctionName).get(), aNumArguments,
2609 SQLITE_ANY, aFunction, basicFunctionHelper, nullptr, nullptr);
2610 if (srv != SQLITE_OK) return convertResultCode(srv);
2612 FunctionInfo info = {aFunction, aNumArguments};
2613 mFunctions.InsertOrUpdate(aFunctionName, info);
2615 return NS_OK;
2618 NS_IMETHODIMP
2619 Connection::RemoveFunction(const nsACString& aFunctionName) {
2620 if (!connectionReady()) {
2621 return NS_ERROR_NOT_INITIALIZED;
2623 nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2624 if (NS_FAILED(rv)) {
2625 return rv;
2628 SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2629 NS_ENSURE_TRUE(mFunctions.Get(aFunctionName, nullptr), NS_ERROR_FAILURE);
2631 int srv = ::sqlite3_create_function(
2632 mDBConn, nsPromiseFlatCString(aFunctionName).get(), 0, SQLITE_ANY,
2633 nullptr, nullptr, nullptr, nullptr);
2634 if (srv != SQLITE_OK) return convertResultCode(srv);
2636 mFunctions.Remove(aFunctionName);
2638 return NS_OK;
2641 NS_IMETHODIMP
2642 Connection::SetProgressHandler(int32_t aGranularity,
2643 mozIStorageProgressHandler* aHandler,
2644 mozIStorageProgressHandler** _oldHandler) {
2645 if (!connectionReady()) {
2646 return NS_ERROR_NOT_INITIALIZED;
2648 nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2649 if (NS_FAILED(rv)) {
2650 return rv;
2653 // Return previous one
2654 SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2655 NS_IF_ADDREF(*_oldHandler = mProgressHandler);
2657 if (!aHandler || aGranularity <= 0) {
2658 aHandler = nullptr;
2659 aGranularity = 0;
2661 mProgressHandler = aHandler;
2662 ::sqlite3_progress_handler(mDBConn, aGranularity, sProgressHelper, this);
2664 return NS_OK;
2667 NS_IMETHODIMP
2668 Connection::RemoveProgressHandler(mozIStorageProgressHandler** _oldHandler) {
2669 if (!connectionReady()) {
2670 return NS_ERROR_NOT_INITIALIZED;
2672 nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2673 if (NS_FAILED(rv)) {
2674 return rv;
2677 // Return previous one
2678 SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2679 NS_IF_ADDREF(*_oldHandler = mProgressHandler);
2681 mProgressHandler = nullptr;
2682 ::sqlite3_progress_handler(mDBConn, 0, nullptr, nullptr);
2684 return NS_OK;
2687 NS_IMETHODIMP
2688 Connection::SetGrowthIncrement(int32_t aChunkSize,
2689 const nsACString& aDatabaseName) {
2690 if (!connectionReady()) {
2691 return NS_ERROR_NOT_INITIALIZED;
2693 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2694 if (NS_FAILED(rv)) {
2695 return rv;
2698 // Bug 597215: Disk space is extremely limited on Android
2699 // so don't preallocate space. This is also not effective
2700 // on log structured file systems used by Android devices
2701 #if !defined(ANDROID) && !defined(MOZ_PLATFORM_MAEMO)
2702 // Don't preallocate if less than 500MiB is available.
2703 int64_t bytesAvailable;
2704 rv = mDatabaseFile->GetDiskSpaceAvailable(&bytesAvailable);
2705 NS_ENSURE_SUCCESS(rv, rv);
2706 if (bytesAvailable < MIN_AVAILABLE_BYTES_PER_CHUNKED_GROWTH) {
2707 return NS_ERROR_FILE_TOO_BIG;
2710 int srv = ::sqlite3_file_control(
2711 mDBConn,
2712 aDatabaseName.Length() ? nsPromiseFlatCString(aDatabaseName).get()
2713 : nullptr,
2714 SQLITE_FCNTL_CHUNK_SIZE, &aChunkSize);
2715 if (srv == SQLITE_OK) {
2716 mGrowthChunkSize = aChunkSize;
2718 #endif
2719 return NS_OK;
2722 int32_t Connection::RemovablePagesInFreeList(const nsACString& aSchemaName) {
2723 int32_t freeListPagesCount = 0;
2724 if (!isConnectionReadyOnThisThread()) {
2725 MOZ_ASSERT(false, "Database connection is not ready");
2726 return freeListPagesCount;
2729 nsAutoCString query(MOZ_STORAGE_UNIQUIFY_QUERY_STR "PRAGMA ");
2730 query.Append(aSchemaName);
2731 query.AppendLiteral(".freelist_count");
2732 nsCOMPtr<mozIStorageStatement> stmt;
2733 DebugOnly<nsresult> rv = CreateStatement(query, getter_AddRefs(stmt));
2734 MOZ_ASSERT(NS_SUCCEEDED(rv));
2735 bool hasResult = false;
2736 if (stmt && NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)) && hasResult) {
2737 freeListPagesCount = stmt->AsInt32(0);
2740 // If there's no chunk size set, any page is good to be removed.
2741 if (mGrowthChunkSize == 0 || freeListPagesCount == 0) {
2742 return freeListPagesCount;
2744 int32_t pageSize;
2746 nsAutoCString query(MOZ_STORAGE_UNIQUIFY_QUERY_STR "PRAGMA ");
2747 query.Append(aSchemaName);
2748 query.AppendLiteral(".page_size");
2749 nsCOMPtr<mozIStorageStatement> stmt;
2750 DebugOnly<nsresult> rv = CreateStatement(query, getter_AddRefs(stmt));
2751 MOZ_ASSERT(NS_SUCCEEDED(rv));
2752 bool hasResult = false;
2753 if (stmt && NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)) && hasResult) {
2754 pageSize = stmt->AsInt32(0);
2755 } else {
2756 MOZ_ASSERT(false, "Couldn't get page_size");
2757 return 0;
2760 return std::max(0, freeListPagesCount - (mGrowthChunkSize / pageSize));
2763 NS_IMETHODIMP
2764 Connection::LoadExtension(const nsACString& aExtensionName,
2765 mozIStorageCompletionCallback* aCallback) {
2766 AUTO_PROFILER_LABEL("Connection::LoadExtension", OTHER);
2768 // This is a static list of extensions we can load.
2769 // Please use lowercase ASCII names and keep this list alphabetically ordered.
2770 static constexpr nsLiteralCString sSupportedExtensions[] = {
2771 // clang-format off
2772 "fts5"_ns,
2773 // clang-format on
2775 if (std::find(std::begin(sSupportedExtensions),
2776 std::end(sSupportedExtensions),
2777 aExtensionName) == std::end(sSupportedExtensions)) {
2778 return NS_ERROR_INVALID_ARG;
2781 if (!connectionReady()) {
2782 return NS_ERROR_NOT_INITIALIZED;
2785 int srv = ::sqlite3_db_config(mDBConn, SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION,
2786 1, nullptr);
2787 if (srv != SQLITE_OK) {
2788 return NS_ERROR_UNEXPECTED;
2791 // Track the loaded extension for later connection cloning operations.
2793 MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
2794 if (!mLoadedExtensions.EnsureInserted(aExtensionName)) {
2795 // Already loaded, bail out but issue a warning.
2796 NS_WARNING(nsPrintfCString(
2797 "Tried to register '%s' SQLite extension multiple times!",
2798 PromiseFlatCString(aExtensionName).get())
2799 .get());
2800 return NS_OK;
2804 nsAutoCString entryPoint("sqlite3_");
2805 entryPoint.Append(aExtensionName);
2806 entryPoint.AppendLiteral("_init");
2808 RefPtr<Runnable> loadTask = NS_NewRunnableFunction(
2809 "mozStorageConnection::LoadExtension",
2810 [this, self = RefPtr(this), entryPoint,
2811 callback = RefPtr(aCallback)]() mutable {
2812 MOZ_ASSERT(
2813 !NS_IsMainThread() ||
2814 (operationSupported(Connection::SYNCHRONOUS) &&
2815 eventTargetOpenedOn == GetMainThreadSerialEventTarget()),
2816 "Should happen on main-thread only for synchronous connections "
2817 "opened on the main thread");
2818 #ifdef MOZ_FOLD_LIBS
2819 int srv = ::sqlite3_load_extension(mDBConn,
2820 MOZ_DLL_PREFIX "nss3" MOZ_DLL_SUFFIX,
2821 entryPoint.get(), nullptr);
2822 #else
2823 int srv = ::sqlite3_load_extension(
2824 mDBConn, MOZ_DLL_PREFIX "mozsqlite3" MOZ_DLL_SUFFIX,
2825 entryPoint.get(), nullptr);
2826 #endif
2827 if (!callback) {
2828 return;
2830 RefPtr<Runnable> callbackTask = NS_NewRunnableFunction(
2831 "mozStorageConnection::LoadExtension_callback",
2832 [callback = std::move(callback), srv]() {
2833 (void)callback->Complete(convertResultCode(srv), nullptr);
2835 if (IsOnCurrentSerialEventTarget(eventTargetOpenedOn)) {
2836 MOZ_ALWAYS_SUCCEEDS(callbackTask->Run());
2837 } else {
2838 // Redispatch the callback to the calling thread.
2839 MOZ_ALWAYS_SUCCEEDS(eventTargetOpenedOn->Dispatch(
2840 callbackTask.forget(), NS_DISPATCH_NORMAL));
2844 if (NS_IsMainThread() && !operationSupported(Connection::SYNCHRONOUS)) {
2845 // This is a main-thread call to an async-only connection, thus we should
2846 // load the library in the helper thread.
2847 nsIEventTarget* helperThread = getAsyncExecutionTarget();
2848 if (!helperThread) {
2849 return NS_ERROR_NOT_INITIALIZED;
2851 MOZ_ALWAYS_SUCCEEDS(
2852 helperThread->Dispatch(loadTask.forget(), NS_DISPATCH_NORMAL));
2853 } else {
2854 // In any other case we just load the extension on the current thread.
2855 MOZ_ALWAYS_SUCCEEDS(loadTask->Run());
2857 return NS_OK;
2860 NS_IMETHODIMP
2861 Connection::EnableModule(const nsACString& aModuleName) {
2862 if (!connectionReady()) {
2863 return NS_ERROR_NOT_INITIALIZED;
2865 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2866 if (NS_FAILED(rv)) {
2867 return rv;
2870 for (auto& gModule : gModules) {
2871 struct Module* m = &gModule;
2872 if (aModuleName.Equals(m->name)) {
2873 int srv = m->registerFunc(mDBConn, m->name);
2874 if (srv != SQLITE_OK) return convertResultCode(srv);
2876 return NS_OK;
2880 return NS_ERROR_FAILURE;
2883 NS_IMETHODIMP
2884 Connection::GetQuotaObjects(QuotaObject** aDatabaseQuotaObject,
2885 QuotaObject** aJournalQuotaObject) {
2886 MOZ_ASSERT(aDatabaseQuotaObject);
2887 MOZ_ASSERT(aJournalQuotaObject);
2889 if (!connectionReady()) {
2890 return NS_ERROR_NOT_INITIALIZED;
2892 nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2893 if (NS_FAILED(rv)) {
2894 return rv;
2897 sqlite3_file* file;
2898 int srv = ::sqlite3_file_control(mDBConn, nullptr, SQLITE_FCNTL_FILE_POINTER,
2899 &file);
2900 if (srv != SQLITE_OK) {
2901 return convertResultCode(srv);
2904 sqlite3_vfs* vfs;
2905 srv =
2906 ::sqlite3_file_control(mDBConn, nullptr, SQLITE_FCNTL_VFS_POINTER, &vfs);
2907 if (srv != SQLITE_OK) {
2908 return convertResultCode(srv);
2911 bool obfusactingVFS = false;
2914 const nsDependentCString vfsName{vfs->zName};
2916 if (vfsName == obfsvfs::GetVFSName()) {
2917 obfusactingVFS = true;
2918 } else if (vfsName != quotavfs::GetVFSName()) {
2919 NS_WARNING("Got unexpected vfs");
2920 return NS_ERROR_FAILURE;
2924 RefPtr<QuotaObject> databaseQuotaObject =
2925 GetQuotaObject(file, obfusactingVFS);
2926 if (NS_WARN_IF(!databaseQuotaObject)) {
2927 return NS_ERROR_FAILURE;
2930 srv = ::sqlite3_file_control(mDBConn, nullptr, SQLITE_FCNTL_JOURNAL_POINTER,
2931 &file);
2932 if (srv != SQLITE_OK) {
2933 return convertResultCode(srv);
2936 RefPtr<QuotaObject> journalQuotaObject = GetQuotaObject(file, obfusactingVFS);
2937 if (NS_WARN_IF(!journalQuotaObject)) {
2938 return NS_ERROR_FAILURE;
2941 databaseQuotaObject.forget(aDatabaseQuotaObject);
2942 journalQuotaObject.forget(aJournalQuotaObject);
2943 return NS_OK;
2946 SQLiteMutex& Connection::GetSharedDBMutex() { return sharedDBMutex; }
2948 uint32_t Connection::GetTransactionNestingLevel(
2949 const mozilla::storage::SQLiteMutexAutoLock& aProofOfLock) {
2950 return mTransactionNestingLevel;
2953 uint32_t Connection::IncreaseTransactionNestingLevel(
2954 const mozilla::storage::SQLiteMutexAutoLock& aProofOfLock) {
2955 return ++mTransactionNestingLevel;
2958 uint32_t Connection::DecreaseTransactionNestingLevel(
2959 const mozilla::storage::SQLiteMutexAutoLock& aProofOfLock) {
2960 return --mTransactionNestingLevel;
2963 NS_IMETHODIMP
2964 Connection::BackupToFileAsync(nsIFile* aDestinationFile,
2965 mozIStorageCompletionCallback* aCallback) {
2966 NS_ENSURE_ARG(aDestinationFile);
2967 NS_ENSURE_ARG(aCallback);
2968 NS_ENSURE_TRUE(NS_IsMainThread(), NS_ERROR_NOT_SAME_THREAD);
2970 // Abort if we're shutting down.
2971 if (AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownConfirmed)) {
2972 return NS_ERROR_ABORT;
2974 // Check if AsyncClose or Close were already invoked.
2975 if (!connectionReady()) {
2976 return NS_ERROR_NOT_INITIALIZED;
2978 nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2979 if (NS_FAILED(rv)) {
2980 return rv;
2982 nsIEventTarget* asyncThread = getAsyncExecutionTarget();
2983 if (!asyncThread) {
2984 return NS_ERROR_NOT_INITIALIZED;
2987 // Create and dispatch our backup event to the execution thread.
2988 nsCOMPtr<nsIRunnable> backupEvent =
2989 new AsyncBackupDatabaseFile(this, mDBConn, aDestinationFile, aCallback);
2990 rv = asyncThread->Dispatch(backupEvent, NS_DISPATCH_NORMAL);
2991 return rv;
2994 } // namespace mozilla::storage