用于管理 LPPROC_THREAD_ATTRIBUTE_LIST 的小型辅助类

<p>The <code>LPPROC_<wbr />THREAD_<wbr />ATTRIBUTE_<wbr />LIST</code> is a bit annoying to manage. You have to allocate memory for it yourself, but you don&#8217;t know how much; you have to ask <code>Initialize­Proc­Thread­Attribute­List</code>. And then when you&#8217;re done, you have to call <code>Delete­Proc­Thread­Attribute­List</code> before freeing the memory.</p> <p>We suffered through this when <a title="Programmatically controlling which handles are inherited by new processes in Win32" href="https://devblogs.microsoft.com/oldnewthing/20111216-00/?p=8873"> we controlled which handles are inherited by a new process</a>. <a title="Another way to create a process with attributes, maybe worse maybe better" href="https://devblogs.microsoft.com/oldnewthing/20130426-00/?p=4543"> I wrote a helper function</a> to try to make it easier, by taking the attributes as a separate parameter beyond the parameters to <code>Create­Process</code> but I&#8217;m not sure if it was entirely successful.</p> <p>Here&#8217;s another try, this time building on the Windows Implementation Library.</p> <pre>namespace details { inline void FreeProcThreadAttributeList( _Pre_valid_ _Frees_ptr_ LPPROC_THREAD_ATTRIBUTE_LIST list) { ::DeleteProcThreadAttributeList(list); ::HeapFree(::GetProcessHeap(), 0, list); } }; using unique_proc_thread_attribute_list = wil::unique_any&lt;LPPROC_THREAD_ATTRIBUTE_LIST, decltype(&amp;details::FreeProcThreadAttributeList), details::FreeProcThreadAttributeList&gt;; HRESULT make_proc_thread_attribute_list_nothrow( DWORD attributeCount, _Out_ LPPROC_THREAD_ATTRIBUTE_LIST* result) { *result = nullptr; SIZE_T size = 0; InitializeProcThreadAttributeList(nullptr, attributeCount, 0, &amp;size); auto p = wil::unique_process_heap_ptr&lt;std::remove_pointer_t&lt;LPPROC_THREAD_ATTRIBUTE_LIST&gt;&gt;( static_cast&lt;LPPROC_THREAD_ATTRIBUTE_LIST&gt;(::HeapAlloc(::GetProcessHeap(), 0, size))); RETURN_IF_NULL_ALLOC(p); RETURN_IF_WIN32_BOOL_FALSE(InitializeProcThreadAttributeList(p.get(), attributeCount, 0, &amp;size)); *result = p.release(); return S_OK; } unique_proc_thread_attribute_list make_proc_thread_attribute_list(DWORD attributeCount) { unique_proc_thread_attribute_list result; THROW_IF_FAILED(make_proc_thread_attribute_list_nothrow(attributeCount, result.put())); return result; } </pre> <p>We start by declaring a helper function that cleans up an <code>LPPROC_<wbr />THREAD_<wbr />ATTRIBUTE_<wbr />LIST</code> by deleting the contents, and then freeing the buffer. We use that to define a <code>unique_<wbr />proc_<wbr />thread_<wbr />attribute_<wbr />list</code> which holds a heap-allocated pointer that has been initialized as a <code>LPPROC_<wbr />THREAD_<wbr />ATTRIBUTE_<wbr />LIST</code>.</p> <p>The first helper function is the nonthrowing version: it asks for the required size of a <code>LPPROC_<wbr />THREAD_<wbr />ATTRIBUTE_<wbr />LIST</code> for the specified number of attributes, then allocates that much memory on the heap, storing it in a <code>unique_<wbr />process_<wbr />heap_<wbr />ptr</code> so that it will be freed if we fail to initialize it. Declaring that <code>unique_<wbr />process_<wbr />heap_<wbr />ptr</code> is a bit of a pain because we want it to be a &#8220;unique pointer to whatever it is that <code>LPPROC_<wbr />THREAD_<wbr />ATTRIBUTE_<wbr />LIST</code> points to.&#8221; It&#8217;s also annoying that we have to repeat ourselves in both the template type parameter as well as in the cast of the heap-allocated pointer, because CTAD doesn&#8217;t work here.</p> <p>After we allocate the memory, we try to initialize it. If that fails (and I can&#8217;t imagine why), we propagate the error, and the RAII type frees the (uninitialized) heap memory.</p> <p>If initialization succeeds, we return the pointer to the caller, who now takes responsibility for freeing it.</p> <p>Note that the temporary holding place has to be a <code>unique_<wbr />process_<wbr />heap_<wbr />ptr</code> and not a <code>unique_<wbr />proc_<wbr />thread_<wbr />attribute_<wbr />list</code>: If the initialization fails, we must not call <code>Delete­Proc­Thread­Attribute­List</code>, so we have to hold the heap pointer in something that won&#8217;t try to call <code>Delete­Proc­Thread­Attribute­List</code>.</p> <p>We can easily use the nonthrowing version to build a throwing version.</p> <p>My next idea was to let you pass the attributes you want to pre-fill into the attribute list.</p> <pre>struct proc_thread_attribute { template&lt;typename T = void&gt; proc_thread_attribute(DWORD_PTR attribute, T* value, SIZE_T size = sizeof(T)) : attribute(attribute), value(value), size(size) { } DWORD_PTR attribute; PVOID value; SIZE_T size; }; template&lt;typename C&gt; HRESULT update_proc_thread_attribute_list_nothrow( LPPROC_THREAD_ATTRIBUTE_LIST list, C&amp;&amp; attributes) { for (auto&amp;&amp; attribute : attributes) { RETURN_IF_WIN32_BOOL_FALSE( UpdateProcThreadAttribute(list, 0, attribute.attribute, attribute.value, attribute.size, nullptr, nullptr)); } return S_OK; } template&lt;typename C&gt; void update_proc_thread_attribute_list( LPPROC_THREAD_ATTRIBUTE_LIST list, C&amp;&amp; attributes) { THROW_IF_FAILED(update_proc_thread_attribute_list_nothrow( list, std::forward&lt;C&gt;(attributes))); } </pre> <p>The container parameter can be anything iterable whose value type has <code>attribute</code>, <code>value</code>, and <code>size</code> members. It&#8217;s probably a collection of <code>proc_<wbr />thread_<wbr />attribute</code>s, but it doesn&#8217;t have to be. (Maybe it&#8217;s a collection of things derived from <code>proc_<wbr />thread_<wbr />attribute</code>.)</p> <p>We can add this to our <code>make_<wbr />proc_<wbr />thread_<wbr />attribute_<wbr />list</code> function so that callers can pass in a list of attributes they want, and we&#8217;ll make a list that holds them all. And as an extra bonus, you can request room for additional attributes beyond those in the collection you passed in. For example, you might have some attributes that you always use, and then some others you decide on dynamically.</p> <pre>// No changes to this function HRESULT make_proc_thread_attribute_list_nothrow( DWORD attributeCount, _Out_ LPPROC_THREAD_ATTRIBUTE_LIST* result) { *result = nullptr; SIZE_T size = 0; InitializeProcThreadAttributeList(nullptr, attributeCount, 0, &amp;size); auto p = wil::unique_process_heap_ptr&lt;std::remove_pointer_t&lt;LPPROC_THREAD_ATTRIBUTE_LIST&gt;&gt;( static_cast&lt;LPPROC_THREAD_ATTRIBUTE_LIST&gt;(::HeapAlloc(::GetProcessHeap(), 0, size))); RETURN_IF_NULL_ALLOC(p); RETURN_IF_WIN32_BOOL_FALSE(InitializeProcThreadAttributeList(p.get(), attributeCount, 0, &amp;size)); *result = p.release(); return S_OK; } // New overload that takes a list of attributes to preload, // with room for any additional attributes you want to add later. template&lt;typename C&gt; HRESULT make_proc_thread_attribute_list_nothrow( C&amp;&amp; attributes, DWORD extraAttributeCount, _Out_ LPPROC_THREAD_ATTRIBUTE_LIST* result) { *result = nullptr; unique_proc_thread_attribute_list list; RETURN_IF_FAILED(make_proc_thread_attribute_list_nothrow( static_cast&lt;DWORD&gt;(attributes.size()) + extraAttributeCount, list.put())); RETURN_IF_FAILED(update_proc_thread_attribute_list_nothrow( list.get(), std::forward&lt;C&gt;(attributes))); *result = list.release(); return S_OK; } // New overload that takes a list of attributes to preload, // with no room for more. template&lt;typename C&gt; std::enable_if_t&lt;!std::is_integral_v&lt;C&gt;, HRESULT&gt; make_proc_thread_attribute_list_nothrow( C&amp;&amp; attributes, _Out_ LPPROC_THREAD_ATTRIBUTE_LIST* result) { return make_proc_thread_attribute_list_nothrow( std::forward&lt;C&gt;(attributes), 0, result); } </pre> <p>Note that without the <code>std::enable_if_t</code> on the third overload, we would have an ambiguity if somebody called <code>make_<wbr />proc_<wbr />thread_<wbr />attribute_<wbr />list_<wbr />nothrow(1, p)</code> because the parameter <code>1</code> would satisfy both the <code>DWORD</code> parameter from the first overload as well as matching the third overload with <code>C = int</code>. To force the third one to be rejected, we use SFINAE to make the return type a substitution failure if the parameter is integral.</p> <p>We can then build a throwing version out of the nonthrowing version.</p> <pre>unique_proc_thread_attribute_list make_proc_thread_attribute_list(DWORD attributeCount) { unique_proc_thread_attribute_list result; THROW_IF_FAILED(make_proc_thread_attribute_list_nothrow( attributeCount, result.put())); return result; } template&lt;typename C = std::initializer_list&lt;proc_thread_attribute&gt;&gt; std::enable_if_t&lt;!std::is_integral_v&lt;C&gt;, unique_proc_thread_attribute_list&gt; make_proc_thread_attribute_list( C&amp;&amp; attributes, DWORD extraAttributeCount = 0) { unique_proc_thread_attribute_list result; THROW_IF_FAILED(make_proc_thread_attribute_list_nothrow( std::forward&lt;C&gt;(attributes), extraAttributeCount, result.put())); return result; } </pre> <p>We use a defaulted parameter to collapse the &#8220;collection initializer&#8221; and &#8220;collection initializer with additional space&#8221; overloads into one. We still need to use SFINAE to avoid an ambiguity that tries to treat a sole integer parameter as a collection.</p> <p>You can use this to build process/thread attribute lists at one go.</p> <pre>HANDLE handles[2] = { handle1, handle2 }; DWORD protection = PROTECTION_LEVEL_SAME; auto list = make_proc_thread_attribute_list({ { PROC_THREAD_ATTRIBUTE_HANDLE_LIST, &amp;handles, sizeof(handles) }, { PROC_THREAD_ATTRIBUTE_PROTECTION_LEVEL, &amp;protection, sizeof(protection) }, }); </pre> <p>Or you can build it up with some premade attributes, and others that you add conditionally:</p> <pre>HANDLE handles[2] = { handle1, handle2 }; DWORD protection = PROTECTION_LEVEL_SAME; auto list = make_proc_thread_attribute_list({ { PROC_THREAD_ATTRIBUTE_HANDLE_LIST, &amp;handles, sizeof(handles) }, { PROC_THREAD_ATTRIBUTE_PROTECTION_LEVEL, &amp;protection, sizeof(protection) }, }, 1); // "1" leaves room for one more attribute if (job != nullptr) { UpdateProcThreadAttribute(list.get(), PROC_THREAD_ATTRIBUTE_JOB_LIST, &amp;job, sizeof(job), nullptr, nullptr); } </pre> <p>The post <a href="https://devblogs.microsoft.com/oldnewthing/20260813-00/?p=112611">A little helper class for managing &lt;CODE&gt;LPPROC_&lt;WBR&gt;THREAD_&lt;WBR&gt;ATTRIBUTE_&lt;WBR&gt;LIST&lt;/CODE&gt;s</a> appeared first on <a href="https://devblogs.microsoft.com/oldnewthing">The Old New Thing</a>.</p>