mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-08 10:44:56 +00:00
256c124f94
This was done by: This was done by applying: ``` diff --git a/python/mozbuild/mozbuild/code-analysis/mach_commands.py b/python/mozbuild/mozbuild/code-analysis/mach_commands.py index 789affde7bbf..fe33c4c7d4d1 100644 --- a/python/mozbuild/mozbuild/code-analysis/mach_commands.py +++ b/python/mozbuild/mozbuild/code-analysis/mach_commands.py @@ -2007,7 +2007,7 @@ class StaticAnalysis(MachCommandBase): from subprocess import Popen, PIPE, check_output, CalledProcessError diff_process = Popen(self._get_clang_format_diff_command(commit), stdout=PIPE) - args = [sys.executable, clang_format_diff, "-p1", "-binary=%s" % clang_format] + args = [sys.executable, clang_format_diff, "-p1", "-binary=%s" % clang_format, '-sort-includes'] if not output_file: args.append("-i") ``` Then running `./mach clang-format -c <commit-hash>` Then undoing that patch. Then running check_spidermonkey_style.py --fixup Then running `./mach clang-format` I had to fix four things: * I needed to move <utility> back down in GuardObjects.h because I was hitting obscure problems with our system include wrappers like this: 0:03.94 /usr/include/stdlib.h:550:14: error: exception specification in declaration does not match previous declaration 0:03.94 extern void *realloc (void *__ptr, size_t __size) 0:03.94 ^ 0:03.94 /home/emilio/src/moz/gecko-2/obj-debug/dist/include/malloc_decls.h:53:1: note: previous declaration is here 0:03.94 MALLOC_DECL(realloc, void*, void*, size_t) 0:03.94 ^ 0:03.94 /home/emilio/src/moz/gecko-2/obj-debug/dist/include/mozilla/mozalloc.h:22:32: note: expanded from macro 'MALLOC_DECL' 0:03.94 MOZ_MEMORY_API return_type name##_impl(__VA_ARGS__); 0:03.94 ^ 0:03.94 <scratch space>:178:1: note: expanded from here 0:03.94 realloc_impl 0:03.94 ^ 0:03.94 /home/emilio/src/moz/gecko-2/obj-debug/dist/include/mozmemory_wrap.h:142:41: note: expanded from macro 'realloc_impl' 0:03.94 #define realloc_impl mozmem_malloc_impl(realloc) Which I really didn't feel like digging into. * I had to restore the order of TrustOverrideUtils.h and related files in nss because the .inc files depend on TrustOverrideUtils.h being included earlier. * I had to add a missing include to RollingNumber.h * Also had to partially restore include order in JsepSessionImpl.cpp to avoid some -WError issues due to some static inline functions being defined in a header but not used in the rest of the compilation unit. Differential Revision: https://phabricator.services.mozilla.com/D60327 --HG-- extra : moz-landing-system : lando
160 lines
4.8 KiB
C++
160 lines
4.8 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
|
|
|
|
#ifndef mozilla_ProcThreadAttributes_h
|
|
#define mozilla_ProcThreadAttributes_h
|
|
|
|
#include <windows.h>
|
|
|
|
#include <utility>
|
|
|
|
#include "mozilla/Attributes.h"
|
|
#include "mozilla/Maybe.h"
|
|
#include "mozilla/UniquePtr.h"
|
|
#include "mozilla/Vector.h"
|
|
|
|
namespace mozilla {
|
|
|
|
class MOZ_RAII ProcThreadAttributes final {
|
|
struct ProcThreadAttributeListDeleter {
|
|
void operator()(LPPROC_THREAD_ATTRIBUTE_LIST aList) {
|
|
::DeleteProcThreadAttributeList(aList);
|
|
delete[] reinterpret_cast<char*>(aList);
|
|
}
|
|
};
|
|
|
|
using ProcThreadAttributeListPtr =
|
|
UniquePtr<_PROC_THREAD_ATTRIBUTE_LIST, ProcThreadAttributeListDeleter>;
|
|
|
|
public:
|
|
ProcThreadAttributes() : mMitigationPolicies(0) {}
|
|
|
|
~ProcThreadAttributes() = default;
|
|
|
|
ProcThreadAttributes(const ProcThreadAttributes&) = delete;
|
|
ProcThreadAttributes(ProcThreadAttributes&&) = delete;
|
|
ProcThreadAttributes& operator=(const ProcThreadAttributes&) = delete;
|
|
ProcThreadAttributes& operator=(ProcThreadAttributes&&) = delete;
|
|
|
|
void AddMitigationPolicy(DWORD64 aPolicy) { mMitigationPolicies |= aPolicy; }
|
|
|
|
bool AddInheritableHandle(HANDLE aHandle) {
|
|
DWORD type = ::GetFileType(aHandle);
|
|
if (type != FILE_TYPE_DISK && type != FILE_TYPE_PIPE) {
|
|
return false;
|
|
}
|
|
|
|
if (!::SetHandleInformation(aHandle, HANDLE_FLAG_INHERIT,
|
|
HANDLE_FLAG_INHERIT)) {
|
|
return false;
|
|
}
|
|
|
|
return mInheritableHandles.append(aHandle);
|
|
}
|
|
|
|
template <size_t N>
|
|
bool AddInheritableHandles(HANDLE (&aHandles)[N]) {
|
|
bool ok = true;
|
|
for (auto handle : aHandles) {
|
|
ok &= AddInheritableHandle(handle);
|
|
}
|
|
|
|
return ok;
|
|
}
|
|
|
|
bool HasMitigationPolicies() const { return !!mMitigationPolicies; }
|
|
|
|
bool HasInheritableHandles() const { return !mInheritableHandles.empty(); }
|
|
|
|
/**
|
|
* @return false if the STARTUPINFOEXW::lpAttributeList was set to null
|
|
* as expected based on the state of |this|;
|
|
* true if the STARTUPINFOEXW::lpAttributeList was set to
|
|
* non-null;
|
|
*/
|
|
LauncherResult<bool> AssignTo(STARTUPINFOEXW& aSiex) {
|
|
ZeroMemory(&aSiex, sizeof(STARTUPINFOEXW));
|
|
|
|
// We'll set the size to sizeof(STARTUPINFOW) until we determine whether the
|
|
// extended fields will be used.
|
|
aSiex.StartupInfo.cb = sizeof(STARTUPINFOW);
|
|
|
|
DWORD numAttributes = 0;
|
|
if (HasMitigationPolicies()) {
|
|
++numAttributes;
|
|
}
|
|
|
|
if (HasInheritableHandles()) {
|
|
++numAttributes;
|
|
}
|
|
|
|
if (!numAttributes) {
|
|
return false;
|
|
}
|
|
|
|
SIZE_T listSize = 0;
|
|
if (!::InitializeProcThreadAttributeList(nullptr, numAttributes, 0,
|
|
&listSize)) {
|
|
DWORD err = ::GetLastError();
|
|
if (err != ERROR_INSUFFICIENT_BUFFER) {
|
|
return LAUNCHER_ERROR_FROM_WIN32(err);
|
|
}
|
|
}
|
|
|
|
auto buf = MakeUnique<char[]>(listSize);
|
|
|
|
LPPROC_THREAD_ATTRIBUTE_LIST tmpList =
|
|
reinterpret_cast<LPPROC_THREAD_ATTRIBUTE_LIST>(buf.get());
|
|
|
|
if (!::InitializeProcThreadAttributeList(tmpList, numAttributes, 0,
|
|
&listSize)) {
|
|
return LAUNCHER_ERROR_FROM_LAST();
|
|
}
|
|
|
|
// Transfer buf to a ProcThreadAttributeListPtr - now that the list is
|
|
// initialized, we are no longer dealing with a plain old char array. We
|
|
// must now deinitialize the attribute list before deallocating the
|
|
// underlying buffer.
|
|
ProcThreadAttributeListPtr attrList(
|
|
reinterpret_cast<LPPROC_THREAD_ATTRIBUTE_LIST>(buf.release()));
|
|
|
|
if (mMitigationPolicies) {
|
|
if (!::UpdateProcThreadAttribute(
|
|
attrList.get(), 0, PROC_THREAD_ATTRIBUTE_MITIGATION_POLICY,
|
|
&mMitigationPolicies, sizeof(mMitigationPolicies), nullptr,
|
|
nullptr)) {
|
|
return LAUNCHER_ERROR_FROM_LAST();
|
|
}
|
|
}
|
|
|
|
if (!mInheritableHandles.empty()) {
|
|
if (!::UpdateProcThreadAttribute(
|
|
attrList.get(), 0, PROC_THREAD_ATTRIBUTE_HANDLE_LIST,
|
|
mInheritableHandles.begin(),
|
|
mInheritableHandles.length() * sizeof(HANDLE), nullptr,
|
|
nullptr)) {
|
|
return LAUNCHER_ERROR_FROM_LAST();
|
|
}
|
|
}
|
|
|
|
mAttrList = std::move(attrList);
|
|
aSiex.lpAttributeList = mAttrList.get();
|
|
aSiex.StartupInfo.cb = sizeof(STARTUPINFOEXW);
|
|
return true;
|
|
}
|
|
|
|
private:
|
|
static const uint32_t kNumInline = 3; // Inline storage for the std handles
|
|
|
|
DWORD64 mMitigationPolicies;
|
|
Vector<HANDLE, kNumInline> mInheritableHandles;
|
|
ProcThreadAttributeListPtr mAttrList;
|
|
};
|
|
|
|
} // namespace mozilla
|
|
|
|
#endif // mozilla_ProcThreadAttributes_h
|