dom/filehandle/FileService.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=2 et sw=2 tw=80: */
   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 file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "FileService.h"
   8
   9 #include "FileHandle.h"
  10 #include "MainThreadUtils.h"
  11 #include "mozilla/Assertions.h"
  12 #include "MutableFile.h"
  13 #include "nsError.h"
  14 #include "nsIEventTarget.h"
  15 #include "nsIObserverService.h"
  16 #include "nsIOfflineStorage.h"
  17 #include "nsNetCID.h"
  18 #include "nsServiceManagerUtils.h"
  19 #include "nsThreadUtils.h"
  20
  21 namespace mozilla {
  22 namespace dom {
  23
  24 namespace {
  25
  26 FileService* gInstance = nullptr;
  27 bool gShutdown = false;
  28
  29 } // anonymous namespace
  30
  31 FileService::FileService()
  32 {
  33   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
  34   NS_ASSERTION(!gInstance, "More than one instance!");
  35 }
  36
  37 FileService::~FileService()
  38 {
  39   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
  40   NS_ASSERTION(!gInstance, "More than one instance!");
  41 }
  42
  43 nsresult
  44 FileService::Init()
  45 {
  46   nsresult rv;
  47   mStreamTransportTarget =
  48     do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID, &rv);
  49
  50   return rv;
  51 }
  52
  53 nsresult
  54 FileService::Cleanup()
  55 {
  56   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
  57
  58   nsIThread* thread = NS_GetCurrentThread();
  59   while (mStorageInfos.Count()) {
  60     if (!NS_ProcessNextEvent(thread)) {
  61       NS_ERROR("Failed to process next event!");
  62       break;
  63     }
  64   }
  65
  66   // Make sure the service is still accessible while any generated callbacks
  67   // are processed.
  68   nsresult rv = NS_ProcessPendingEvents(thread);
  69   NS_ENSURE_SUCCESS(rv, rv);
  70
  71   if (!mCompleteCallbacks.IsEmpty()) {
  72     // Run all callbacks manually now.
  73     for (uint32_t index = 0; index < mCompleteCallbacks.Length(); index++) {
  74       mCompleteCallbacks[index].mCallback->Run();
  75     }
  76     mCompleteCallbacks.Clear();
  77
  78     // And make sure they get processed.
  79     rv = NS_ProcessPendingEvents(thread);
  80     NS_ENSURE_SUCCESS(rv, rv);
  81   }
  82
  83   return NS_OK;
  84 }
  85
  86 // static
  87 FileService*
  88 FileService::GetOrCreate()
  89 {
  90   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
  91
  92   if (gShutdown) {
  93     NS_WARNING("Calling GetOrCreate() after shutdown!");
  94     return nullptr;
  95   }
  96
  97   if (!gInstance) {
  98     nsRefPtr<FileService> service(new FileService);
  99
 100     nsresult rv = service->Init();
 101     NS_ENSURE_SUCCESS(rv, nullptr);
 102
 103     nsCOMPtr<nsIObserverService> obs =
 104       do_GetService(NS_OBSERVERSERVICE_CONTRACTID, &rv);
 105     NS_ENSURE_SUCCESS(rv, nullptr);
 106
 107     rv = obs->AddObserver(service, "profile-before-change", false);
 108     NS_ENSURE_SUCCESS(rv, nullptr);
 109
 110     // The observer service now owns us.
 111     gInstance = service;
 112   }
 113
 114   return gInstance;
 115 }
 116
 117 // static
 118 FileService*
 119 FileService::Get()
 120 {
 121   // Does not return an owning reference.
 122   return gInstance;
 123 }
 124
 125 // static
 126 void
 127 FileService::Shutdown()
 128 {
 129   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 130
 131   gShutdown = true;
 132
 133   if (gInstance) {
 134     if (NS_FAILED(gInstance->Cleanup())) {
 135       NS_WARNING("Failed to shutdown file service!");
 136     }
 137     gInstance = nullptr;
 138   }
 139 }
 140
 141 // static
 142 bool
 143 FileService::IsShuttingDown()
 144 {
 145   return gShutdown;
 146 }
 147
 148 nsresult
 149 FileService::Enqueue(FileHandleBase* aFileHandle, FileHelper* aFileHelper)
 150 {
 151   MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
 152   MOZ_ASSERT(aFileHandle, "Null pointer!");
 153
 154   MutableFileBase* mutableFile = aFileHandle->MutableFile();
 155
 156   if (mutableFile->IsInvalid()) {
 157     return NS_ERROR_NOT_AVAILABLE;
 158   }
 159
 160   const nsACString& storageId = mutableFile->mStorageId;
 161   const nsAString& fileName = mutableFile->mFileName;
 162   bool modeIsWrite = aFileHandle->mMode == FileMode::Readwrite;
 163
 164   StorageInfo* storageInfo;
 165   if (!mStorageInfos.Get(storageId, &storageInfo)) {
 166     nsAutoPtr<StorageInfo> newStorageInfo(new StorageInfo());
 167
 168     mStorageInfos.Put(storageId, newStorageInfo);
 169
 170     storageInfo = newStorageInfo.forget();
 171   }
 172
 173   FileHandleQueue* existingFileHandleQueue =
 174     storageInfo->GetFileHandleQueue(aFileHandle);
 175
 176   if (existingFileHandleQueue) {
 177     existingFileHandleQueue->Enqueue(aFileHelper);
 178     return NS_OK;
 179   }
 180
 181   bool lockedForReading = storageInfo->IsFileLockedForReading(fileName);
 182   bool lockedForWriting = storageInfo->IsFileLockedForWriting(fileName);
 183
 184   if (modeIsWrite) {
 185     if (!lockedForWriting) {
 186       storageInfo->LockFileForWriting(fileName);
 187     }
 188   }
 189   else {
 190     if (!lockedForReading) {
 191       storageInfo->LockFileForReading(fileName);
 192     }
 193   }
 194
 195   if (lockedForWriting || (lockedForReading && modeIsWrite)) {
 196     storageInfo->CreateDelayedEnqueueInfo(aFileHandle, aFileHelper);
 197   }
 198   else {
 199     FileHandleQueue* fileHandleQueue =
 200       storageInfo->CreateFileHandleQueue(aFileHandle);
 201
 202     if (aFileHelper) {
 203       // Enqueue() will queue the file helper if there's already something
 204       // running. That can't fail, so no need to eventually remove
 205       // storageInfo from the hash table.
 206       //
 207       // If the file helper is free to run then AsyncRun() is called on the
 208       // file helper. AsyncRun() is responsible for calling all necessary
 209       // callbacks when something fails. We're propagating the error here,
 210       // however there's no need to eventually remove storageInfo from
 211       // the hash table. Code behind AsyncRun() will take care of it. The last
 212       // item in the code path is NotifyFileHandleCompleted() which removes
 213       // storageInfo from the hash table if there are no file handles for
 214       // the file storage.
 215       nsresult rv = fileHandleQueue->Enqueue(aFileHelper);
 216       NS_ENSURE_SUCCESS(rv, rv);
 217     }
 218   }
 219
 220   return NS_OK;
 221 }
 222
 223 void
 224 FileService::NotifyFileHandleCompleted(FileHandleBase* aFileHandle)
 225 {
 226   MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
 227   MOZ_ASSERT(aFileHandle, "Null pointer!");
 228
 229   MutableFileBase* mutableFile = aFileHandle->MutableFile();
 230   const nsACString& storageId = mutableFile->mStorageId;
 231
 232   StorageInfo* storageInfo;
 233   if (!mStorageInfos.Get(storageId, &storageInfo)) {
 234     NS_ERROR("We don't know anyting about this file handle?!");
 235     return;
 236   }
 237
 238   storageInfo->RemoveFileHandleQueue(aFileHandle);
 239
 240   if (!storageInfo->HasRunningFileHandles()) {
 241     mStorageInfos.Remove(storageId);
 242
 243     // See if we need to fire any complete callbacks.
 244     uint32_t index = 0;
 245     while (index < mCompleteCallbacks.Length()) {
 246       if (MaybeFireCallback(mCompleteCallbacks[index])) {
 247         mCompleteCallbacks.RemoveElementAt(index);
 248       }
 249       else {
 250         index++;
 251       }
 252     }
 253   }
 254 }
 255
 256 void
 257 FileService::WaitForStoragesToComplete(
 258                                  nsTArray<nsCOMPtr<nsIOfflineStorage> >& aStorages,
 259                                  nsIRunnable* aCallback)
 260 {
 261   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 262   NS_ASSERTION(!aStorages.IsEmpty(), "No databases to wait on!");
 263   NS_ASSERTION(aCallback, "Null pointer!");
 264
 265   StoragesCompleteCallback* callback = mCompleteCallbacks.AppendElement();
 266   callback->mCallback = aCallback;
 267   callback->mStorages.SwapElements(aStorages);
 268
 269   if (MaybeFireCallback(*callback)) {
 270     mCompleteCallbacks.RemoveElementAt(mCompleteCallbacks.Length() - 1);
 271   }
 272 }
 273
 274 void
 275 FileService::AbortFileHandlesForStorage(nsIOfflineStorage* aStorage)
 276 {
 277   MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
 278   MOZ_ASSERT(aStorage, "Null pointer!");
 279
 280   StorageInfo* storageInfo;
 281   if (!mStorageInfos.Get(aStorage->Id(), &storageInfo)) {
 282     return;
 283   }
 284
 285   nsAutoTArray<nsRefPtr<FileHandleBase>, 10> fileHandles;
 286   storageInfo->CollectRunningAndDelayedFileHandles(aStorage, fileHandles);
 287
 288   for (uint32_t index = 0; index < fileHandles.Length(); index++) {
 289     ErrorResult ignored;
 290     fileHandles[index]->Abort(ignored);
 291   }
 292 }
 293
 294 bool
 295 FileService::HasFileHandlesForStorage(nsIOfflineStorage* aStorage)
 296 {
 297   MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
 298   MOZ_ASSERT(aStorage, "Null pointer!");
 299
 300   StorageInfo* storageInfo;
 301   if (!mStorageInfos.Get(aStorage->Id(), &storageInfo)) {
 302     return false;
 303   }
 304
 305   return storageInfo->HasRunningFileHandles(aStorage);
 306 }
 307
 308 NS_IMPL_ISUPPORTS(FileService, nsIObserver)
 309
 310 NS_IMETHODIMP
 311 FileService::Observe(nsISupports* aSubject, const char*  aTopic,
 312                      const char16_t* aData)
 313 {
 314   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 315   NS_ASSERTION(!strcmp(aTopic, "profile-before-change"), "Wrong topic!");
 316
 317   Shutdown();
 318
 319   return NS_OK;
 320 }
 321
 322 bool
 323 FileService::MaybeFireCallback(StoragesCompleteCallback& aCallback)
 324 {
 325   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 326
 327   for (uint32_t index = 0; index < aCallback.mStorages.Length(); index++) {
 328     if (mStorageInfos.Get(aCallback.mStorages[index]->Id(), nullptr)) {
 329       return false;
 330     }
 331   }
 332
 333   aCallback.mCallback->Run();
 334   return true;
 335 }
 336
 337 FileService::FileHandleQueue::FileHandleQueue(FileHandleBase* aFileHandle)
 338 : mFileHandle(aFileHandle)
 339 {
 340   MOZ_ASSERT(aFileHandle, "Null pointer!");
 341 }
 342
 343 FileService::FileHandleQueue::~FileHandleQueue()
 344 {
 345 }
 346
 347 NS_IMPL_ADDREF(FileService::FileHandleQueue)
 348 NS_IMPL_RELEASE(FileService::FileHandleQueue)
 349
 350 nsresult
 351 FileService::FileHandleQueue::Enqueue(FileHelper* aFileHelper)
 352 {
 353   mQueue.AppendElement(aFileHelper);
 354
 355   nsresult rv;
 356   if (mFileHandle->mRequestMode == FileHandleBase::PARALLEL) {
 357     rv = aFileHelper->AsyncRun(this);
 358   }
 359   else {
 360     rv = ProcessQueue();
 361   }
 362   NS_ENSURE_SUCCESS(rv, rv);
 363
 364   return NS_OK;
 365 }
 366
 367 void
 368 FileService::
 369 FileHandleQueue::OnFileHelperComplete(FileHelper* aFileHelper)
 370 {
 371   if (mFileHandle->mRequestMode == FileHandleBase::PARALLEL) {
 372     int32_t index = mQueue.IndexOf(aFileHelper);
 373     NS_ASSERTION(index != -1, "We don't know anything about this helper!");
 374
 375     mQueue.RemoveElementAt(index);
 376   }
 377   else {
 378     NS_ASSERTION(mCurrentHelper == aFileHelper, "How can this happen?!");
 379
 380     mCurrentHelper = nullptr;
 381
 382     nsresult rv = ProcessQueue();
 383     if (NS_FAILED(rv)) {
 384       return;
 385     }
 386   }
 387 }
 388
 389 nsresult
 390 FileService::FileHandleQueue::ProcessQueue()
 391 {
 392   if (mQueue.IsEmpty() || mCurrentHelper) {
 393     return NS_OK;
 394   }
 395
 396   mCurrentHelper = mQueue[0];
 397   mQueue.RemoveElementAt(0);
 398
 399   nsresult rv = mCurrentHelper->AsyncRun(this);
 400   NS_ENSURE_SUCCESS(rv, rv);
 401
 402   return NS_OK;
 403 }
 404
 405 FileService::DelayedEnqueueInfo::DelayedEnqueueInfo()
 406 {
 407 }
 408
 409 FileService::DelayedEnqueueInfo::~DelayedEnqueueInfo()
 410 {
 411 }
 412
 413 FileService::FileHandleQueue*
 414 FileService::StorageInfo::CreateFileHandleQueue(FileHandleBase* aFileHandle)
 415 {
 416   nsRefPtr<FileHandleQueue>* fileHandleQueue =
 417     mFileHandleQueues.AppendElement();
 418   *fileHandleQueue = new FileHandleQueue(aFileHandle);
 419   return fileHandleQueue->get();
 420 }
 421
 422 FileService::FileHandleQueue*
 423 FileService::StorageInfo::GetFileHandleQueue(FileHandleBase* aFileHandle)
 424 {
 425   uint32_t count = mFileHandleQueues.Length();
 426   for (uint32_t index = 0; index < count; index++) {
 427     nsRefPtr<FileHandleQueue>& fileHandleQueue = mFileHandleQueues[index];
 428     if (fileHandleQueue->mFileHandle == aFileHandle) {
 429       return fileHandleQueue;
 430     }
 431   }
 432   return nullptr;
 433 }
 434
 435 void
 436 FileService::StorageInfo::RemoveFileHandleQueue(FileHandleBase* aFileHandle)
 437 {
 438   for (uint32_t index = 0; index < mDelayedEnqueueInfos.Length(); index++) {
 439     if (mDelayedEnqueueInfos[index].mFileHandle == aFileHandle) {
 440       MOZ_ASSERT(!mDelayedEnqueueInfos[index].mFileHelper, "Should be null!");
 441       mDelayedEnqueueInfos.RemoveElementAt(index);
 442       return;
 443     }
 444   }
 445
 446   uint32_t fileHandleCount = mFileHandleQueues.Length();
 447
 448   // We can't just remove entries from lock hash tables, we have to rebuild
 449   // them instead. Multiple FileHandle objects may lock the same file
 450   // (one entry can represent multiple locks).
 451
 452   mFilesReading.Clear();
 453   mFilesWriting.Clear();
 454
 455   for (uint32_t index = 0, count = fileHandleCount; index < count; index++) {
 456     FileHandleBase* fileHandle = mFileHandleQueues[index]->mFileHandle;
 457     if (fileHandle == aFileHandle) {
 458       MOZ_ASSERT(count == fileHandleCount, "More than one match?!");
 459
 460       mFileHandleQueues.RemoveElementAt(index);
 461       index--;
 462       count--;
 463
 464       continue;
 465     }
 466
 467     const nsAString& fileName = fileHandle->MutableFile()->mFileName;
 468
 469     if (fileHandle->mMode == FileMode::Readwrite) {
 470       if (!IsFileLockedForWriting(fileName)) {
 471         LockFileForWriting(fileName);
 472       }
 473     }
 474     else {
 475       if (!IsFileLockedForReading(fileName)) {
 476         LockFileForReading(fileName);
 477       }
 478     }
 479   }
 480
 481   MOZ_ASSERT(mFileHandleQueues.Length() == fileHandleCount - 1,
 482              "Didn't find the file handle we were looking for!");
 483
 484   nsTArray<DelayedEnqueueInfo> delayedEnqueueInfos;
 485   delayedEnqueueInfos.SwapElements(mDelayedEnqueueInfos);
 486
 487   for (uint32_t index = 0; index < delayedEnqueueInfos.Length(); index++) {
 488     DelayedEnqueueInfo& delayedEnqueueInfo = delayedEnqueueInfos[index];
 489     if (NS_FAILED(gInstance->Enqueue(delayedEnqueueInfo.mFileHandle,
 490                                      delayedEnqueueInfo.mFileHelper))) {
 491       NS_WARNING("Enqueue failed!");
 492     }
 493   }
 494 }
 495
 496 bool
 497 FileService::StorageInfo::HasRunningFileHandles(nsIOfflineStorage* aStorage)
 498 {
 499   for (uint32_t index = 0; index < mFileHandleQueues.Length(); index++) {
 500     FileHandleBase* fileHandle = mFileHandleQueues[index]->mFileHandle;
 501     if (fileHandle->MutableFile()->Storage() == aStorage) {
 502       return true;
 503     }
 504   }
 505   return false;
 506 }
 507
 508 FileService::DelayedEnqueueInfo*
 509 FileService::StorageInfo::CreateDelayedEnqueueInfo(FileHandleBase* aFileHandle,
 510                                                    FileHelper* aFileHelper)
 511 {
 512   DelayedEnqueueInfo* info = mDelayedEnqueueInfos.AppendElement();
 513   info->mFileHandle = aFileHandle;
 514   info->mFileHelper = aFileHelper;
 515   return info;
 516 }
 517
 518 void
 519 FileService::StorageInfo::CollectRunningAndDelayedFileHandles(
 520                                nsIOfflineStorage* aStorage,
 521                                nsTArray<nsRefPtr<FileHandleBase>>& aFileHandles)
 522 {
 523   for (uint32_t index = 0; index < mFileHandleQueues.Length(); index++) {
 524     FileHandleBase* fileHandle = mFileHandleQueues[index]->mFileHandle;
 525     if (fileHandle->MutableFile()->Storage() == aStorage) {
 526       aFileHandles.AppendElement(fileHandle);
 527     }
 528   }
 529
 530   for (uint32_t index = 0; index < mDelayedEnqueueInfos.Length(); index++) {
 531     FileHandleBase* fileHandle = mDelayedEnqueueInfos[index].mFileHandle;
 532     if (fileHandle->MutableFile()->Storage() == aStorage) {
 533       aFileHandles.AppendElement(fileHandle);
 534     }
 535   }
 536 }
 537
 538 } // namespace dom
 539 } // namespace mozilla