-----BEGIN CERTIFICATE-----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-----END CERTIFICATE-----

/*
 Derived from source code of TrueCrypt 7.1a, which is
 Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed
 by the TrueCrypt License 3.0.

 Modifications and additions to the original source code (contained in this file)
 and all other portions of this file are Copyright (c) 2013-2017 IDRIX
 and are governed by the Apache License 2.0 the full text of which is
 contained in the file License.txt included in VeraCrypt binary and source
 code distribution packages.
*/

#ifdef TC_UNIX
#	include <unistd.h>
#endif

#ifdef TC_MACOSX
#	include <sys/types.h>
#	include <sys/sysctl.h>
#endif

#include "Platform/SyncEvent.h"
#include "Platform/SystemLog.h"
#include "Common/Crypto.h"
#include "EncryptionThreadPool.h"

namespace VeraCrypt
{
	void EncryptionThreadPool::DoWork (WorkType::Enum type, const EncryptionMode *encryptionMode, byte *data, uint64 startUnitNo, uint64 unitCount, size_t sectorSize)
	{
		size_t fragmentCount;
		size_t unitsPerFragment;
		size_t remainder;

		byte *fragmentData;
		uint64 fragmentStartUnitNo;

		WorkItem *workItem;
		WorkItem *firstFragmentWorkItem;

		if (unitCount == 0)
			return;

		if (!ThreadPoolRunning || unitCount == 1)
		{
			switch (type)
			{
			case WorkType::DecryptDataUnits:
				encryptionMode->DecryptSectorsCurrentThread (data, startUnitNo, unitCount, sectorSize);
				break;

			case WorkType::EncryptDataUnits:
				encryptionMode->EncryptSectorsCurrentThread (data, startUnitNo, unitCount, sectorSize);
				break;

			default:
				throw ParameterIncorrect (SRC_POS);
			}

			return;
		}

		if (unitCount <= ThreadCount)
		{
			fragmentCount = (size_t) unitCount;
			unitsPerFragment = 1;
			remainder = 0;
		}
		else
		{
			fragmentCount = ThreadCount;
			unitsPerFragment = (size_t) unitCount / ThreadCount;
			remainder = (size_t) unitCount % ThreadCount;

			if (remainder > 0)
				++unitsPerFragment;
		}

		fragmentData = data;
		fragmentStartUnitNo = startUnitNo;

		{
			ScopeLock lock (EnqueueMutex);
			firstFragmentWorkItem = &WorkItemQueue[EnqueuePosition];

			while (firstFragmentWorkItem->State != WorkItem::State::Free)
			{
				WorkItemCompletedEvent.Wait();
			}

			firstFragmentWorkItem->OutstandingFragmentCount.Set (fragmentCount);
			firstFragmentWorkItem->ItemException.reset();

			while (fragmentCount-- > 0)
			{
				workItem = &WorkItemQueue[EnqueuePosition++];

				if (EnqueuePosition >= QueueSize)
					EnqueuePosition = 0;

				while (workItem->State != WorkItem::State::Free)
				{
					WorkItemCompletedEvent.Wait();
				}

				workItem->Type = type;
				workItem->FirstFragment = firstFragmentWorkItem;

				workItem->Encryption.Mode = encryptionMode;
				workItem->Encryption.Data = fragmentData;
				workItem->Encryption.UnitCount = unitsPerFragment;
				workItem->Encryption.StartUnitNo = fragmentStartUnitNo;
				workItem->Encryption.SectorSize = sectorSize;

				fragmentData += unitsPerFragment * sectorSize;
				fragmentStartUnitNo += unitsPerFragment;

				if (remainder > 0 && --remainder == 0)
					--unitsPerFragment;

				workItem->State.Set (WorkItem::State::Ready);
				WorkItemReadyEvent.Signal();
			}
		}

		firstFragmentWorkItem->ItemCompletedEvent.Wait();

		auto_ptr <Exception> itemException;
		if (firstFragmentWorkItem->ItemException.get())
			itemException = firstFragmentWorkItem->ItemException;

		firstFragmentWorkItem->State.Set (WorkItem::State::Free);
		WorkItemCompletedEvent.Signal();

		if (itemException.get())
			itemException->Throw();
	}

	void EncryptionThreadPool::Start ()
	{
		if (ThreadPoolRunning)
			return;

		size_t cpuCount;

#ifdef TC_WINDOWS

		SYSTEM_INFO sysInfo;
		GetSystemInfo (&sysInfo);
		cpuCount = sysInfo.dwNumberOfProcessors;

#elif defined (_SC_NPROCESSORS_ONLN)

		cpuCount = (size_t) sysconf (_SC_NPROCESSORS_ONLN);
		if (cpuCount == (size_t) -1)
			cpuCount = 1;

#elif defined (TC_MACOSX)

		int cpuCountSys;
		int mib[2] = { CTL_HW, HW_NCPU };

		size_t len = sizeof (cpuCountSys);
		if (sysctl (mib, 2, &cpuCountSys, &len, nullptr, 0) == -1)
			cpuCountSys = 1;

		cpuCount = (size_t) cpuCountSys;

#else
#	error Cannot determine CPU count
#endif

		if (cpuCount < 2)
			return;

		if (cpuCount > MaxThreadCount)
			cpuCount = MaxThreadCount;

		StopPending = false;
		DequeuePosition = 0;
		EnqueuePosition = 0;

		for (size_t i = 0; i < sizeof (WorkItemQueue) / sizeof (WorkItemQueue[0]); ++i)
		{
			WorkItemQueue[i].State.Set (WorkItem::State::Free);
		}

		try
		{
			for (ThreadCount = 0; ThreadCount < cpuCount; ++ThreadCount)
			{
				struct ThreadFunctor : public Functor
				{
					virtual void operator() ()
					{
						WorkThreadProc();
					}
				};

				make_shared_auto (Thread, thread);
				thread->Start (new ThreadFunctor ());
				RunningThreads.push_back (thread);
			}
		}
		catch (...)
		{
			try
			{
				ThreadPoolRunning = true;
				Stop();
			} catch (...) { }

			throw;
		}

		ThreadPoolRunning = true;
	}

	void EncryptionThreadPool::Stop ()
	{
		if (!ThreadPoolRunning)
			return;

		StopPending = true;
		WorkItemReadyEvent.Signal();

		foreach_ref (const Thread &thread, RunningThreads)
		{
			thread.Join();
		}

		ThreadCount = 0;
		ThreadPoolRunning = false;
	}

	void EncryptionThreadPool::WorkThreadProc ()
	{
		try
		{
			WorkItem *workItem;

			while (!StopPending)
			{
				{
					ScopeLock lock (DequeueMutex);

					workItem = &WorkItemQueue[DequeuePosition++];

					if (DequeuePosition >= QueueSize)
						DequeuePosition = 0;

					while (!StopPending && workItem->State != WorkItem::State::Ready)
					{
						WorkItemReadyEvent.Wait();
					}

					workItem->State.Set (WorkItem::State::Busy);
				}

				if (StopPending)
					break;

				try
				{
					switch (workItem->Type)
					{
					case WorkType::DecryptDataUnits:
						workItem->Encryption.Mode->DecryptSectorsCurrentThread (workItem->Encryption.Data, workItem->Encryption.StartUnitNo, workItem->Encryption.UnitCount, workItem->Encryption.SectorSize);
						break;

					case WorkType::EncryptDataUnits:
						workItem->Encryption.Mode->EncryptSectorsCurrentThread (workItem->Encryption.Data, workItem->Encryption.StartUnitNo, workItem->Encryption.UnitCount, workItem->Encryption.SectorSize);
						break;

					default:
						throw ParameterIncorrect (SRC_POS);
					}
				}
				catch (Exception &e)
				{
					workItem->FirstFragment->ItemException.reset (e.CloneNew());
				}
				catch (exception &e)
				{
					workItem->FirstFragment->ItemException.reset (new ExternalException (SRC_POS, StringConverter::ToExceptionString (e)));
				}
				catch (...)
				{
					workItem->FirstFragment->ItemException.reset (new UnknownException (SRC_POS));
				}

				if (workItem != workItem->FirstFragment)
				{
					workItem->State.Set (WorkItem::State::Free);
					WorkItemCompletedEvent.Signal();
				}

				if (workItem->FirstFragment->OutstandingFragmentCount.Decrement() == 0)
					workItem->FirstFragment->ItemCompletedEvent.Signal();
			}
		}
		catch (exception &e)
		{
			SystemLog::WriteException (e);
		}
		catch (...)
		{
			SystemLog::WriteException (UnknownException (SRC_POS));
		}
	}

	volatile bool EncryptionThreadPool::ThreadPoolRunning = false;
	volatile bool EncryptionThreadPool::StopPending = false;

	size_t EncryptionThreadPool::ThreadCount;

	EncryptionThreadPool::WorkItem EncryptionThreadPool::WorkItemQueue[QueueSize];

	volatile size_t EncryptionThreadPool::EnqueuePosition;
	volatile size_t EncryptionThreadPool::DequeuePosition;

	Mutex EncryptionThreadPool::EnqueueMutex;
	Mutex EncryptionThreadPool::DequeueMutex;

	SyncEvent EncryptionThreadPool::WorkItemReadyEvent;
	SyncEvent EncryptionThreadPool::WorkItemCompletedEvent;

	list < shared_ptr <Thread> > EncryptionThreadPool::RunningThreads;
}