passenger 5.0.0.beta2 → 5.0.0.beta3

data/ext/apache2/Hooks.cpp

@@ -1224,6 +1224,7 @@ public:
 			.set    ("default_ruby", serverConfig.defaultRuby)
 			.setInt ("max_pool_size", serverConfig.maxPoolSize)
 			.setInt ("pool_idle_time", serverConfig.poolIdleTime)
+			.setInt ("response_buffer_high_watermark", serverConfig.responseBufferHighWatermark)
 			.setInt ("stat_throttle_rate", serverConfig.statThrottleRate)
 			.set    ("analytics_log_user", serverConfig.analyticsLogUser)
 			.set    ("analytics_log_group", serverConfig.analyticsLogGroup)

data/ext/common/Constants.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2010-2013 Phusion
+ *  Copyright (c) 2010-2015 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -78,6 +78,8 @@
 
 	#define DEFAULT_PYTHON "python"
 
+	#define DEFAULT_RESPONSE_BUFFER_HIGH_WATERMARK 134217728
+
 	#define DEFAULT_RUBY "ruby"
 
 	#define DEFAULT_SPAWN_METHOD "smart"
@@ -110,7 +112,7 @@
 
 	#define NGINX_DOC_URL "https://www.phusionpassenger.com/documentation/Users%20guide%20Nginx.html"
 
-	#define PASSENGER_VERSION "5.0.0.beta2"
+	#define PASSENGER_VERSION "5.0.0.beta3"
 
 	#define POOL_HELPER_THREAD_STACK_SIZE 262144
 

data/ext/common/Constants.h.erb

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2010-2013 Phusion
+ *  Copyright (c) 2010-2015 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *

data/ext/common/DataStructures/LString.h

@@ -117,6 +117,16 @@ psg_lstr_append_part(LString *str, LString::Part *part) {
 	part->next = NULL;
 }
 
+inline void
+psg_lstr_append_part_from_another_lstr(LString *str, psg_pool_t *pool, const LString::Part *part) {
+	LString::Part *copy = (LString::Part *) psg_palloc(pool, sizeof(LString::Part));
+	*copy = *part;
+	if (part->mbuf_block != NULL) {
+		mbuf_block_ref(part->mbuf_block);
+	}
+	psg_lstr_append_part(str, copy);
+}
+
 inline void
 psg_lstr_append(LString *str, psg_pool_t *pool, const MemoryKit::mbuf &buffer,
 	const char *data, unsigned int size)

data/ext/common/ServerKit/Channel.h

@@ -133,7 +133,7 @@ using namespace boost;
  *
  *             ...process buffer....
  *
- *             return Channel::Result(bytesProcessed, acceptFurtherData);
+ *             return Channel::Result(bytesProcessed, !acceptFurtherData);
  *         } else if (errcode == 0) {
  *             // EOF reached. Result doesn't matter in this case.
  *             return Channel::Result(0, false);

data/ext/common/ServerKit/Context.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2014 Phusion
+ *  Copyright (c) 2014-2015 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -33,6 +33,7 @@
 #include <Constants.h>
 #include <Utils/StrIntUtils.h>
 #include <Utils/json.h>
+#include <Utils/JsonUtils.h>
 
 namespace Passenger {
 namespace ServerKit {
@@ -61,26 +62,6 @@ private:
 		MemoryKit::mbuf_pool_init(&mbuf_pool);
 	}
 
-	string formatFloat(double val) const {
-		char buf[64];
-		int size = snprintf(buf, sizeof(buf), "%.1f", val);
-		return string(buf, size);
-	}
-
-	Json::Value
-	byteSizeToJson(size_t size) const {
-		Json::Value doc;
-		doc["bytes"] = (Json::UInt64) size;
-		if (size < 1024) {
-			doc["human_readable"] = toString(size) + " bytes";
-		} else if (size < 1024 * 1024) {
-			doc["human_readable"] = formatFloat(size / 1024.0) + " KB";
-		} else {
-			doc["human_readable"] = formatFloat(size / 1024.0 / 1024.0) + " MB";
-		}
-		return doc;
-	}
-
 public:
 	SafeLibevPtr libev;
 	struct MemoryKit::mbuf_pool mbuf_pool;

data/ext/common/ServerKit/CookieUtils.h

@@ -0,0 +1,246 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2014 Phusion
+ *
+ *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in
+ *  all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *  THE SOFTWARE.
+ */
+#ifndef _PASSENGER_SERVER_KIT_COOKIE_UTILS_H_
+#define _PASSENGER_SERVER_KIT_COOKIE_UTILS_H_
+
+#include <cstring>
+#include <cassert>
+#include <MemoryKit/palloc.h>
+#include <DataStructures/LString.h>
+
+namespace Passenger {
+namespace ServerKit {
+
+
+inline bool findCookieNameValueSeparator(const LString::Part *part, size_t index,
+	const LString::Part **separatorPart, size_t *separatorIndex);
+inline bool findCookieEnd(const LString::Part *separatorPart, size_t separatorIndex,
+	const LString::Part **endPart, size_t *endIndex);
+inline bool matchCookieName(psg_pool_t *pool, const LString::Part *part, size_t index,
+	const LString::Part *separatorPart, size_t separatorIndex,
+	const LString *name);
+inline LString *extractCookieValue(psg_pool_t *pool,
+	const LString::Part *separatorPart, size_t separatorIndex,
+	const LString::Part *endPart, size_t endIndex);
+
+
+/**
+ * Given the value of an HTTP cookie header, returns the value of the cookie
+ * of the given name, or NULL if not found.
+ */
+inline LString *
+findCookie(psg_pool_t *pool, const LString *cookieHeaderValue, const LString *name) {
+	const LString::Part *part = cookieHeaderValue->start;
+	const LString::Part *separatorPart, *endPart;
+	size_t index = 0, separatorIndex, endIndex;
+	bool done = part == NULL;
+	LString *result = NULL;
+
+	while (!done) {
+		if (findCookieNameValueSeparator(part, index, &separatorPart, &separatorIndex)) {
+			if (!findCookieEnd(separatorPart, separatorIndex, &endPart, &endIndex)) {
+				done = true;
+			} else if (matchCookieName(pool, part, index, separatorPart, separatorIndex, name)) {
+				result = extractCookieValue(pool, separatorPart, separatorIndex, endPart, endIndex);
+				done   = true;
+			} else {
+				part  = endPart;
+				index = endIndex;
+				done  = endIndex >= endPart->size;
+			}
+		} else {
+			done = true;
+		}
+	}
+
+	return result;
+}
+
+inline bool
+findCookieNameValueSeparator(const LString::Part *part, size_t index,
+	const LString::Part **separatorPart, size_t *separatorIndex)
+{
+	const char *pos;
+	bool result = false;
+	bool done = part == NULL;
+
+	while (!done) {
+		pos = (const char *) memchr(part->data + index, '=', part->size - index);
+		if (pos == NULL) {
+			part  = part->next;
+			index = 0;
+			done  = part == NULL;
+		} else {
+			*separatorPart  = part;
+			*separatorIndex = pos - part->data;
+			result = true;
+			done   = true;
+		}
+	}
+
+	return result;
+}
+
+inline bool
+findCookieEnd(const LString::Part *separatorPart, size_t separatorIndex,
+	const LString::Part **endPart, size_t *endIndex)
+{
+	const LString::Part *part = separatorPart;
+	size_t index = separatorIndex;
+	const char *pos;
+	bool result = false;
+	bool done = part == NULL;
+
+	while (!done) {
+		pos = (const char *) memchr(part->data + index, ';', part->size - index);
+		if (pos == NULL) {
+			if (part->next == NULL) {
+				// Semicolon not found in entire LString. Return end-of-LString
+				// as cookie end.
+				*endPart = part;
+				*endIndex = part->size;
+				result = true;
+				done   = true;
+			} else {
+				part  = part->next;
+				index = 0;
+				done  = part == NULL;
+			}
+		} else {
+			// Semicolon found.
+			*endPart = part;
+			*endIndex = pos - part->data;
+			result = true;
+			done   = true;
+		}
+	}
+
+	return result;
+}
+
+inline void
+_matchCookieName_skipWhitespace(LString *str) {
+	LString::Part *part = str->start;
+	size_t pos = 0;
+	bool done = false;
+
+	while (!done) {
+		while (part->data[pos] == ' ' || part->data[pos] == ';') {
+			pos++;
+		}
+
+		if (pos == part->size) {
+			str->start = part->next;
+			str->size -= part->size;
+			part = part->next;
+			if (part == NULL) {
+				assert(str->size == 0);
+				done = true;
+				str->end = NULL;
+			}
+		} else {
+			part->data += pos;
+			part->size -= pos;
+			str->size  -= pos;
+			done = true;
+		}
+	}
+}
+
+inline bool
+matchCookieName(psg_pool_t *pool, const LString::Part *part, size_t index,
+	const LString::Part *separatorPart, size_t separatorIndex,
+	const LString *name)
+{
+	LString *str = (LString *) psg_palloc(pool, sizeof(LString));
+	psg_lstr_init(str);
+
+	if (part == separatorPart) {
+		assert(index < separatorIndex);
+		psg_lstr_append(str, pool,
+			part->data + index,
+			separatorIndex - index);
+	} else {
+		psg_lstr_append(str, pool,
+			part->data + index,
+			part->size - index);
+
+		part = part->next;
+		while (part != separatorPart) {
+			psg_lstr_append(str, pool, part->data, part->size);
+			part = part->next;
+		}
+
+		if (separatorIndex != 0) {
+			psg_lstr_append(str, pool, separatorPart->data, separatorIndex);
+		}
+	}
+
+	_matchCookieName_skipWhitespace(str);
+
+	bool result = psg_lstr_cmp(str, name);
+	psg_lstr_deinit(str);
+	return result;
+}
+
+inline LString *
+extractCookieValue(psg_pool_t *pool,
+	const LString::Part *separatorPart, size_t separatorIndex,
+	const LString::Part *endPart, size_t endIndex)
+{
+	LString *str = (LString *) psg_palloc(pool, sizeof(LString));
+	psg_lstr_init(str);
+
+	if (separatorPart == endPart) {
+		assert(separatorIndex < endIndex);
+		psg_lstr_append(str, pool,
+			separatorPart->data + separatorIndex + 1,
+			endIndex - separatorIndex - 1);
+	} else {
+		if (separatorIndex < separatorPart->size - 1) {
+			psg_lstr_append(str, pool,
+				separatorPart->data + separatorIndex + 1,
+				separatorPart->size - separatorIndex - 1);
+		}
+
+		const LString::Part *part = separatorPart->next;
+		while (part != endPart) {
+			psg_lstr_append(str, pool, part->data, part->size);
+			part = part->next;
+		}
+
+		if (endIndex != 0) {
+			psg_lstr_append(str, pool, endPart->data, endIndex);
+		}
+	}
+
+	return str;
+}
+
+
+} // namespace ServerKit
+} // namespace Passenger
+
+#endif /* _PASSENGER_SERVER_KIT_COOKIE_UTILS_H_ */

data/ext/common/ServerKit/FdSourceChannel.h

@@ -207,6 +207,16 @@ public:
 		return watcher.fd;
 	}
 
+	OXT_FORCE_INLINE
+	State getState() const {
+		return Channel::getState();
+	}
+
+	OXT_FORCE_INLINE
+	bool isStarted() const {
+		return Channel::isStarted();
+	}
+
 	OXT_FORCE_INLINE
 	void setDataCallback(DataCallback callback) {
 		Channel::dataCallback = callback;

data/ext/common/ServerKit/FileBufferedChannel.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2014 Phusion
+ *  Copyright (c) 2014-2015 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -43,6 +43,8 @@
 #include <ServerKit/Context.h>
 #include <ServerKit/Errors.h>
 #include <ServerKit/Channel.h>
+#include <Utils/json.h>
+#include <Utils/JsonUtils.h>
 
 namespace Passenger {
 namespace ServerKit {
@@ -187,8 +189,10 @@ public:
 	typedef Channel::DataCallback DataCallback;
 	typedef void (*Callback)(FileBufferedChannel *channel);
 
-	// `buffered` is 25-bit. This is 2^25-1, or 32 MB.
-	static const unsigned int MAX_MEMORY_BUFFERING = 33554431;
+	// 2^32-1 bytes.
+	static const unsigned int MAX_MEMORY_BUFFERING = 4294967295u;
+	// `nbuffers` is 27-bit. This is 2^27-1.
+	static const unsigned int MAX_BUFFERS = 134217727;
 
 
 private:
@@ -197,6 +201,13 @@ private:
 		SafeLibevPtr libev;
 		eio_req *req;
 		boost::atomic<bool> canceled;
+		/**
+		 * Synchronizes access to `req`. Because all I/O callbacks call
+		 * `eioFinished()`, this mutex blocks callbacks until the main
+		 * thread is done assigning `req`.
+		 * See https://github.com/phusion/passenger/issues/1326
+		 */
+		boost::mutex syncher;
 
 		eio_ssize_t result;
 		int errcode;
@@ -213,6 +224,7 @@ private:
 		virtual ~IOContext() { }
 
 		void cancel() {
+			boost::lock_guard<boost::mutex> l(syncher);
 			if (req != NULL) {
 				eio_cancel(req);
 			}
@@ -225,6 +237,7 @@ private:
 		}
 
 		void eioFinished() {
+			boost::lock_guard<boost::mutex> l(syncher);
 			result = req->result;
 			errcode = req->errorno;
 			req = NULL;
@@ -337,10 +350,10 @@ private:
 	};
 
 	FileBufferedChannelConfig *config;
-	Mode mode;
-	ReaderState readerState;
+	Mode mode: 2;
+	ReaderState readerState: 3;
 	/** Number of buffers in `firstBuffer` + `moreBuffers`. */
-	boost::uint16_t nbuffers;
+	unsigned int nbuffers: 27;
 
 	/**
 	 * If an error is encountered, its details are stored here.
@@ -390,6 +403,7 @@ private:
 
 	void pushBuffer(const MemoryKit::mbuf &buffer) {
 		assert(bytesBuffered + buffer.size() <= MAX_MEMORY_BUFFERING);
+		assert(nbuffers < MAX_BUFFERS);
 		if (nbuffers == 0) {
 			firstBuffer = buffer;
 		} else {
@@ -606,7 +620,6 @@ private:
 	void channelHasBecomeIdle() {
 		FBC_DEBUG("Reader: underlying channel has become idle");
 		verifyInvariants();
-		//readerState = RS_INACTIVE;
 		readNext();
 	}
 
@@ -631,9 +644,9 @@ private:
 	};
 
 	void readNextChunkFromFile() {
+		assert(inFileMode->written > 0);
 		size_t size = std::min<size_t>(inFileMode->written,
-			ctx->mbuf_pool.mbuf_block_chunk_size -
-			ctx->mbuf_pool.mbuf_block_offset);
+			mbuf_pool_data_size(&ctx->mbuf_pool));
 		FBC_DEBUG("Reader: reading next chunk from file");
 		verifyInvariants();
 		ReadContext *readContext = new ReadContext(this);
@@ -641,16 +654,34 @@ private:
 		readContext->inFileMode = inFileMode;
 		readerState = RS_READING_FROM_FILE;
 		inFileMode->readRequest = readContext;
+		boost::unique_lock<boost::mutex> l(readContext->syncher);
 		readContext->req = eio_read(inFileMode->fd, readContext->buffer.start,
 			size, inFileMode->readOffset, 0, _nextChunkDoneReading, readContext);
+		l.unlock();
 		verifyInvariants();
 	}
 
+	// Since a ReadContext contains an mbuf, we may only destroy it
+	// in the event loop thread.
+	static void destroyReadContext(ReadContext *readContext) {
+		if (readContext->libev->onEventLoopThread()) {
+			destroyReadContext_onEventLoopThread(readContext);
+		} else {
+			readContext->libev->runLater(boost::bind(
+				destroyReadContext_onEventLoopThread,
+				readContext));
+		}
+	}
+
+	static void destroyReadContext_onEventLoopThread(ReadContext *readContext) {
+		delete readContext;
+	}
+
 	static int _nextChunkDoneReading(eio_req *req) {
 		ReadContext *readContext = (ReadContext *) req->data;
 		readContext->eioFinished();
 		if (readContext->isCanceled()) {
-			delete readContext;
+			destroyReadContext(readContext);
 			return 0;
 		}
 
@@ -666,7 +697,7 @@ private:
 
 	static void _nextChunkDoneReading_onEventLoopThread(ReadContext *readContext) {
 		if (readContext->isCanceled()) {
-			delete readContext;
+			destroyReadContext(readContext);
 			return;
 		}
 
@@ -683,7 +714,7 @@ private:
 		int fd = readContext->result;
 		int errcode = readContext->errcode;
 		MemoryKit::mbuf buffer(boost::move(readContext->buffer));
-		delete readContext;
+		destroyReadContext(readContext);
 		inFileMode->readRequest = NULL;
 
 		if (fd != -1) {
@@ -802,6 +833,7 @@ private:
 		inFileMode->writerState = WS_CREATING_FILE;
 		inFileMode->writerRequest = fcContext;
 
+		boost::lock_guard<boost::mutex> l(fcContext->syncher);
 		if (config->delayInFileModeSwitching == 0) {
 			FBC_DEBUG("Writer: creating file " << fcContext->path);
 			fcContext->req = eio_open(fcContext->path.c_str(),
@@ -845,6 +877,7 @@ private:
 	}
 
 	void bufferFileDoneDelaying(FileCreationContext *fcContext) {
+		boost::lock_guard<boost::mutex> l(fcContext->syncher);
 		FBC_DEBUG("Writer: done delaying in-file mode switching. "
 			"Creating file: " << fcContext->path);
 		fcContext->req = eio_open(fcContext->path.c_str(),
@@ -981,19 +1014,37 @@ private:
 
 		inFileMode->writerState = WS_MOVING;
 		inFileMode->writerRequest = moveContext;
+		boost::unique_lock<boost::mutex> l(moveContext->syncher);
 		moveContext->req = eio_write(inFileMode->fd,
 			moveContext->buffer.start,
 			moveContext->buffer.size(),
 			inFileMode->readOffset + inFileMode->written,
 			0, _bufferWrittenToFile, moveContext);
+		l.unlock();
 		verifyInvariants();
 	}
 
+	// Since a MoveContext contains an mbuf, we may only destroy it
+	// in the event loop thread.
+	static void destroyMoveContext(MoveContext *moveContext) {
+		if (moveContext->libev->onEventLoopThread()) {
+			destroyMoveContext_onEventLoopThread(moveContext);
+		} else {
+			moveContext->libev->runLater(boost::bind(
+				destroyMoveContext_onEventLoopThread,
+				moveContext));
+		}
+	}
+
+	static void destroyMoveContext_onEventLoopThread(MoveContext *moveContext) {
+		delete moveContext;
+	}
+
 	static int _bufferWrittenToFile(eio_req *req) {
 		MoveContext *moveContext = static_cast<MoveContext *>(req->data);
 		moveContext->eioFinished();
 		if (moveContext->isCanceled()) {
-			delete moveContext;
+			destroyMoveContext(moveContext);
 			return 0;
 		}
 
@@ -1009,7 +1060,7 @@ private:
 
 	static void _bufferWrittenToFile_onEventLoopThread(MoveContext *moveContext) {
 		if (moveContext->isCanceled()) {
-			delete moveContext;
+			destroyMoveContext(moveContext);
 			return;
 		}
 
@@ -1040,27 +1091,29 @@ private:
 				if (generation != this->generation || mode >= ERROR) {
 					// buffersFlushedCallback deinitialized this object, or callback
 					// called a method that encountered an error.
-					delete moveContext;
+					destroyMoveContext(moveContext);
 					return;
 				}
 
 				inFileMode->writerRequest = NULL;
-				delete moveContext;
+				destroyMoveContext(moveContext);
 				moveNextBufferToFile();
 			} else {
 				FBC_DEBUG("Writer: move incomplete, proceeding " <<
 					"with writing rest of buffer");
+				boost::unique_lock<boost::mutex> l(moveContext->syncher);
 				moveContext->req = eio_write(inFileMode->fd,
 					moveContext->buffer.start + moveContext->written,
 					moveContext->buffer.size() - moveContext->written,
 					inFileMode->readOffset + inFileMode->written,
 					0, _bufferWrittenToFile, moveContext);
+				l.unlock();
 				verifyInvariants();
 			}
 		} else {
 			FBC_DEBUG("Writer: file write failed");
 			int errcode = moveContext->errcode;
-			delete moveContext;
+			destroyMoveContext(moveContext);
 			inFileMode->writerRequest = NULL;
 			inFileMode->writerState = WS_TERMINATED;
 			setError(errcode, __FILE__, __LINE__);
@@ -1141,6 +1194,42 @@ private:
 		inFileMode->writerState = WS_INACTIVE;
 	}
 
+	const char *getReaderStateString() const {
+		switch (readerState) {
+		case RS_INACTIVE:
+			return "RS_INACTIVE";
+		case RS_FEEDING:
+			return "RS_FEEDING";
+		case RS_FEEDING_EOF:
+			return "RS_FEEDING_EOF";
+		case RS_WAITING_FOR_CHANNEL_IDLE:
+			return "RS_WAITING_FOR_CHANNEL_IDLE";
+		case RS_READING_FROM_FILE:
+			return "RS_READING_FROM_FILE";
+		case RS_TERMINATED:
+			return "RS_TERMINATED";
+		default:
+			P_BUG("Unknown readerState");
+			return NULL;
+		}
+	}
+
+	const char *getWriterStateString() const {
+		switch (inFileMode->writerState) {
+		case WS_INACTIVE:
+			return "WS_INACTIVE";
+		case WS_CREATING_FILE:
+			return "WS_CREATING_FILE";
+		case WS_MOVING:
+			return "WS_MOVING";
+		case WS_TERMINATED:
+			return "WS_TERMINATED";
+		default:
+			P_BUG("Unknown writerState");
+			return NULL;
+		}
+	}
+
 	void verifyInvariants() const {
 		#ifndef NDEBUG
 			if (mode >= ERROR) {
@@ -1353,10 +1442,32 @@ public:
 		return inFileMode->writerState;
 	}
 
+	/**
+	 * Returns the number of bytes buffered in memory.
+	 */
 	unsigned int getBytesBuffered() const {
 		return bytesBuffered;
 	}
 
+	/**
+	 * Returns the number of bytes that are buffered on disk
+	 * and have not yet been read.
+	 */
+	boost::uint64_t getBytesBufferedOnDisk() const {
+		if (mode == IN_FILE_MODE && inFileMode->written >= 0) {
+			return inFileMode->written;
+		} else {
+			return 0;
+		}
+	}
+
+	/**
+	 * Returns the total bytes buffered, both in-memory and on disk.
+	 */
+	boost::uint64_t getTotalBytesBuffered() const {
+		return bytesBuffered + getBytesBufferedOnDisk();
+	}
+
 	bool ended() const {
 		return (hasBuffers() && peekLastBuffer().empty())
 			|| mode >= ERROR || Channel::ended();
@@ -1370,14 +1481,27 @@ public:
 		return bytesBuffered >= config->threshold;
 	}
 
+	OXT_FORCE_INLINE
 	void setDataCallback(DataCallback callback) {
 		Channel::dataCallback = callback;
 	}
 
+	OXT_FORCE_INLINE
+	Callback getBuffersFlushedCallback() const {
+		return buffersFlushedCallback;
+	}
+
+	OXT_FORCE_INLINE
 	void setBuffersFlushedCallback(Callback callback) {
 		buffersFlushedCallback = callback;
 	}
 
+	OXT_FORCE_INLINE
+	Callback getDataFlushedCallback() const {
+		return dataFlushedCallback;
+	}
+
+	OXT_FORCE_INLINE
 	void setDataFlushedCallback(Callback callback) {
 		dataFlushedCallback = callback;
 	}
@@ -1387,9 +1511,41 @@ public:
 		return Channel::hooks;
 	}
 
+	OXT_FORCE_INLINE
 	void setHooks(Hooks *hooks) {
 		Channel::hooks = hooks;
 	}
+
+	Json::Value inspectAsJson() const {
+		Json::Value doc;
+
+		switch (mode) {
+		case IN_MEMORY_MODE:
+			doc["mode"] = "IN_MEMORY_MODE";
+			break;
+		case IN_FILE_MODE:
+			doc["mode"] = "IN_FILE_MODE";
+			doc["writer_state"] = getWriterStateString();
+			doc["read_offset"] = byteSizeToJson(inFileMode->readOffset);
+			doc["written"] = signedByteSizeToJson(inFileMode->written);
+			break;
+		case ERROR:
+			doc["mode"] = "ERROR";
+			break;
+		case ERROR_WAITING:
+			doc["mode"] = "ERROR_WAITING";
+			break;
+		default:
+			break;
+		}
+
+		doc["reader_state"] = getReaderStateString();
+		doc["nbuffers"] = nbuffers;
+		doc["bytes_buffered"] = byteSizeToJson(getBytesBuffered());
+		doc["callback_in_progress"] = !acceptingInput();
+
+		return doc;
+	}
 };