Fix soft-mutex assert in websocket stream:

Fix #1000

This resolves the assert 'ws_.wr_block_ == tok_'.
This commit is contained in:
Vinnie Falco committed 2018-02-16 10:51:28 -08:00
1 parent 9f3c981d6a
commit ab32400d00
12 files changed
+173 -162

No files matched your search

+11 -28
View File
@@ -44,7 +44,6 @@ class stream<NextLayer, deflateSupported>::close_op
stream<NextLayer, deflateSupported>& ws;
detail::frame_buffer fb;
error_code ev;
token tok;
bool cont = false;
state(
@@ -52,7 +51,6 @@ class stream<NextLayer, deflateSupported>::close_op
stream<NextLayer, deflateSupported>& ws_,
close_reason const& cr)
: ws(ws_)
, tok(ws.tok_.unique())
{
// Serialize the close frame
ws.template write_close<
@@ -125,11 +123,8 @@ operator()(
BOOST_ASIO_CORO_REENTER(*this)
{
// Maybe suspend
if(! d.ws.wr_block_)
if(d.ws.wr_block_.try_lock(this))
{
// Acquire the write block
d.ws.wr_block_ = d.tok;
// Make sure the stream is open
if(! d.ws.check_open(ec))
goto upcall;
@@ -137,19 +132,17 @@ operator()(
else
{
// Suspend
BOOST_ASSERT(d.ws.wr_block_ != d.tok);
BOOST_ASIO_CORO_YIELD
d.ws.paused_close_.emplace(std::move(*this));
// Acquire the write block
BOOST_ASSERT(! d.ws.wr_block_);
d.ws.wr_block_ = d.tok;
d.ws.wr_block_.lock(this);
// Resume
BOOST_ASIO_CORO_YIELD
boost::asio::post(
d.ws.get_executor(), std::move(*this));
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
BOOST_ASSERT(d.ws.wr_block_.is_locked(this));
// Make sure the stream is open
if(! d.ws.check_open(ec))
@@ -180,27 +173,20 @@ operator()(
}
// Maybe suspend
if(! d.ws.rd_block_)
{
// Acquire the read block
d.ws.rd_block_ = d.tok;
}
else
if(! d.ws.rd_block_.try_lock(this))
{
// Suspend
BOOST_ASSERT(d.ws.rd_block_ != d.tok);
BOOST_ASIO_CORO_YIELD
d.ws.paused_r_close_.emplace(std::move(*this));
// Acquire the read block
BOOST_ASSERT(! d.ws.rd_block_);
d.ws.rd_block_ = d.tok;
d.ws.rd_block_.lock(this);
// Resume
BOOST_ASIO_CORO_YIELD
boost::asio::post(
d.ws.get_executor(), std::move(*this));
BOOST_ASSERT(d.ws.rd_block_ == d.tok);
BOOST_ASSERT(d.ws.rd_block_.is_locked(this));
// Make sure the stream is open
BOOST_ASSERT(d.ws.status_ != status::open);
@@ -275,12 +261,12 @@ operator()(
teardown:
// Teardown
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
BOOST_ASSERT(d.ws.wr_block_.is_locked(this));
using beast::websocket::async_teardown;
BOOST_ASIO_CORO_YIELD
async_teardown(d.ws.role_,
d.ws.stream_, std::move(*this));
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
BOOST_ASSERT(d.ws.wr_block_.is_locked(this));
if(ec == boost::asio::error::eof)
{
// Rationale:
@@ -296,13 +282,10 @@ operator()(
d.ws.close();
upcall:
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
d.ws.wr_block_.reset();
if(d.ws.rd_block_ == d.tok)
{
d.ws.rd_block_.reset();
BOOST_ASSERT(d.ws.wr_block_.is_locked(this));
d.ws.wr_block_.unlock(this);
if(d.ws.rd_block_.try_unlock(this))
d.ws.paused_r_rd_.maybe_invoke();
}
d.ws.paused_rd_.maybe_invoke() ||
d.ws.paused_ping_.maybe_invoke() ||
d.ws.paused_wr_.maybe_invoke();
+4 -12
View File
@@ -41,7 +41,6 @@ class stream<NextLayer, deflateSupported>::ping_op
{
stream<NextLayer, deflateSupported>& ws;
detail::frame_buffer fb;
token tok;
state(
Handler const&,
@@ -49,7 +48,6 @@ class stream<NextLayer, deflateSupported>::ping_op
detail::opcode op,
ping_data const& payload)
: ws(ws_)
, tok(ws.tok_.unique())
{
// Serialize the control frame
ws.template write_ping<
@@ -118,11 +116,8 @@ operator()(error_code ec, std::size_t)
BOOST_ASIO_CORO_REENTER(*this)
{
// Maybe suspend
if(! d.ws.wr_block_)
if(d.ws.wr_block_.try_lock(this))
{
// Acquire the write block
d.ws.wr_block_ = d.tok;
// Make sure the stream is open
if(! d.ws.check_open(ec))
{
@@ -136,19 +131,17 @@ operator()(error_code ec, std::size_t)
else
{
// Suspend
BOOST_ASSERT(d.ws.wr_block_ != d.tok);
BOOST_ASIO_CORO_YIELD
d.ws.paused_ping_.emplace(std::move(*this));
// Acquire the write block
BOOST_ASSERT(! d.ws.wr_block_);
d.ws.wr_block_ = d.tok;
d.ws.wr_block_.lock(this);
// Resume
BOOST_ASIO_CORO_YIELD
boost::asio::post(
d.ws.get_executor(), std::move(*this));
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
BOOST_ASSERT(d.ws.wr_block_.is_locked(this));
// Make sure the stream is open
if(! d.ws.check_open(ec))
@@ -163,8 +156,7 @@ operator()(error_code ec, std::size_t)
goto upcall;
upcall:
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
d.ws.wr_block_.reset();
d.ws.wr_block_.unlock(this);
d.ws.paused_close_.maybe_invoke() ||
d.ws.paused_rd_.maybe_invoke() ||
d.ws.paused_wr_.maybe_invoke();
+25 -52
View File
@@ -85,7 +85,6 @@ class stream<NextLayer, deflateSupported>::read_some_op
buffers_suffix<MutableBufferSequence> cb_;
std::size_t bytes_written_ = 0;
error_code result_;
token tok_;
close_code code_;
bool did_read_ = false;
bool cont_ = false;
@@ -103,7 +102,6 @@ public:
, ws_(ws)
, bs_(bs)
, cb_(bs)
, tok_(ws_.tok_.unique())
, code_(close_code::none)
{
}
@@ -165,11 +163,8 @@ operator()(
{
// Maybe suspend
do_maybe_suspend:
if(! ws_.rd_block_)
if(ws_.rd_block_.try_lock(this))
{
// Acquire the read block
ws_.rd_block_ = tok_;
// Make sure the stream is not closed
if( ws_.status_ == status::closed ||
ws_.status_ == status::failed)
@@ -182,19 +177,17 @@ operator()(
{
do_suspend:
// Suspend
BOOST_ASSERT(ws_.rd_block_ != tok_);
BOOST_ASIO_CORO_YIELD
ws_.paused_r_rd_.emplace(std::move(*this));
// Acquire the read block
BOOST_ASSERT(! ws_.rd_block_);
ws_.rd_block_ = tok_;
ws_.rd_block_.lock(this);
// Resume
BOOST_ASIO_CORO_YIELD
boost::asio::post(
ws_.get_executor(), std::move(*this));
BOOST_ASSERT(ws_.rd_block_ == tok_);
BOOST_ASSERT(ws_.rd_block_.is_locked(this));
// The only way to get read blocked is if
// a `close_op` wrote a close frame
@@ -209,7 +202,7 @@ operator()(
// then finish the read with operation_aborted.
loop:
BOOST_ASSERT(ws_.rd_block_ == tok_);
BOOST_ASSERT(ws_.rd_block_.is_locked(this));
// See if we need to read a frame header. This
// condition is structured to give the decompressor
// a chance to emit the final empty deflate block
@@ -230,29 +223,28 @@ operator()(
code_ = close_code::protocol_error;
goto close;
}
BOOST_ASSERT(ws_.rd_block_ == tok_);
BOOST_ASSERT(ws_.rd_block_.is_locked(this));
BOOST_ASIO_CORO_YIELD
ws_.stream_.async_read_some(
ws_.rd_buf_.prepare(read_size(
ws_.rd_buf_, ws_.rd_buf_.max_size())),
std::move(*this));
BOOST_ASSERT(ws_.rd_block_ == tok_);
BOOST_ASSERT(ws_.rd_block_.is_locked(this));
if(! ws_.check_ok(ec))
goto upcall;
ws_.rd_buf_.commit(bytes_transferred);
// Allow a close operation
// to acquire the read block
BOOST_ASSERT(ws_.rd_block_ == tok_);
ws_.rd_block_.reset();
ws_.rd_block_.unlock(this);
if( ws_.paused_r_close_.maybe_invoke())
{
// Suspend
BOOST_ASSERT(ws_.rd_block_);
BOOST_ASSERT(ws_.rd_block_.is_locked());
goto do_suspend;
}
// Acquire read block
ws_.rd_block_ = tok_;
ws_.rd_block_.lock(this);
}
// Immediately apply the mask to the portion
// of the buffer holding payload data.
@@ -302,36 +294,26 @@ operator()(
detail::opcode::pong, payload);
}
//BOOST_ASSERT(! ws_.paused_r_close_);
// Allow a close operation
// to acquire the read block
BOOST_ASSERT(ws_.rd_block_ == tok_);
ws_.rd_block_.reset();
ws_.rd_block_.unlock(this);
ws_.paused_r_close_.maybe_invoke();
// Maybe suspend
if(! ws_.wr_block_)
{
// Acquire the write block
ws_.wr_block_ = tok_;
}
else
if(! ws_.wr_block_.try_lock(this))
{
// Suspend
BOOST_ASSERT(ws_.wr_block_ != tok_);
BOOST_ASIO_CORO_YIELD
ws_.paused_rd_.emplace(std::move(*this));
// Acquire the write block
BOOST_ASSERT(! ws_.wr_block_);
ws_.wr_block_ = tok_;
ws_.wr_block_.lock(this);
// Resume
BOOST_ASIO_CORO_YIELD
boost::asio::post(
ws_.get_executor(), std::move(*this));
BOOST_ASSERT(ws_.wr_block_ == tok_);
BOOST_ASSERT(ws_.wr_block_.is_locked(this));
// Make sure the stream is open
if(! ws_.check_open(ec))
@@ -339,14 +321,14 @@ operator()(
}
// Send pong
BOOST_ASSERT(ws_.wr_block_ == tok_);
BOOST_ASSERT(ws_.wr_block_.is_locked(this));
BOOST_ASIO_CORO_YIELD
boost::asio::async_write(ws_.stream_,
ws_.rd_fb_.data(), std::move(*this));
BOOST_ASSERT(ws_.wr_block_ == tok_);
BOOST_ASSERT(ws_.wr_block_.is_locked(this));
if(! ws_.check_ok(ec))
goto upcall;
ws_.wr_block_.reset();
ws_.wr_block_.unlock(this);
ws_.paused_close_.maybe_invoke() ||
ws_.paused_ping_.maybe_invoke() ||
ws_.paused_wr_.maybe_invoke();
@@ -629,30 +611,25 @@ operator()(
goto upcall;
close:
if(! ws_.wr_block_)
if(ws_.wr_block_.try_lock(this))
{
// Acquire the write block
ws_.wr_block_ = tok_;
// Make sure the stream is open
BOOST_ASSERT(ws_.status_ == status::open);
}
else
{
// Suspend
BOOST_ASSERT(ws_.wr_block_ != tok_);
BOOST_ASIO_CORO_YIELD
ws_.paused_rd_.emplace(std::move(*this));
// Acquire the write block
BOOST_ASSERT(! ws_.wr_block_);
ws_.wr_block_ = tok_;
ws_.wr_block_.lock(this);
// Resume
BOOST_ASIO_CORO_YIELD
boost::asio::post(
ws_.get_executor(), std::move(*this));
BOOST_ASSERT(ws_.wr_block_ == tok_);
BOOST_ASSERT(ws_.wr_block_.is_locked(this));
// Make sure the stream is open
if(! ws_.check_open(ec))
@@ -673,23 +650,23 @@ operator()(
ws_.rd_fb_, code_);
// Send close frame
BOOST_ASSERT(ws_.wr_block_ == tok_);
BOOST_ASSERT(ws_.wr_block_.is_locked(this));
BOOST_ASIO_CORO_YIELD
boost::asio::async_write(
ws_.stream_, ws_.rd_fb_.data(),
std::move(*this));
BOOST_ASSERT(ws_.wr_block_ == tok_);
BOOST_ASSERT(ws_.wr_block_.is_locked(this));
if(! ws_.check_ok(ec))
goto upcall;
}
// Teardown
using beast::websocket::async_teardown;
BOOST_ASSERT(ws_.wr_block_ == tok_);
BOOST_ASSERT(ws_.wr_block_.is_locked(this));
BOOST_ASIO_CORO_YIELD
async_teardown(ws_.role_,
ws_.stream_, std::move(*this));
BOOST_ASSERT(ws_.wr_block_ == tok_);
BOOST_ASSERT(ws_.wr_block_.is_locked(this));
if(ec == boost::asio::error::eof)
{
// Rationale:
@@ -705,16 +682,12 @@ operator()(
ws_.close();
upcall:
if(ws_.rd_block_ == tok_)
ws_.rd_block_.reset();
ws_.rd_block_.try_unlock(this);
ws_.paused_r_close_.maybe_invoke();
if(ws_.wr_block_ == tok_)
{
ws_.wr_block_.reset();
if(ws_.wr_block_.try_unlock(this))
ws_.paused_close_.maybe_invoke() ||
ws_.paused_ping_.maybe_invoke() ||
ws_.paused_wr_.maybe_invoke();
}
if(! cont_)
return boost::asio::post(
ws_.stream_.get_executor(),
@@ -45,7 +45,6 @@ template<class... Args>
stream<NextLayer, deflateSupported>::
stream(Args&&... args)
: stream_(std::forward<Args>(args)...)
, tok_(1)
{
BOOST_ASSERT(rd_buf_.max_size() >=
max_control_frame_size);
@@ -125,6 +124,9 @@ open(role_type role)
rd_fh_.fin = false;
rd_close_ = false;
wr_close_ = false;
// These should not be necessary, because all completion
// handlers must be allowed to execute otherwise the
// stream exhibits undefined behavior.
wr_block_.reset();
rd_block_.reset();
cr_.code = close_code::none;
@@ -196,6 +198,9 @@ reset()
rd_close_ = false;
wr_close_ = false;
wr_cont_ = false;
// These should not be necessary, because all completion
// handlers must be allowed to execute otherwise the
// stream exhibits undefined behavior.
wr_block_.reset();
rd_block_.reset();
cr_.code = close_code::none;
+13 -21
View File
@@ -146,7 +146,6 @@ class stream<NextLayer, deflateSupported>::write_some_op
std::size_t bytes_transferred_ = 0;
std::size_t remain_;
std::size_t in_;
token tok_;
int how_;
bool fin_;
bool more_;
@@ -165,7 +164,6 @@ public:
: h_(std::forward<DeducedHandler>(h))
, ws_(ws)
, cb_(bs)
, tok_(ws_.tok_.unique())
, fin_(fin)
{
}
@@ -293,11 +291,8 @@ operator()(
}
// Maybe suspend
if(! ws_.wr_block_)
if(ws_.wr_block_.try_lock(this))
{
// Acquire the write block
ws_.wr_block_ = tok_;
// Make sure the stream is open
if(! ws_.check_open(ec))
goto upcall;
@@ -306,19 +301,17 @@ operator()(
{
do_suspend:
// Suspend
BOOST_ASSERT(ws_.wr_block_ != tok_);
BOOST_ASIO_CORO_YIELD
ws_.paused_wr_.emplace(std::move(*this));
// Acquire the write block
BOOST_ASSERT(! ws_.wr_block_);
ws_.wr_block_ = tok_;
ws_.wr_block_.lock(this);
// Resume
BOOST_ASIO_CORO_YIELD
boost::asio::post(
ws_.get_executor(), std::move(*this));
BOOST_ASSERT(ws_.wr_block_ == tok_);
BOOST_ASSERT(ws_.wr_block_.is_locked(this));
// Make sure the stream is open
if(! ws_.check_open(ec))
@@ -377,15 +370,15 @@ operator()(
fh_.op = detail::opcode::cont;
// Allow outgoing control frames to
// be sent in between message frames
ws_.wr_block_.reset();
ws_.wr_block_.unlock(this);
if( ws_.paused_close_.maybe_invoke() ||
ws_.paused_rd_.maybe_invoke() ||
ws_.paused_ping_.maybe_invoke())
{
BOOST_ASSERT(ws_.wr_block_);
BOOST_ASSERT(ws_.wr_block_.is_locked());
goto do_suspend;
}
ws_.wr_block_ = tok_;
ws_.wr_block_.lock(this);
}
goto upcall;
}
@@ -476,15 +469,15 @@ operator()(
fh_.op = detail::opcode::cont;
// Allow outgoing control frames to
// be sent in between message frames:
ws_.wr_block_.reset();
ws_.wr_block_.unlock(this);
if( ws_.paused_close_.maybe_invoke() ||
ws_.paused_rd_.maybe_invoke() ||
ws_.paused_ping_.maybe_invoke())
{
BOOST_ASSERT(ws_.wr_block_);
BOOST_ASSERT(ws_.wr_block_.is_locked());
goto do_suspend;
}
ws_.wr_block_ = tok_;
ws_.wr_block_.lock(this);
}
goto upcall;
}
@@ -537,15 +530,15 @@ operator()(
fh_.rsv1 = false;
// Allow outgoing control frames to
// be sent in between message frames:
ws_.wr_block_.reset();
ws_.wr_block_.unlock(this);
if( ws_.paused_close_.maybe_invoke() ||
ws_.paused_rd_.maybe_invoke() ||
ws_.paused_ping_.maybe_invoke())
{
BOOST_ASSERT(ws_.wr_block_);
BOOST_ASSERT(ws_.wr_block_.is_locked());
goto do_suspend;
}
ws_.wr_block_ = tok_;
ws_.wr_block_.lock(this);
}
else
{
@@ -559,8 +552,7 @@ operator()(
//--------------------------------------------------------------------------
upcall:
BOOST_ASSERT(ws_.wr_block_ == tok_);
ws_.wr_block_.reset();
ws_.wr_block_.unlock(this);
ws_.paused_close_.maybe_invoke() ||
ws_.paused_rd_.maybe_invoke() ||
ws_.paused_ping_.maybe_invoke();