{"id":112611,"date":"2026-08-13T07:00:00","date_gmt":"2026-08-13T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=112611"},"modified":"2026-08-13T23:02:59","modified_gmt":"2026-08-14T06:02:59","slug":"20260813-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20260813-00\/?p=112611","title":{"rendered":"A little helper class for managing LPPROC_THREAD_ATTRIBUTE_LIST<\/CODE>s"},"content":{"rendered":"

The LPPROC_THREAD_ATTRIBUTE_LIST<\/code> is a bit annoying to manage. You have to allocate memory for it yourself, but you don’t know how much; you have to ask Initialize\u00adProc\u00adThread\u00adAttribute\u00adList<\/code>. And then when you’re done, you have to call Delete\u00adProc\u00adThread\u00adAttribute\u00adList<\/code> before freeing the memory.<\/p>\n

We suffered through this when we controlled which handles are inherited by a new process<\/a>. I wrote a helper function<\/a> to try to make it easier, by taking the attributes as a separate parameter beyond the parameters to Create\u00adProcess<\/code> but I’m not sure if it was entirely successful.<\/p>\n

Here’s another try, this time building on the Windows Implementation Library.<\/p>\n

namespace details\r\n{\r\n    inline void FreeProcThreadAttributeList(\r\n        _Pre_valid_ _Frees_ptr_ LPPROC_THREAD_ATTRIBUTE_LIST list)\r\n    {\r\n        ::DeleteProcThreadAttributeList(list);\r\n        ::HeapFree(::GetProcessHeap(), 0, list);\r\n    }\r\n};\r\n\r\nusing unique_proc_thread_attribute_list = wil::unique_any<LPPROC_THREAD_ATTRIBUTE_LIST,\r\n    decltype(&details::FreeProcThreadAttributeList), details::FreeProcThreadAttributeList>;\r\n\r\nHRESULT make_proc_thread_attribute_list_nothrow(\r\n    DWORD attributeCount, _Out_ LPPROC_THREAD_ATTRIBUTE_LIST* result)\r\n{\r\n    *result = nullptr;\r\n    SIZE_T size = 0;\r\n    InitializeProcThreadAttributeList(nullptr, attributeCount, 0, &size);\r\n    auto p = wil::unique_process_heap_ptr<std::remove_pointer_t<LPPROC_THREAD_ATTRIBUTE_LIST>>(\r\n        static_cast<LPPROC_THREAD_ATTRIBUTE_LIST>(::HeapAlloc(::GetProcessHeap(), 0, size)));\r\n    RETURN_IF_NULL_ALLOC(p);\r\n    RETURN_IF_WIN32_BOOL_FALSE(InitializeProcThreadAttributeList(p.get(), attributeCount, 0, &size));\r\n    *result = p.release();\r\n    return S_OK;\r\n}\r\n\r\nunique_proc_thread_attribute_list make_proc_thread_attribute_list(DWORD attributeCount)\r\n{\r\n    unique_proc_thread_attribute_list result;\r\n    THROW_IF_FAILED(make_proc_thread_attribute_list_nothrow(attributeCount, result.put()));\r\n    return result;\r\n}\r\n<\/pre>\n
We start by declaring a helper function that cleans up an LPPROC_THREAD_ATTRIBUTE_LIST<\/code> by deleting the contents, and then freeing the buffer. We use that to define a unique_proc_thread_attribute_list<\/code> which holds a heap-allocated pointer that has been initialized as a LPPROC_THREAD_ATTRIBUTE_LIST<\/code>.<\/p>\n
The first helper function is the nonthrowing version: it asks for the required size of a LPPROC_THREAD_ATTRIBUTE_LIST<\/code> for the specified number of attributes, then allocates that much memory on the heap, storing it in a unique_process_heap_ptr<\/code> so that it will be freed if we fail to initialize it. Declaring that unique_process_heap_ptr<\/code> is a bit of a pain because we want it to be a “unique pointer to whatever it is that LPPROC_THREAD_ATTRIBUTE_LIST<\/code> points to.” It’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’t work here.<\/p>\n
After we allocate the memory, we try to initialize it. If that fails (and I can’t imagine why), we propagate the error, and the RAII type frees the (uninitialized) heap memory.<\/p>\n
If initialization succeeds, we return the pointer to the caller, who now takes responsibility for freeing it.<\/p>\n
Note that the temporary holding place has to be a unique_process_heap_ptr<\/code> and not a unique_proc_thread_attribute_list<\/code>: If the initialization fails, we must not call Delete\u00adProc\u00adThread\u00adAttribute\u00adList<\/code>, so we have to hold the heap pointer in something that won’t try to call Delete\u00adProc\u00adThread\u00adAttribute\u00adList<\/code>.<\/p>\n
We can easily use the nonthrowing version to build a throwing version.<\/p>\n
My next idea was to let you pass the attributes you want to pre-fill into the attribute list.<\/p>\n
struct proc_thread_attribute {\r\n   template<typename T = void>\r\n   proc_thread_attribute(DWORD_PTR attribute, T* value, SIZE_T size = sizeof(T)) :\r\n      attribute(attribute), value(value), size(size) {\r\n   }\r\n\r\n   DWORD_PTR attribute;\r\n   PVOID value;\r\n   SIZE_T size;\r\n};\r\n\r\ntemplate<typename C>\r\nHRESULT update_proc_thread_attribute_list_nothrow(\r\n    LPPROC_THREAD_ATTRIBUTE_LIST list, C&& attributes)\r\n{\r\n    for (auto&& attribute : attributes) {\r\n        RETURN_IF_WIN32_BOOL_FALSE(\r\n            UpdateProcThreadAttribute(list, 0, attribute.attribute,\r\n                attribute.value, attribute.size, nullptr, nullptr));\r\n    }\r\n    return S_OK;\r\n}\r\n\r\ntemplate<typename C>\r\nvoid update_proc_thread_attribute_list(\r\n    LPPROC_THREAD_ATTRIBUTE_LIST list, C&& attributes)\r\n{\r\n    THROW_IF_FAILED(update_proc_thread_attribute_list_nothrow(\r\n        list, std::forward<C>(attributes)));\r\n}\r\n<\/pre>\n
The container parameter can be anything iterable whose value type has attribute<\/code>, value<\/code>, and size<\/code> members. It’s probably a collection of proc_thread_attribute<\/code>s, but it doesn’t have to be. (Maybe it’s a collection of things derived from proc_thread_attribute<\/code>.)<\/p>\n
We can add this to our make_proc_thread_attribute_list<\/code> function so that callers can pass in a list of attributes they want, and we’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>\n
\/\/ No changes to this function\r\nHRESULT make_proc_thread_attribute_list_nothrow(\r\n    DWORD attributeCount, _Out_ LPPROC_THREAD_ATTRIBUTE_LIST* result)\r\n{\r\n    *result = nullptr;\r\n    SIZE_T size = 0;\r\n    InitializeProcThreadAttributeList(nullptr, attributeCount, 0, &size);\r\n    auto p = wil::unique_process_heap_ptr<std::remove_pointer_t<LPPROC_THREAD_ATTRIBUTE_LIST>>(\r\n        static_cast<LPPROC_THREAD_ATTRIBUTE_LIST>(::HeapAlloc(::GetProcessHeap(), 0, size)));\r\n    RETURN_IF_NULL_ALLOC(p);\r\n    RETURN_IF_WIN32_BOOL_FALSE(InitializeProcThreadAttributeList(p.get(), attributeCount, 0, &size));\r\n    *result = p.release();\r\n    return S_OK;\r\n}\r\n\r\n\/\/ New overload that takes a list of attributes to preload,\r\n\/\/ with room for any additional attributes you want to add later.\r\n\r\ntemplate<typename C>\r\nHRESULT make_proc_thread_attribute_list_nothrow(\r\n    C&& attributes, DWORD extraAttributeCount,\r\n    _Out_ LPPROC_THREAD_ATTRIBUTE_LIST* result)\r\n{\r\n    *result = nullptr;\r\n    unique_proc_thread_attribute_list list;\r\n    RETURN_IF_FAILED(make_proc_thread_attribute_list_nothrow(\r\n        static_cast<DWORD>(attributes.size()) + extraAttributeCount,\r\n        list.put()));\r\n    RETURN_IF_FAILED(update_proc_thread_attribute_list_nothrow(\r\n        list.get(), std::forward<C>(attributes)));\r\n\r\n    *result = list.release();\r\n    return S_OK;\r\n}\r\n\r\n\/\/ New overload that takes a list of attributes to preload,\r\n\/\/ with no room for more.\r\n\r\ntemplate<typename C>\r\nstd::enable_if_t<!std::is_integral_v<C>, HRESULT>\r\n    make_proc_thread_attribute_list_nothrow(\r\n        C&& attributes,\r\n        _Out_ LPPROC_THREAD_ATTRIBUTE_LIST* result)\r\n{\r\n    return make_proc_thread_attribute_list_nothrow(\r\n        std::forward<C>(attributes), 0, result);\r\n}\r\n<\/pre>\n
Note that without the std::enable_if_t<\/code> on the third overload, we would have an ambiguity if somebody called make_proc_thread_attribute_list_nothrow(1, p)<\/code> because the parameter 1<\/code> would satisfy both the DWORD<\/code> parameter from the first overload as well as matching the third overload with 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>\n
We can then build a throwing version out of the nonthrowing version.<\/p>\n
unique_proc_thread_attribute_list\r\n    make_proc_thread_attribute_list(DWORD attributeCount)\r\n{\r\n    unique_proc_thread_attribute_list result;\r\n    THROW_IF_FAILED(make_proc_thread_attribute_list_nothrow(\r\n        attributeCount, result.put()));\r\n    return result;\r\n}\r\n\r\ntemplate<typename C = std::initializer_list<proc_thread_attribute>>\r\nstd::enable_if_t<!std::is_integral_v<C>, unique_proc_thread_attribute_list>\r\n    make_proc_thread_attribute_list(\r\n        C&& attributes, DWORD extraAttributeCount = 0)\r\n{\r\n    unique_proc_thread_attribute_list result;\r\n    THROW_IF_FAILED(make_proc_thread_attribute_list_nothrow(\r\n        std::forward<C>(attributes), extraAttributeCount,\r\n        result.put()));\r\n    return result;\r\n}\r\n<\/pre>\n
We use a defaulted parameter to collapse the “collection initializer” and “collection initializer with additional space” 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>\n
You can use this to build process\/thread attribute lists at one go.<\/p>\n
HANDLE handles[2] = { handle1, handle2 };\r\nDWORD protection = PROTECTION_LEVEL_SAME;\r\nauto list = make_proc_thread_attribute_list({\r\n    { PROC_THREAD_ATTRIBUTE_HANDLE_LIST, &handles, sizeof(handles) },\r\n    { PROC_THREAD_ATTRIBUTE_PROTECTION_LEVEL, &protection, sizeof(protection) },\r\n});\r\n<\/pre>\n
Or you can build it up with some premade attributes, and others that you add conditionally:<\/p>\n
HANDLE handles[2] = { handle1, handle2 };\r\nDWORD protection = PROTECTION_LEVEL_SAME;\r\nauto list = make_proc_thread_attribute_list({\r\n    { PROC_THREAD_ATTRIBUTE_HANDLE_LIST, &handles, sizeof(handles) },\r\n    { PROC_THREAD_ATTRIBUTE_PROTECTION_LEVEL, &protection, sizeof(protection) },\r\n}, 1); \/\/ \"1\" leaves room for one more attribute\r\nif (job != nullptr) {\r\n    UpdateProcThreadAttribute(list.get(),\r\n        PROC_THREAD_ATTRIBUTE_JOB_LIST,\r\n        &job, sizeof(job), nullptr, nullptr);\r\n}\r\n<\/pre>\n","protected":false},"excerpt":{"rendered":"
Another RAII-style wrapper.<\/p>\n","protected":false},"author":1069,"featured_media":111744,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[25],"class_list":["post-112611","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
Another RAII-style wrapper.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/112611","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/users\/1069"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/comments?post=112611"}],"version-history":[{"count":1,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/112611\/revisions"}],"predecessor-version":[{"id":112612,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/112611\/revisions\/112612"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media\/111744"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media?parent=112611"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=112611"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=112611"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}