Fix use of async_mutex guard to avoid coroutine RAII bug on GCC 15, remove macos-14 (EOL)

mvandeberg · mvandeberg · commit 5a40e9a4ffbe · 2026-03-20T17:53:19.000-06:00
diff --git a/.github/compilers.json b/.github/compilers.json
@@ -130,21 +130,12 @@
       "version": "*",
       "cxxstd": "20,23",
       "latest_cxxstd": "23",
-      "runs_on": "macos-14",
+      "runs_on": "macos-15",
       "cxx": "clang++",
       "cc": "clang",
       "b2_toolset": "clang",
       "is_earliest": true
     },
-    {
-      "version": "*",
-      "cxxstd": "20,23",
-      "latest_cxxstd": "23",
-      "runs_on": "macos-15",
-      "cxx": "clang++",
-      "cc": "clang",
-      "b2_toolset": "clang"
-    },
     {
       "version": "*",
       "cxxstd": "20,23",
diff --git a/src/openssl/src/openssl_stream.cpp b/src/openssl/src/openssl_stream.cpp
@@ -374,9 +374,10 @@ struct openssl_stream::impl
                 break;
 
             {
-                auto [lec, guard] = co_await io_cm_.scoped_lock();
+                auto [lec] = co_await io_cm_.lock();
                 if (lec)
                     co_return lec;
+                capy::async_mutex::lock_guard io_guard(&io_cm_);
                 auto [ec, n] = co_await capy::write(
                     s_, capy::const_buffer(out_buf_.data(), got));
                 if (ec)
@@ -388,9 +389,10 @@ struct openssl_stream::impl
 
     capy::task<std::error_code> read_input()
     {
-        auto [lec, guard] = co_await io_cm_.scoped_lock();
+        auto [lec] = co_await io_cm_.lock();
         if (lec)
             co_return lec;
+        capy::async_mutex::lock_guard io_guard(&io_cm_);
         auto [ec, n] = co_await s_.read_some(
             capy::mutable_buffer(in_buf_.data(), in_buf_.size()));
         if (ec)
diff --git a/src/wolfssl/src/wolfssl_stream.cpp b/src/wolfssl/src/wolfssl_stream.cpp
@@ -494,12 +494,13 @@ struct wolfssl_stream::impl
                             read_in_buf_.data() + read_in_len_,
                             read_in_buf_.size() - read_in_len_);
 
-                        auto [lec, guard] = co_await io_cm_.scoped_lock();
+                        auto [lec] = co_await io_cm_.lock();
                         if (lec)
                         {
                             current_op_ = nullptr;
                             co_return {lec, total_read};
                         }
+                        capy::async_mutex::lock_guard io_guard(&io_cm_);
                         auto [rec, rn] = co_await s_.read_some(rbuf);
                         if (rec)
                         {
@@ -526,12 +527,13 @@ struct wolfssl_stream::impl
                         // Renegotiation
                         if (read_out_len_ > 0)
                         {
-                            auto [lec, guard] = co_await io_cm_.scoped_lock();
+                            auto [lec] = co_await io_cm_.lock();
                             if (lec)
                             {
                                 current_op_ = nullptr;
                                 co_return {lec, total_read};
                             }
+                            capy::async_mutex::lock_guard io_guard(&io_cm_);
                             auto [wec, wn] = co_await capy::write(
                                 s_,
                                 capy::const_buffer(
@@ -604,12 +606,13 @@ struct wolfssl_stream::impl
                         // Flush any pending output
                         if (write_out_len_ > 0)
                         {
-                            auto [lec, guard] = co_await io_cm_.scoped_lock();
+                            auto [lec] = co_await io_cm_.lock();
                             if (lec)
                             {
                                 current_op_ = nullptr;
                                 co_return {lec, total_written};
                             }
+                            capy::async_mutex::lock_guard io_guard(&io_cm_);
                             auto [wec, wn] = co_await capy::write(
                                 s_,
                                 capy::const_buffer(
@@ -633,12 +636,13 @@ struct wolfssl_stream::impl
                     {
                         if (write_out_len_ > 0)
                         {
-                            auto [lec, guard] = co_await io_cm_.scoped_lock();
+                            auto [lec] = co_await io_cm_.lock();
                             if (lec)
                             {
                                 current_op_ = nullptr;
                                 co_return {lec, total_written};
                             }
+                            capy::async_mutex::lock_guard io_guard(&io_cm_);
                             auto [wec, wn] = co_await capy::write(
                                 s_,
                                 capy::const_buffer(
@@ -662,12 +666,13 @@ struct wolfssl_stream::impl
                         capy::mutable_buffer rbuf(
                             write_in_buf_.data() + write_in_len_,
                             write_in_buf_.size() - write_in_len_);
-                        auto [lec, guard] = co_await io_cm_.scoped_lock();
+                        auto [lec] = co_await io_cm_.lock();
                         if (lec)
                         {
                             current_op_ = nullptr;
                             co_return {lec, total_written};
                         }
+                        capy::async_mutex::lock_guard io_guard(&io_cm_);
                         auto [rec, rn] = co_await s_.read_some(rbuf);
                         if (rec)
                         {
@@ -729,12 +734,13 @@ struct wolfssl_stream::impl
                 // Flush any remaining output
                 if (read_out_len_ > 0)
                 {
-                    auto [lec, guard] = co_await io_cm_.scoped_lock();
+                    auto [lec] = co_await io_cm_.lock();
                     if (lec)
                     {
                         ec = lec;
                         break;
                     }
+                    capy::async_mutex::lock_guard io_guard(&io_cm_);
                     auto [wec, wn] = co_await capy::write(
                         s_,
                         capy::const_buffer(
@@ -754,12 +760,13 @@ struct wolfssl_stream::impl
                     // Must flush (e.g. ClientHello) before reading ServerHello
                     if (read_out_len_ > 0)
                     {
-                        auto [lec, guard] = co_await io_cm_.scoped_lock();
+                        auto [lec] = co_await io_cm_.lock();
                         if (lec)
                         {
                             ec = lec;
                             break;
                         }
+                        capy::async_mutex::lock_guard io_guard(&io_cm_);
                         auto [wec, wn] = co_await capy::write(
                             s_,
                             capy::const_buffer(
@@ -780,12 +787,13 @@ struct wolfssl_stream::impl
                     capy::mutable_buffer rbuf(
                         read_in_buf_.data() + read_in_len_,
                         read_in_buf_.size() - read_in_len_);
-                    auto [lec, guard] = co_await io_cm_.scoped_lock();
+                    auto [lec] = co_await io_cm_.lock();
                     if (lec)
                     {
                         ec = lec;
                         break;
                     }
+                    capy::async_mutex::lock_guard io_guard(&io_cm_);
                     auto [rec, rn] = co_await s_.read_some(rbuf);
                     if (rec)
                     {
@@ -798,12 +806,13 @@ struct wolfssl_stream::impl
                 {
                     if (read_out_len_ > 0)
                     {
-                        auto [lec, guard] = co_await io_cm_.scoped_lock();
+                        auto [lec] = co_await io_cm_.lock();
                         if (lec)
                         {
                             ec = lec;
                             break;
                         }
+                        capy::async_mutex::lock_guard io_guard(&io_cm_);
                         auto [wec, wn] = co_await capy::write(
                             s_,
                             capy::const_buffer(
@@ -853,12 +862,13 @@ struct wolfssl_stream::impl
                 // Bidirectional shutdown complete - flush any remaining output
                 if (read_out_len_ > 0)
                 {
-                    auto [lec, guard] = co_await io_cm_.scoped_lock();
+                    auto [lec] = co_await io_cm_.lock();
                     if (lec)
                     {
                         ec = lec;
                         break;
                     }
+                    capy::async_mutex::lock_guard io_guard(&io_cm_);
                     auto [wec, wn] = co_await capy::write(
                         s_,
                         capy::const_buffer(
@@ -874,9 +884,13 @@ struct wolfssl_stream::impl
                 // First, flush any pending output (sends our close_notify)
                 if (read_out_len_ > 0)
                 {
-                    auto [lec, guard] = co_await io_cm_.scoped_lock();
+                    auto [lec] = co_await io_cm_.lock();
                     if (lec)
+                    {
+                        ec = lec;
                         break;
+                    }
+                    capy::async_mutex::lock_guard io_guard(&io_cm_);
                     auto [wec, wn] = co_await capy::write(
                         s_,
                         capy::const_buffer(
@@ -897,9 +911,13 @@ struct wolfssl_stream::impl
                     capy::mutable_buffer rbuf(
                         read_in_buf_.data() + read_in_len_,
                         read_in_buf_.size() - read_in_len_);
-                    auto [lec, guard] = co_await io_cm_.scoped_lock();
+                    auto [lec] = co_await io_cm_.lock();
                     if (lec)
+                    {
+                        ec = lec;
                         break;
+                    }
+                    capy::async_mutex::lock_guard io_guard(&io_cm_);
                     auto [rec, rn] = co_await s_.read_some(rbuf);
                     if (rec)
                         break; // EOF or socket error during shutdown read - acceptable

Original file line number	Diff line number	Diff line change
`@@ -494,12 +494,13 @@ struct wolfssl_stream::impl`
`494`	`494`	`read_in_buf_.data() + read_in_len_,`
`495`	`495`	`read_in_buf_.size() - read_in_len_);`
`496`	`496`
`497`		`- auto [lec, guard] = co_await io_cm_.scoped_lock();`
	`497`	`+ auto [lec] = co_await io_cm_.lock();`
`498`	`498`	`if (lec)`
`499`	`499`	`{`
`500`	`500`	`current_op_ = nullptr;`
`501`	`501`	`co_return {lec, total_read};`
`502`	`502`	`}`
	`503`	`+ capy::async_mutex::lock_guard io_guard(&io_cm_);`
`503`	`504`	`auto [rec, rn] = co_await s_.read_some(rbuf);`
`504`	`505`	`if (rec)`
`505`	`506`	`{`
`@@ -526,12 +527,13 @@ struct wolfssl_stream::impl`
`526`	`527`	`// Renegotiation`
`527`	`528`	`if (read_out_len_ > 0)`
`528`	`529`	`{`
`529`		`- auto [lec, guard] = co_await io_cm_.scoped_lock();`
	`530`	`+ auto [lec] = co_await io_cm_.lock();`
`530`	`531`	`if (lec)`
`531`	`532`	`{`
`532`	`533`	`current_op_ = nullptr;`
`533`	`534`	`co_return {lec, total_read};`
`534`	`535`	`}`
	`536`	`+ capy::async_mutex::lock_guard io_guard(&io_cm_);`
`535`	`537`	`auto [wec, wn] = co_await capy::write(`
`536`	`538`	`s_,`
`537`	`539`	`capy::const_buffer(`
`@@ -604,12 +606,13 @@ struct wolfssl_stream::impl`
`604`	`606`	`// Flush any pending output`
`605`	`607`	`if (write_out_len_ > 0)`
`606`	`608`	`{`
`607`		`- auto [lec, guard] = co_await io_cm_.scoped_lock();`
	`609`	`+ auto [lec] = co_await io_cm_.lock();`
`608`	`610`	`if (lec)`
`609`	`611`	`{`
`610`	`612`	`current_op_ = nullptr;`
`611`	`613`	`co_return {lec, total_written};`
`612`	`614`	`}`
	`615`	`+ capy::async_mutex::lock_guard io_guard(&io_cm_);`
`613`	`616`	`auto [wec, wn] = co_await capy::write(`
`614`	`617`	`s_,`
`615`	`618`	`capy::const_buffer(`
`@@ -633,12 +636,13 @@ struct wolfssl_stream::impl`
`633`	`636`	`{`
`634`	`637`	`if (write_out_len_ > 0)`
`635`	`638`	`{`
`636`		`- auto [lec, guard] = co_await io_cm_.scoped_lock();`
	`639`	`+ auto [lec] = co_await io_cm_.lock();`
`637`	`640`	`if (lec)`
`638`	`641`	`{`
`639`	`642`	`current_op_ = nullptr;`
`640`	`643`	`co_return {lec, total_written};`
`641`	`644`	`}`
	`645`	`+ capy::async_mutex::lock_guard io_guard(&io_cm_);`
`642`	`646`	`auto [wec, wn] = co_await capy::write(`
`643`	`647`	`s_,`
`644`	`648`	`capy::const_buffer(`
`@@ -662,12 +666,13 @@ struct wolfssl_stream::impl`
`662`	`666`	`capy::mutable_buffer rbuf(`
`663`	`667`	`write_in_buf_.data() + write_in_len_,`
`664`	`668`	`write_in_buf_.size() - write_in_len_);`
`665`		`- auto [lec, guard] = co_await io_cm_.scoped_lock();`
	`669`	`+ auto [lec] = co_await io_cm_.lock();`
`666`	`670`	`if (lec)`
`667`	`671`	`{`
`668`	`672`	`current_op_ = nullptr;`
`669`	`673`	`co_return {lec, total_written};`
`670`	`674`	`}`
	`675`	`+ capy::async_mutex::lock_guard io_guard(&io_cm_);`
`671`	`676`	`auto [rec, rn] = co_await s_.read_some(rbuf);`
`672`	`677`	`if (rec)`
`673`	`678`	`{`
`@@ -729,12 +734,13 @@ struct wolfssl_stream::impl`
`729`	`734`	`// Flush any remaining output`
`730`	`735`	`if (read_out_len_ > 0)`
`731`	`736`	`{`
`732`		`- auto [lec, guard] = co_await io_cm_.scoped_lock();`
	`737`	`+ auto [lec] = co_await io_cm_.lock();`
`733`	`738`	`if (lec)`
`734`	`739`	`{`
`735`	`740`	`ec = lec;`
`736`	`741`	`break;`
`737`	`742`	`}`
	`743`	`+ capy::async_mutex::lock_guard io_guard(&io_cm_);`
`738`	`744`	`auto [wec, wn] = co_await capy::write(`
`739`	`745`	`s_,`
`740`	`746`	`capy::const_buffer(`
`@@ -754,12 +760,13 @@ struct wolfssl_stream::impl`
`754`	`760`	`// Must flush (e.g. ClientHello) before reading ServerHello`
`755`	`761`	`if (read_out_len_ > 0)`
`756`	`762`	`{`
`757`		`- auto [lec, guard] = co_await io_cm_.scoped_lock();`
	`763`	`+ auto [lec] = co_await io_cm_.lock();`
`758`	`764`	`if (lec)`
`759`	`765`	`{`
`760`	`766`	`ec = lec;`
`761`	`767`	`break;`
`762`	`768`	`}`
	`769`	`+ capy::async_mutex::lock_guard io_guard(&io_cm_);`
`763`	`770`	`auto [wec, wn] = co_await capy::write(`
`764`	`771`	`s_,`
`765`	`772`	`capy::const_buffer(`
`@@ -780,12 +787,13 @@ struct wolfssl_stream::impl`
`780`	`787`	`capy::mutable_buffer rbuf(`
`781`	`788`	`read_in_buf_.data() + read_in_len_,`
`782`	`789`	`read_in_buf_.size() - read_in_len_);`
`783`		`- auto [lec, guard] = co_await io_cm_.scoped_lock();`
	`790`	`+ auto [lec] = co_await io_cm_.lock();`
`784`	`791`	`if (lec)`
`785`	`792`	`{`
`786`	`793`	`ec = lec;`
`787`	`794`	`break;`
`788`	`795`	`}`
	`796`	`+ capy::async_mutex::lock_guard io_guard(&io_cm_);`
`789`	`797`	`auto [rec, rn] = co_await s_.read_some(rbuf);`
`790`	`798`	`if (rec)`
`791`	`799`	`{`
`@@ -798,12 +806,13 @@ struct wolfssl_stream::impl`
`798`	`806`	`{`
`799`	`807`	`if (read_out_len_ > 0)`
`800`	`808`	`{`
`801`		`- auto [lec, guard] = co_await io_cm_.scoped_lock();`
	`809`	`+ auto [lec] = co_await io_cm_.lock();`
`802`	`810`	`if (lec)`
`803`	`811`	`{`
`804`	`812`	`ec = lec;`
`805`	`813`	`break;`
`806`	`814`	`}`
	`815`	`+ capy::async_mutex::lock_guard io_guard(&io_cm_);`
`807`	`816`	`auto [wec, wn] = co_await capy::write(`
`808`	`817`	`s_,`
`809`	`818`	`capy::const_buffer(`
`@@ -853,12 +862,13 @@ struct wolfssl_stream::impl`
`853`	`862`	`// Bidirectional shutdown complete - flush any remaining output`
`854`	`863`	`if (read_out_len_ > 0)`
`855`	`864`	`{`
`856`		`- auto [lec, guard] = co_await io_cm_.scoped_lock();`
	`865`	`+ auto [lec] = co_await io_cm_.lock();`
`857`	`866`	`if (lec)`
`858`	`867`	`{`
`859`	`868`	`ec = lec;`
`860`	`869`	`break;`
`861`	`870`	`}`
	`871`	`+ capy::async_mutex::lock_guard io_guard(&io_cm_);`
`862`	`872`	`auto [wec, wn] = co_await capy::write(`
`863`	`873`	`s_,`
`864`	`874`	`capy::const_buffer(`
`@@ -874,9 +884,13 @@ struct wolfssl_stream::impl`
`874`	`884`	`// First, flush any pending output (sends our close_notify)`
`875`	`885`	`if (read_out_len_ > 0)`
`876`	`886`	`{`
`877`		`- auto [lec, guard] = co_await io_cm_.scoped_lock();`
	`887`	`+ auto [lec] = co_await io_cm_.lock();`
`878`	`888`	`if (lec)`
	`889`	`+ {`
	`890`	`+ ec = lec;`
`879`	`891`	`break;`
	`892`	`+ }`
	`893`	`+ capy::async_mutex::lock_guard io_guard(&io_cm_);`
`880`	`894`	`auto [wec, wn] = co_await capy::write(`
`881`	`895`	`s_,`
`882`	`896`	`capy::const_buffer(`
`@@ -897,9 +911,13 @@ struct wolfssl_stream::impl`
`897`	`911`	`capy::mutable_buffer rbuf(`
`898`	`912`	`read_in_buf_.data() + read_in_len_,`
`899`	`913`	`read_in_buf_.size() - read_in_len_);`
`900`		`- auto [lec, guard] = co_await io_cm_.scoped_lock();`
	`914`	`+ auto [lec] = co_await io_cm_.lock();`
`901`	`915`	`if (lec)`
	`916`	`+ {`
	`917`	`+ ec = lec;`
`902`	`918`	`break;`
	`919`	`+ }`
	`920`	`+ capy::async_mutex::lock_guard io_guard(&io_cm_);`
`903`	`921`	`auto [rec, rn] = co_await s_.read_some(rbuf);`
`904`	`922`	`if (rec)`
`905`	`923`	`break; // EOF or socket error during shutdown read - acceptable`