proxygen: folly::IOBuf Class Reference

#include <IOBuf.h>

Classes
struct	DeleterBase

struct	HeapFullStorage

struct	HeapPrefix

struct	HeapStorage

struct	InternalConstructor

class	Iterator

struct	SharedInfo

struct	UniquePtrDeleter

Public Types
enum	CreateOp { CREATE }

enum	WrapBufferOp { WRAP_BUFFER }

enum	TakeOwnershipOp { TAKE_OWNERSHIP }

enum	CopyBufferOp { COPY_BUFFER }

typedef ByteRange	value_type

typedef Iterator	iterator

typedef Iterator	const_iterator

typedef void(*	FreeFunction) (void buf, void userData)

Public Member Functions
	IOBuf (CreateOp, std::size_t capacity)

	IOBuf (TakeOwnershipOp op, void buf, std::size_t capacity, FreeFunction freeFn=nullptr, void userData=nullptr, bool freeOnError=true)

	IOBuf (TakeOwnershipOp, void buf, std::size_t capacity, std::size_t length, FreeFunction freeFn=nullptr, void userData=nullptr, bool freeOnError=true)

	IOBuf (WrapBufferOp op, const void *buf, std::size_t capacity) noexcept

	IOBuf (WrapBufferOp op, ByteRange br) noexcept

	IOBuf (CopyBufferOp op, const void *buf, std::size_t size, std::size_t headroom=0, std::size_t minTailroom=0)

	IOBuf (CopyBufferOp op, ByteRange br, std::size_t headroom=0, std::size_t minTailroom=0)

	IOBuf (CopyBufferOp op, const std::string &buf, std::size_t headroom=0, std::size_t minTailroom=0)

	~IOBuf ()

bool	empty () const

const uint8_t *	data () const

uint8_t *	writableData ()

const uint8_t *	tail () const

uint8_t *	writableTail ()

std::size_t	length () const

std::size_t	headroom () const

std::size_t	tailroom () const

const uint8_t *	buffer () const

uint8_t *	writableBuffer ()

const uint8_t *	bufferEnd () const

std::size_t	capacity () const

IOBuf *	next ()

const IOBuf *	next () const

IOBuf *	prev ()

const IOBuf *	prev () const

void	advance (std::size_t amount)

void	retreat (std::size_t amount)

void	prepend (std::size_t amount)

void	append (std::size_t amount)

void	trimStart (std::size_t amount)

void	trimEnd (std::size_t amount)

void	clear ()

void	reserve (std::size_t minHeadroom, std::size_t minTailroom)

bool	isChained () const

size_t	countChainElements () const

std::size_t	computeChainDataLength () const

void	prependChain (std::unique_ptr< IOBuf > &&iobuf)

void	appendChain (std::unique_ptr< IOBuf > &&iobuf)

std::unique_ptr< IOBuf >	unlink ()

std::unique_ptr< IOBuf >	pop ()

std::unique_ptr< IOBuf >	separateChain (IOBuf head, IOBuf tail)

bool	isShared () const

bool	isManaged () const

bool	isManagedOne () const

bool	isSharedOne () const

void	unshare ()

void	unshareOne ()

void	markExternallyShared ()

void	markExternallySharedOne ()

void	makeManaged ()

void	makeManagedOne ()

ByteRange	coalesce ()

ByteRange	coalesceWithHeadroomTailroom (std::size_t newHeadroom, std::size_t newTailroom)

void	gather (std::size_t maxLength)

std::unique_ptr< IOBuf >	clone () const

IOBuf	cloneAsValue () const

std::unique_ptr< IOBuf >	cloneOne () const

IOBuf	cloneOneAsValue () const

std::unique_ptr< IOBuf >	cloneCoalesced () const

std::unique_ptr< IOBuf >	cloneCoalescedWithHeadroomTailroom (std::size_t newHeadroom, std::size_t newTailroom) const

IOBuf	cloneCoalescedAsValue () const

IOBuf	cloneCoalescedAsValueWithHeadroomTailroom (std::size_t newHeadroom, std::size_t newTailroom) const

void	cloneInto (IOBuf &other) const

void	cloneOneInto (IOBuf &other) const

folly::fbvector< struct iovec >	getIov () const

void	appendToIov (folly::fbvector< struct iovec > *iov) const

size_t	fillIov (struct iovec *iov, size_t len) const

void *	operator new (size_t size)

void *	operator new (size_t size, void *ptr)

void	operator delete (void *ptr)

void	operator delete (void ptr, void placement)

fbstring	moveToFbString ()

Iterator	cbegin () const

Iterator	cend () const

Iterator	begin () const

Iterator	end () const

	IOBuf () noexcept

	IOBuf (IOBuf &&other) noexcept

IOBuf &	operator= (IOBuf &&other) noexcept

	IOBuf (const IOBuf &other)

IOBuf &	operator= (const IOBuf &other)

Static Public Member Functions
static std::unique_ptr< IOBuf >	create (std::size_t capacity)

static std::unique_ptr< IOBuf >	createCombined (std::size_t capacity)

static std::unique_ptr< IOBuf >	createSeparate (std::size_t capacity)

static std::unique_ptr< IOBuf >	createChain (size_t totalCapacity, std::size_t maxBufCapacity)

static std::unique_ptr< IOBuf >	takeOwnership (void buf, std::size_t capacity, FreeFunction freeFn=nullptr, void userData=nullptr, bool freeOnError=true)

static std::unique_ptr< IOBuf >	takeOwnership (void buf, std::size_t capacity, std::size_t length, FreeFunction freeFn=nullptr, void userData=nullptr, bool freeOnError=true)

template<class UniquePtr >
static std::enable_if< detail::IsUniquePtrToSL< UniquePtr >::value, std::unique_ptr< IOBuf > >::type	takeOwnership (UniquePtr &&buf, size_t count=1)

static std::unique_ptr< IOBuf >	wrapBuffer (const void *buf, std::size_t capacity)

static std::unique_ptr< IOBuf >	wrapBuffer (ByteRange br)

static IOBuf	wrapBufferAsValue (const void *buf, std::size_t capacity) noexcept

static IOBuf	wrapBufferAsValue (ByteRange br) noexcept

static std::unique_ptr< IOBuf >	copyBuffer (const void *buf, std::size_t size, std::size_t headroom=0, std::size_t minTailroom=0)

static std::unique_ptr< IOBuf >	copyBuffer (ByteRange br, std::size_t headroom=0, std::size_t minTailroom=0)

static std::unique_ptr< IOBuf >	copyBuffer (const std::string &buf, std::size_t headroom=0, std::size_t minTailroom=0)

static std::unique_ptr< IOBuf >	maybeCopyBuffer (const std::string &buf, std::size_t headroom=0, std::size_t minTailroom=0)

static void	destroy (std::unique_ptr< IOBuf > &&data)

static std::unique_ptr< IOBuf >	wrapIov (const iovec *vec, size_t count)

static std::unique_ptr< IOBuf >	takeOwnershipIov (const iovec vec, size_t count, FreeFunction freeFn=nullptr, void userData=nullptr, bool freeOnError=true)

Private Types
enum	FlagsEnum : uintptr_t { kFlagFreeSharedInfo = 0x1, kFlagMaybeShared = 0x2, kFlagMask = kFlagFreeSharedInfo \| kFlagMaybeShared }

Private Member Functions
	IOBuf (InternalConstructor, uintptr_t flagsAndSharedInfo, uint8_t buf, std::size_t capacity, uint8_t data, std::size_t length) noexcept

void	unshareOneSlow ()

void	unshareChained ()

void	makeManagedChained ()

void	coalesceSlow ()

void	coalesceSlow (size_t maxLength)

void	coalesceAndReallocate (size_t newHeadroom, size_t newLength, IOBuf *end, size_t newTailroom)

void	coalesceAndReallocate (size_t newLength, IOBuf *end)

void	decrementRefcount ()

void	reserveSlow (std::size_t minHeadroom, std::size_t minTailroom)

void	freeExtBuffer ()

SharedInfo *	sharedInfo () const

void	setSharedInfo (SharedInfo *info)

uintptr_t	flags () const

void	setFlags (uintptr_t flags) const

void	clearFlags (uintptr_t flags) const

void	setFlagsAndSharedInfo (uintptr_t flags, SharedInfo *info)

Static Private Member Functions
static size_t	goodExtBufferSize (std::size_t minCapacity)

static void	initExtBuffer (uint8_t buf, size_t mallocSize, SharedInfo infoReturn, std::size_t capacityReturn)

static void	allocExtBuffer (std::size_t minCapacity, uint8_t bufReturn, SharedInfo infoReturn, std::size_t *capacityReturn)

static void	releaseStorage (HeapStorage *storage, uint16_t freeFlags)

static void	freeInternalBuf (void buf, void userData)

static uintptr_t	packFlagsAndSharedInfo (uintptr_t flags, SharedInfo *info)

static void	freeUniquePtrBuffer (void ptr, void userData)

Private Attributes
IOBuf *	next_ {this}

IOBuf *	prev_ {this}

uint8_t *	data_ {nullptr}

uint8_t *	buf_ {nullptr}

std::size_t	length_ {0}

std::size_t	capacity_ {0}

uintptr_t	flagsAndSharedInfo_ {0}

Detailed Description

Definition at line 221 of file IOBuf.h.

Member Typedef Documentation

typedef Iterator folly::IOBuf::const_iterator

Definition at line 232 of file IOBuf.h.

typedef void(* folly::IOBuf::FreeFunction) (void *buf, void *userData)

Definition at line 234 of file IOBuf.h.

typedef Iterator folly::IOBuf::iterator

Definition at line 231 of file IOBuf.h.

typedef ByteRange folly::IOBuf::value_type

Definition at line 230 of file IOBuf.h.

Member Enumeration Documentation

enum folly::IOBuf::CopyBufferOp

Enumerator
COPY_BUFFER

Definition at line 228 of file IOBuf.h.

228 { COPY_BUFFER };

folly::IOBuf::COPY_BUFFER

Definition: IOBuf.h:228

enum folly::IOBuf::CreateOp

Enumerator
CREATE

Definition at line 225 of file IOBuf.h.

225 { CREATE };

folly::IOBuf::CREATE

Definition: IOBuf.h:225

enum folly::IOBuf::FlagsEnum : uintptr_t

private

Enumerator
kFlagFreeSharedInfo
kFlagMaybeShared
kFlagMask

Definition at line 1338 of file IOBuf.h.

                  : uintptr_t {
     // Adding any more flags would not work on 32-bit architectures,
     // as these flags are stashed in the least significant 2 bits of a
     // max-align-aligned pointer.
     kFlagFreeSharedInfo = 0x1,
     kFlagMaybeShared = 0x2,
     kFlagMask = kFlagFreeSharedInfo | kFlagMaybeShared
   };

enum folly::IOBuf::TakeOwnershipOp

Enumerator
TAKE_OWNERSHIP

Definition at line 227 of file IOBuf.h.

227 { TAKE_OWNERSHIP };

folly::IOBuf::TAKE_OWNERSHIP

Definition: IOBuf.h:227

enum folly::IOBuf::WrapBufferOp

Enumerator
WRAP_BUFFER

Definition at line 226 of file IOBuf.h.

226 { WRAP_BUFFER };

folly::IOBuf::WRAP_BUFFER

Definition: IOBuf.h:226

Constructor & Destructor Documentation

folly::IOBuf::IOBuf	(	CreateOp	,
		std::size_t	capacity
	)

Definition at line 195 of file IOBuf.cpp.

References allocExtBuffer(), buf_, capacity_, data_, deadlock::info(), and setSharedInfo().

     : next_(this),
       prev_(this),
       data_(nullptr),
       length_(0),
       flagsAndSharedInfo_(0) {
   SharedInfo* info;
   allocExtBuffer(capacity, &buf_, &info, &capacity_);
   setSharedInfo(info);
   data_ = buf_;
 }

folly::IOBuf::IOBuf	(	TakeOwnershipOp	op,
		void *	buf,
		std::size_t	capacity,
		FreeFunction	freeFn = `nullptr`,
		void *	userData = `nullptr`,
		bool	freeOnError = `true`
	)

inline

Definition at line 313 of file IOBuf.h.

References count, and type.

320 : IOBuf(op, buf, capacity, capacity, freeFn, userData, freeOnError) {}

folly::IOBuf::capacity

std::size_t capacity() const

Definition: IOBuf.h:593

folly::pushmi::operators

Definition: bulk.h:23

folly::IOBuf::IOBuf

IOBuf() noexcept

Definition: IOBuf.cpp:361

folly::IOBuf::IOBuf	(	TakeOwnershipOp	,
		void *	buf,
		std::size_t	capacity,
		std::size_t	length,
		FreeFunction	freeFn = `nullptr`,
		void *	userData = `nullptr`,
		bool	freeOnError = `true`
	)

Definition at line 289 of file IOBuf.cpp.

References setSharedInfo().

     : next_(this),
       prev_(this),
       data_(static_cast<uint8_t*>(buf)),
       buf_(static_cast<uint8_t*>(buf)),
       length_(length),
       capacity_(capacity),
       flagsAndSharedInfo_(
           packFlagsAndSharedInfo(kFlagFreeSharedInfo, nullptr)) {
   try {
     setSharedInfo(new SharedInfo(freeFn, userData));
   } catch (...) {
     takeOwnershipError(freeOnError, buf, freeFn, userData);
     throw;
   }
 }

folly::IOBuf::IOBuf	(	WrapBufferOp	op,
		const void *	buf,
		std::size_t	capacity
	)

noexcept

Definition at line 338 of file IOBuf.cpp.

     : IOBuf(
           InternalConstructor(),
           0,
           // We cast away the const-ness of the buffer here.
           // This is okay since IOBuf users must use unshare() to create a copy
           // of this buffer before writing to the buffer.
           static_cast<uint8_t*>(const_cast<void*>(buf)),
           capacity,
           static_cast<uint8_t*>(const_cast<void*>(buf)),
           capacity) {}

folly::IOBuf::IOBuf	(	WrapBufferOp	op,
		ByteRange	br
	)

noexcept

Definition at line 350 of file IOBuf.cpp.

351 : IOBuf(op, br.data(), br.size()) {}

folly::pushmi::operators

Definition: bulk.h:23

folly::IOBuf::IOBuf

IOBuf() noexcept

Definition: IOBuf.cpp:361

folly::IOBuf::IOBuf	(	CopyBufferOp	op,
		const void *	buf,
		std::size_t	size,
		std::size_t	headroom = `0`,
		std::size_t	minTailroom = `0`
	)

Definition at line 207 of file IOBuf.cpp.

References advance(), append(), and writableData().

     : IOBuf(CREATE, headroom + size + minTailroom) {
   advance(headroom);
   if (size > 0) {
     assert(buf != nullptr);
     memcpy(writableData(), buf, size);
     append(size);
   }
 }

folly::IOBuf::IOBuf	(	CopyBufferOp	op,
		ByteRange	br,
		std::size_t	headroom = `0`,
		std::size_t	minTailroom = `0`
	)

Definition at line 222 of file IOBuf.cpp.

227 : IOBuf(op, br.data(), br.size(), headroom, minTailroom) {}

folly::pushmi::operators

Definition: bulk.h:23

folly::IOBuf::headroom

std::size_t headroom() const

Definition: IOBuf.h:542

folly::IOBuf::IOBuf

IOBuf() noexcept

Definition: IOBuf.cpp:361

folly::IOBuf::IOBuf	(	CopyBufferOp	op,
		const std::string &	buf,
		std::size_t	headroom = `0`,
		std::size_t	minTailroom = `0`
	)

inline

Definition at line 448 of file IOBuf.h.

References string.

453 : IOBuf(op, buf.data(), buf.size(), headroom, minTailroom) {}

folly::pushmi::operators

Definition: bulk.h:23

folly::IOBuf::headroom

std::size_t headroom() const

Definition: IOBuf.h:542

folly::IOBuf::IOBuf

IOBuf() noexcept

Definition: IOBuf.cpp:361

folly::IOBuf::~IOBuf ( )

Destroy this IOBuf.

Deleting an IOBuf will automatically destroy all IOBufs in the chain. (See the comments above regarding the ownership model of IOBuf chains. All subsequent IOBufs in the chain are considered to be owned by the head of the chain. Users should only explicitly delete the head of a chain.)

When each individual IOBuf is destroyed, it will release its reference count on the underlying buffer. If it was the last user of the buffer, the buffer will be freed.

Definition at line 415 of file IOBuf.cpp.

References decrementRefcount(), next_, and unlink().

               {
   // Destroying an IOBuf destroys the entire chain.
   // Users of IOBuf should only explicitly delete the head of any chain.
   // The other elements in the chain will be automatically destroyed.
   while (next_ != this) {
     // Since unlink() returns unique_ptr() and we don't store it,
     // it will automatically delete the unlinked element.
     (void)next_->unlink();
   }
 
   decrementRefcount();
 }

folly::IOBuf::IOBuf ( )

noexcept

Allocate a new null buffer.

This can be used to allocate an empty IOBuf on the stack. It will have no space allocated for it. This is generally useful only to later use move assignment to fill out the IOBuf.

Definition at line 361 of file IOBuf.cpp.

Referenced by cloneOneAsValue(), operator=(), and wrapBufferAsValue().

361 {}

folly::IOBuf::IOBuf ( IOBuf && other )

noexcept

Move constructor and assignment operator.

In general, you should only ever move the head of an IOBuf chain. Internal nodes in an IOBuf chain are owned by the head of the chain, and should not be moved from. (Technically, nothing prevents you from moving a non-head node, but the moved-to node will replace the moved-from node in the chain. This has implications for ownership, since non-head nodes are owned by the chain head. You are then responsible for relinquishing ownership of the moved-to node, and manually deleting the moved-from node.)

With the move assignment operator, the destination of the move should be the head of an IOBuf chain or a solitary IOBuf not part of a chain. If the move destination is part of a chain, all other IOBufs in the chain will be deleted.

Definition at line 363 of file IOBuf.cpp.

References next_, and prev_.

     : data_(other.data_),
       buf_(other.buf_),
       length_(other.length_),
       capacity_(other.capacity_),
       flagsAndSharedInfo_(other.flagsAndSharedInfo_) {
   // Reset other so it is a clean state to be destroyed.
   other.data_ = nullptr;
   other.buf_ = nullptr;
   other.length_ = 0;
   other.capacity_ = 0;
   other.flagsAndSharedInfo_ = 0;
 
   // If other was part of the chain, assume ownership of the rest of its chain.
   // (It's only valid to perform move assignment on the head of a chain.)
   if (other.next_ != &other) {
     next_ = other.next_;
     next_->prev_ = this;
     other.next_ = &other;
 
     prev_ = other.prev_;
     prev_->next_ = this;
     other.prev_ = &other;
   }
 
   // Sanity check to make sure that other is in a valid state to be destroyed.
   DCHECK_EQ(other.prev_, &other);
   DCHECK_EQ(other.next_, &other);
 }

folly::IOBuf::IOBuf ( const IOBuf & other )

Definition at line 393 of file IOBuf.cpp.

References cloneAsValue().

                                {
   *this = other.cloneAsValue();
 }

folly::IOBuf::IOBuf	(	InternalConstructor	,
		uintptr_t	flagsAndSharedInfo,
		uint8_t *	buf,
		std::size_t	capacity,
		uint8_t *	data,
		std::size_t	length
	)

privatenoexcept

Definition at line 397 of file IOBuf.cpp.

References capacity(), data(), and length().

     : next_(this),
       prev_(this),
       data_(data),
       buf_(buf),
       length_(length),
       capacity_(capacity),
       flagsAndSharedInfo_(flagsAndSharedInfo) {
   assert(data >= buf);
   assert(data + length <= buf + capacity);
 }

Member Function Documentation

void folly::IOBuf::advance ( std::size_t amount )

inline

Shift the data forwards in the buffer.

This shifts the data pointer forwards in the buffer to increase the headroom. This is commonly used to increase the headroom in a newly allocated buffer.

The caller is responsible for ensuring that there is sufficient tailroom in the buffer before calling advance().

If there is a non-zero data length, advance() will use memmove() to shift the data forwards in the buffer. In this case, the caller is responsible for making sure the buffer is unshared, so it will not affect other IOBufs that may be sharing the same underlying buffer.

Definition at line 632 of file IOBuf.h.

References data_, and length_.

Referenced by folly::TypedIOBuf< T >::advance(), proxygen::GzipHeaderCodec::encode(), fizz::detail::evpEncrypt(), IOBuf(), and TEST().

                                  {
     // In debug builds, assert if there is a problem.
     assert(amount <= tailroom());
 
     if (length_ > 0) {
       memmove(data_ + amount, data_, length_);
     }
     data_ += amount;
   }

void folly::IOBuf::allocExtBuffer	(	std::size_t	minCapacity,
		uint8_t **	bufReturn,
		SharedInfo **	infoReturn,
		std::size_t *	capacityReturn
	)

staticprivate

Definition at line 927 of file IOBuf.cpp.

References folly::checkedMalloc(), goodExtBufferSize(), initExtBuffer(), and uint8_t.

Referenced by coalesceAndReallocate(), IOBuf(), and unshareOneSlow().

                                {
   size_t mallocSize = goodExtBufferSize(minCapacity);
   uint8_t* buf = static_cast<uint8_t*>(checkedMalloc(mallocSize));
   initExtBuffer(buf, mallocSize, infoReturn, capacityReturn);
   *bufReturn = buf;
 }

void folly::IOBuf::append ( std::size_t amount )

inline

Adjust the tail pointer to include more valid data at the end.

This moves the tail pointer forwards to include more of the available buffer. The caller is responsible for ensuring that there is sufficient tailroom for the new data. The caller is also responsible for populating this section with valid data.

This does not modify any actual data in the buffer.

Definition at line 689 of file IOBuf.h.

References length_.

Referenced by append(), folly::TypedIOBuf< T >::append(), folly::IOBufQueue::append(), BENCHMARK(), folly::gen::detail::consumeBufferPlus(), folly::io::StreamCodec::doUncompress(), proxygen::GzipHeaderCodec::encode(), fizz::detail::evpDecrypt(), fizz::detail::evpEncrypt(), folly::AsyncPipeReader::handlerReady(), IOBuf(), main(), MoveToFbStringTest::makeBuf(), poolGetIOBuf(), proxygen::readFileToIOBuf(), CurlService::CurlClient::sendRequest(), TEST(), and TEST_F().

                                 {
     DCHECK_LE(amount, tailroom());
     length_ += amount;
   }

void folly::IOBuf::appendChain ( std::unique_ptr< IOBuf > && iobuf )

inline

Append another IOBuf chain immediately after this IOBuf.

For example, if there are two IOBuf chains (A, B, C) and (D, E, F), and B->appendChain(D) is called, the (D, E, F) chain will be subsumed and become part of the chain starting at A, which will now look like (A, B, D, E, F, C)

The elements in the specified IOBuf chain will become part of this chain, and will be owned by the head of this chain. When this chain is destroyed, all elements in the supplied chain will also be destroyed.

For this reason, appendChain() only accepts an rvalue-reference to a unique_ptr(), to make it clear that it is taking ownership of the supplied chain. If you have a raw pointer, you can pass in a new temporary unique_ptr around the raw pointer. If you have an existing, non-temporary unique_ptr, you must call std::move(ptr) to make it clear that you are destroying the original pointer.

Definition at line 827 of file IOBuf.h.

References folly::gen::move.

Referenced by TEST(), TEST_F(), and TEST_P().

                                                  {
     // Just use prependChain() on the next element in our chain
     next_->prependChain(std::move(iobuf));
   }

void folly::IOBuf::appendToIov ( folly::fbvector< struct iovec > * iov ) const

Update an existing iovec array with the IOBuf data.

New iovecs will be appended to the existing vector; anything already present in the vector will be left unchanged.

Naturally, the returned iovec data will be invalid if you modify the buffer chain.

Definition at line 1016 of file IOBuf.cpp.

References data(), length(), next(), and folly::fbvector< T, Allocator >::push_back().

Referenced by getIov().

                                                               {
   IOBuf const* p = this;
   do {
     // some code can get confused by empty iovs, so skip them
     if (p->length() > 0) {
       iov->push_back({(void*)p->data(), folly::to<size_t>(p->length())});
     }
     p = p->next();
   } while (p != this);
 }

IOBuf::Iterator folly::IOBuf::begin ( ) const

inline

Definition at line 1684 of file IOBuf.h.

References folly::padded::cbegin().

Referenced by folly::io::StreamCodec::doUncompress().

                                         {
   return cbegin();
 }

const uint8_t* folly::IOBuf::buffer ( ) const

inline

Get the pointer to the start of the buffer.

Note that this is the pointer to the very beginning of the usable buffer, not the start of valid data within the buffer. Use the data() method to get a pointer to the start of the data within the buffer.

Definition at line 562 of file IOBuf.h.

Referenced by folly::TypedIOBuf< T >::buffer(), and TEST().

                                 {
     return buf_;
   }

const uint8_t* folly::IOBuf::bufferEnd ( ) const

inline

Get the pointer to the end of the buffer.

Note that this is the pointer to the very end of the usable buffer, not the end of valid data within the buffer. Use the tail() method to get a pointer to the end of the data within the buffer.

Definition at line 583 of file IOBuf.h.

Referenced by folly::TypedIOBuf< T >::bufferEnd().

                                    {
     return buf_ + capacity_;
   }

std::size_t folly::IOBuf::capacity ( ) const

inline

Get the total size of the buffer.

This returns the total usable length of the buffer. Use the length() method to get the length of the actual valid data in this IOBuf.

Definition at line 593 of file IOBuf.h.

Referenced by BENCHMARK(), folly::TypedIOBuf< T >::capacity(), createCombined(), createSeparate(), folly::AsyncPipeReader::handlerReady(), IOBuf(), moveToFbString(), reserveSlow(), takeOwnership(), TEST(), testAllocSize(), wrapBuffer(), and wrapBufferAsValue().

                              {
     return capacity_;
   }

IOBuf::Iterator folly::IOBuf::cbegin ( ) const

Iteration support: a chain of IOBufs may be iterated through using STL-style iterators over const ByteRanges. Iterators are only invalidated if the IOBuf that they currently point to is removed.

Definition at line 1001 of file IOBuf.cpp.

                                   {
   return Iterator(this, this);
 }

IOBuf::Iterator folly::IOBuf::cend ( ) const

Definition at line 1005 of file IOBuf.cpp.

                                 {
   return Iterator(nullptr, nullptr);
 }

void folly::IOBuf::clear ( )

inline

Clear the buffer.

Postcondition: headroom() == 0, length() == 0, tailroom() == capacity()

Definition at line 728 of file IOBuf.h.

References data_, and length_.

Referenced by folly::TypedIOBuf< T >::clear(), folly::IOBufQueue::clear(), folly::gen::detail::consumeBufferPlus(), moveToFbString(), and TEST().

                {
     data_ = writableBuffer();
     length_ = 0;
   }

void folly::IOBuf::clearFlags ( uintptr_t flags ) const

inlineprivate

Definition at line 1469 of file IOBuf.h.

                                                 {
     DCHECK_EQ(flags & ~kFlagMask, 0u);
     flagsAndSharedInfo_ &= ~flags;
   }

unique_ptr< IOBuf > folly::IOBuf::clone ( ) const

Return a new IOBuf chain sharing the same data as this chain.

The new IOBuf chain will normally point to the same underlying data buffers as the original chain. (The one exception to this is if some of the IOBufs in this chain contain small internal data buffers which cannot be shared.)

Definition at line 527 of file IOBuf.cpp.

References cloneAsValue().

Referenced by BENCHMARK(), HTTP2FramerTest::dataFrameTest(), fizz::server::DualTicketCipher::decrypt(), folly::io::StreamCodec::doUncompress(), ZlibServerFilterTest::exercise_compression(), fizz::HkdfImpl< Hash >::expand(), proxygen::SPDYCodec::failSession(), proxygen::SPDYCodec::failStream(), folly::io::QueueAppender::insert(), UDPAcceptor::onDataAvailable(), proxygen::HTTP1xCodec::onIngress(), proxygen::IOBufPrinter::printChain(), TEST(), and proxygen::SecondaryAuthManager::validateAuthenticator().

                                      {
   return std::make_unique<IOBuf>(cloneAsValue());
 }

IOBuf folly::IOBuf::cloneAsValue ( ) const

Similar to clone(). But returns IOBuf by value rather than heap-allocating it.

Definition at line 546 of file IOBuf.cpp.

References cloneOneAsValue(), current, and next_.

Referenced by BENCHMARK(), clone(), and IOBuf().

                                 {
   auto tmp = cloneOneAsValue();
 
   for (IOBuf* current = next_; current != this; current = current->next_) {
     tmp.prependChain(current->cloneOne());
   }
 
   return tmp;
 }

unique_ptr< IOBuf > folly::IOBuf::cloneCoalesced ( ) const

Return a new unchained IOBuf that may share the same data as this chain.

If the IOBuf chain is not chained then the new IOBuf will point to the same underlying data buffer as the original chain. Otherwise, it will clone and coalesce the IOBuf chain.

The new IOBuf will have at least as much headroom as the first IOBuf in the chain, and at least as much tailroom as the last IOBuf in the chain.

Throws std::bad_alloc on error.

Definition at line 535 of file IOBuf.cpp.

References cloneCoalescedAsValue().

                                               {
   return std::make_unique<IOBuf>(cloneCoalescedAsValue());
 }

IOBuf folly::IOBuf::cloneCoalescedAsValue ( ) const

Similar to cloneCoalesced(). But returns IOBuf by value rather than heap-allocating it.

Definition at line 570 of file IOBuf.cpp.

References cloneCoalescedAsValueWithHeadroomTailroom(), headroom(), prev(), and tailroom().

Referenced by BENCHMARK_RELATIVE(), cloneCoalesced(), folly::io::StreamCodec::doUncompress(), and folly::io::test::TEST_P().

                                          {
   const std::size_t newHeadroom = headroom();
   const std::size_t newTailroom = prev()->tailroom();
   return cloneCoalescedAsValueWithHeadroomTailroom(newHeadroom, newTailroom);
 }

IOBuf folly::IOBuf::cloneCoalescedAsValueWithHeadroomTailroom	(	std::size_t	newHeadroom,
		std::size_t	newTailroom
	)		const

This is similar to the cloneCoalescedAsValue() method, except this allows to set a headroom and tailroom for the new IOBuf.

Definition at line 576 of file IOBuf.cpp.

References cloneOneAsValue(), computeChainDataLength(), CREATE, current, and isChained().

Referenced by cloneCoalescedAsValue(), and cloneCoalescedWithHeadroomTailroom().

                                  {
   if (!isChained()) {
     return cloneOneAsValue();
   }
   // Coalesce into newBuf
   const std::size_t newLength = computeChainDataLength();
   const std::size_t newCapacity = newLength + newHeadroom + newTailroom;
   IOBuf newBuf{CREATE, newCapacity};
   newBuf.advance(newHeadroom);
 
   auto current = this;
   do {
     if (current->length() > 0) {
       DCHECK_NOTNULL(current->data());
       DCHECK_LE(current->length(), newBuf.tailroom());
       memcpy(newBuf.writableTail(), current->data(), current->length());
       newBuf.append(current->length());
     }
     current = current->next();
   } while (current != this);
 
   DCHECK_EQ(newLength, newBuf.length());
   DCHECK_EQ(newHeadroom, newBuf.headroom());
   DCHECK_LE(newTailroom, newBuf.tailroom());
 
   return newBuf;
 }

unique_ptr< IOBuf > folly::IOBuf::cloneCoalescedWithHeadroomTailroom	(	std::size_t	newHeadroom,
		std::size_t	newTailroom
	)		const

This is similar to the cloneCoalesced() method, except this allows to set a headroom and tailroom for the new IOBuf.

Definition at line 539 of file IOBuf.cpp.

References cloneCoalescedAsValueWithHeadroomTailroom().

                                  {
   return std::make_unique<IOBuf>(
       cloneCoalescedAsValueWithHeadroomTailroom(newHeadroom, newTailroom));
 }

void folly::IOBuf::cloneInto ( IOBuf & other ) const

inline

Similar to Clone(). But use other as the head node. Other nodes in the chain (if any) will be allocted on heap.

Definition at line 1213 of file IOBuf.h.

Referenced by BENCHMARK().

                                      {
     other = cloneAsValue();
   }

unique_ptr< IOBuf > folly::IOBuf::cloneOne ( ) const

Return a new IOBuf with the same data as this IOBuf.

The new IOBuf returned will not be part of a chain (even if this IOBuf is part of a larger chain).

Definition at line 531 of file IOBuf.cpp.

References cloneOneAsValue().

Referenced by BENCHMARK(), ZlibServerFilterTest::exercise_compression(), proxygen::HTTP1xCodec::onBody(), proxygen::HTTP1xCodec::onParserError(), and TEST().

                                         {
   return std::make_unique<IOBuf>(cloneOneAsValue());
 }

IOBuf folly::IOBuf::cloneOneAsValue ( ) const

Similar to cloneOne(). But returns IOBuf by value rather than heap-allocating it.

Definition at line 556 of file IOBuf.cpp.

References buf_, capacity_, data_, flagsAndSharedInfo_, deadlock::info(), IOBuf(), kFlagMaybeShared, length_, setFlags(), and sharedInfo().

Referenced by cloneAsValue(), cloneCoalescedAsValueWithHeadroomTailroom(), and cloneOne().

                                    {
   if (SharedInfo* info = sharedInfo()) {
     setFlags(kFlagMaybeShared);
     info->refcount.fetch_add(1, std::memory_order_acq_rel);
   }
   return IOBuf(
       InternalConstructor(),
       flagsAndSharedInfo_,
       buf_,
       capacity_,
       data_,
       length_);
 }

void folly::IOBuf::cloneOneInto ( IOBuf & other ) const

inline

Similar to CloneOne(). But to fill an existing IOBuf instead of a new IOBuf.

Definition at line 1221 of file IOBuf.h.

References folly::test::begin(), folly::padded::cbegin(), folly::padded::cend(), count, folly::test::end(), folly::pushmi::__adl::noexcept(), ptr, and folly::size().

Referenced by BENCHMARK().

                                         {
     other = cloneOneAsValue();
   }

ByteRange folly::IOBuf::coalesce ( )

inline

Coalesce this IOBuf chain into a single buffer.

This method moves all of the data in this IOBuf chain into a single contiguous buffer, if it is not already in one buffer. After coalesce() returns, this IOBuf will be a chain of length one. Other IOBufs in the chain will be automatically deleted.

After coalescing, the IOBuf will have at least as much headroom as the first IOBuf in the chain, and at least as much tailroom as the last IOBuf in the chain.

Throws std::bad_alloc on error. On error the IOBuf chain will be unmodified.

Returns ByteRange that points to the data IOBuf stores.

Definition at line 1095 of file IOBuf.h.

Referenced by BENCHMARK(), folly::io::StreamCodec::doUncompress(), fizz::EncryptedReadRecordLayer::getDecryptedBuf(), wangle::SSLSessionCacheManager::onGetSuccess(), proxygen::IOBufPrinter::printChain(), wangle::StringCodec::read(), HTTPUpstreamTest< SPDY3CodecPair >::readAndLoop(), TEST_F(), folly::AsyncUDPSocket::writeGSO(), and ConnectedWriteUDPClient::writePing().

                        {
     const std::size_t newHeadroom = headroom();
     const std::size_t newTailroom = prev()->tailroom();
     return coalesceWithHeadroomTailroom(newHeadroom, newTailroom);
   }

void folly::IOBuf::coalesceAndReallocate	(	size_t	newHeadroom,
		size_t	newLength,
		IOBuf *	end,
		size_t	newTailroom
	)

private

Definition at line 722 of file IOBuf.cpp.

References allocExtBuffer(), buf_, capacity_, current, data_, decrementRefcount(), isChained(), length_, next_, prev_, separateChain(), setFlagsAndSharedInfo(), and uint8_t.

Referenced by coalesceSlow(), and moveToFbString().

                         {
   std::size_t newCapacity = newLength + newHeadroom + newTailroom;
 
   // Allocate space for the coalesced buffer.
   // We always convert to an external buffer, even if we happened to be an
   // internal buffer before.
   uint8_t* newBuf;
   SharedInfo* newInfo;
   std::size_t actualCapacity;
   allocExtBuffer(newCapacity, &newBuf, &newInfo, &actualCapacity);
 
   // Copy the data into the new buffer
   uint8_t* newData = newBuf + newHeadroom;
   uint8_t* p = newData;
   IOBuf* current = this;
   size_t remaining = newLength;
   do {
     if (current->length_ > 0) {
       assert(current->length_ <= remaining);
       assert(current->data_ != nullptr);
       remaining -= current->length_;
       memcpy(p, current->data_, current->length_);
       p += current->length_;
     }
     current = current->next_;
   } while (current != end);
   assert(remaining == 0);
 
   // Point at the new buffer
   decrementRefcount();
 
   // Make sure kFlagMaybeShared and kFlagFreeSharedInfo are all cleared.
   setFlagsAndSharedInfo(0, newInfo);
 
   capacity_ = actualCapacity;
   buf_ = newBuf;
   data_ = newData;
   length_ = newLength;
 
   // Separate from the rest of our chain.
   // Since we don't store the unique_ptr returned by separateChain(),
   // this will immediately delete the returned subchain.
   if (isChained()) {
     (void)separateChain(next_, current->prev_);
   }
 }

void folly::IOBuf::coalesceAndReallocate	(	size_t	newLength,
		IOBuf *	end
	)

inlineprivate

Definition at line 1391 of file IOBuf.h.

References prev_, tailroom(), uint16_t, and uint8_t.

                                                            {
     coalesceAndReallocate(headroom(), newLength, end, end->prev_->tailroom());
   }

void folly::IOBuf::coalesceSlow ( )

private

Definition at line 677 of file IOBuf.cpp.

References coalesceAndReallocate(), end(), isChained(), length_, and next_.

Referenced by unshareChained().

                          {
   // coalesceSlow() should only be called if we are part of a chain of multiple
   // IOBufs.  The caller should have already verified this.
   DCHECK(isChained());
 
   // Compute the length of the entire chain
   std::size_t newLength = 0;
   IOBuf* end = this;
   do {
     newLength += end->length_;
     end = end->next_;
   } while (end != this);
 
   coalesceAndReallocate(newLength, end);
   // We should be only element left in the chain now
   DCHECK(!isChained());
 }

void folly::IOBuf::coalesceSlow ( size_t maxLength )

private

Definition at line 695 of file IOBuf.cpp.

References coalesceAndReallocate(), end(), isChained(), length_, and next_.

                                          {
   // coalesceSlow() should only be called if we are part of a chain of multiple
   // IOBufs.  The caller should have already verified this.
   DCHECK(isChained());
   DCHECK_LT(length_, maxLength);
 
   // Compute the length of the entire chain
   std::size_t newLength = 0;
   IOBuf* end = this;
   while (true) {
     newLength += end->length_;
     end = end->next_;
     if (newLength >= maxLength) {
       break;
     }
     if (end == this) {
       throw std::overflow_error(
           "attempted to coalesce more data than "
           "available");
     }
   }
 
   coalesceAndReallocate(newLength, end);
   // We should have the requested length now
   DCHECK_GE(length_, maxLength);
 }

ByteRange folly::IOBuf::coalesceWithHeadroomTailroom	(	std::size_t	newHeadroom,
		std::size_t	newTailroom
	)

inline

This is similar to the coalesce() method, except this allows to set a headroom and tailroom after coalescing.

Returns ByteRange that points to the data IOBuf stores.

Definition at line 1107 of file IOBuf.h.

References data_, and length_.

                              {
     if (isChained()) {
       coalesceAndReallocate(
           newHeadroom, computeChainDataLength(), this, newTailroom);
     }
     return ByteRange(data_, length_);
   }

std::size_t folly::IOBuf::computeChainDataLength ( ) const

Get the length of all the data in this IOBuf chain.

Beware that this method has to walk the entire chain.

Definition at line 501 of file IOBuf.cpp.

References current, length_, and next_.

Referenced by MoveToFbStringTest::check(), checkQError(), fizz::test::chunkIOBuf(), cloneCoalescedAsValueWithHeadroomTailroom(), folly::io::Codec::compress(), proxygen::SecondaryAuthManager::createAuthRequest(), proxygen::compress::QMINScheme::decode(), fizz::AsyncFizzBase::deliverAppData(), TestAbortPost< stage >::doAbortTest(), folly::io::StreamCodec::doCompress(), folly::io::StreamCodec::doUncompress(), proxygen::HTTP1xCodec::generateBody(), proxygen::SPDYCodec::generateBody(), proxygen::FlowControlFilter::generateBody(), proxygen::SPDYCodec::generateSynReply(), proxygen::SPDYCodec::generateSynStream(), proxygen::HTTPSession::getCertAuthSettingVal(), folly::io::Codec::getUncompressedLength(), folly::io::RWCursor< access >::insert(), isLowercase(), moveToFbString(), HTTP1xCodecCallback::onBody(), proxygen::FlowControlFilter::onBody(), proxygen::FakeHTTPCodecCallback::onBody(), proxygen::HTTPSession::onBody(), proxygen::HTTPDirectResponseHandler::onHeadersComplete(), proxygen::HTTP1xCodec::onIngress(), proxygen::SPDYCodec::onIngress(), proxygen::HTTPTransaction::onIngressBody(), MockCodecDownstreamTest::onIngressImpl(), proxygen::SPDYCodec::parseIngress(), fizz::test::LocalTransport::receiveData(), proxygen::HPACKCodec::recordCompressedSize(), proxygen::HTTPTransaction::resumeIngress(), proxygen::HTTPSession::runLoopCallback(), proxygen::HTTPTransaction::sendBody(), TEST(), TEST_F(), fizz::test::TEST_F(), folly::io::test::TEST_P(), folly::io::Codec::uncompress(), proxygen::HTTPSession::verifyCertAuthSetting(), wangle::LengthFieldPrepender::write(), proxygen::http2::writeCertificate(), and proxygen::http2::writeCertificateRequest().

                                               {
   std::size_t fullLength = length_;
   for (IOBuf* current = next_; current != this; current = current->next_) {
     fullLength += current->length_;
   }
   return fullLength;
 }

std::unique_ptr< IOBuf > folly::IOBuf::copyBuffer	(	const void *	buf,
		std::size_t	size,
		std::size_t	headroom = `0`,
		std::size_t	minTailroom = `0`
	)

inlinestatic

Convenience function to create a new IOBuf object that copies data from a user-supplied buffer, optionally allocating a given amount of headroom and tailroom.

Definition at line 1587 of file IOBuf.h.

References data, and folly::size().

                            {
   std::size_t capacity = headroom + size + minTailroom;
   std::unique_ptr<IOBuf> buf = create(capacity);
   buf->advance(headroom);
   if (size != 0) {
     memcpy(buf->writableData(), data, size);
   }
   buf->append(size);
   return buf;
 }

static std::unique_ptr<IOBuf> folly::IOBuf::copyBuffer	(	ByteRange	br,
		std::size_t	headroom = `0`,
		std::size_t	minTailroom = `0`
	)

inlinestatic

Definition at line 415 of file IOBuf.h.

References fizz::test::copyBuffer(), folly::Range< Iter >::data(), folly::Range< Iter >::size(), and string.

                                  {
     return copyBuffer(br.data(), br.size(), headroom, minTailroom);
   }

std::unique_ptr< IOBuf > folly::IOBuf::copyBuffer	(	const std::string &	buf,
		std::size_t	headroom = `0`,
		std::size_t	minTailroom = `0`
	)

inlinestatic

Convenience function to create a new IOBuf object that copies data from a user-supplied string, optionally allocating a given amount of headroom and tailroom.

Beware when attempting to invoke this function with a constant string literal and a headroom argument: you will likely end up invoking the version of copyBuffer() above. IOBuf::copyBuffer("hello", 3) will treat the first argument as a const void*, and will invoke the version of copyBuffer() above, with the size argument of 3.

Definition at line 1602 of file IOBuf.h.

References fizz::test::copyBuffer().

                            {
   return copyBuffer(buf.data(), buf.size(), headroom, minTailroom);
 }

size_t folly::IOBuf::countChainElements ( ) const

Get the number of IOBufs in this chain.

Beware that this method has to walk the entire chain. Use isChained() if you just want to check if this IOBuf is part of a chain or not.

Definition at line 493 of file IOBuf.cpp.

References current, and next_.

Referenced by MoveToFbStringTest::check(), fizz::test::chunkIOBuf(), ZlibServerFilterTest::exercise_compression(), getIov(), TEST(), TEST_F(), and fizz::trimBytes().

                                        {
   size_t numElements = 1;
   for (IOBuf* current = next_; current != this; current = current->next_) {
     ++numElements;
   }
   return numElements;
 }

unique_ptr< IOBuf > folly::IOBuf::create ( std::size_t capacity )

static

Allocate a new IOBuf object with the requested capacity.

Returns a new IOBuf object that must be (eventually) deleted by the caller. The returned IOBuf may actually have slightly more capacity than requested.

The data pointer will initially point to the start of the newly allocated buffer, and will have a data length of 0.

Throws std::bad_alloc on error.

Definition at line 229 of file IOBuf.cpp.

References createCombined(), and createSeparate().

                                                   {
   // For smaller-sized buffers, allocate the IOBuf, SharedInfo, and the buffer
   // all with a single allocation.
   //
   // We don't do this for larger buffers since it can be wasteful if the user
   // needs to reallocate the buffer but keeps using the same IOBuf object.
   // In this case we can't free the data space until the IOBuf is also
   // destroyed.  Callers can explicitly call createCombined() or
   // createSeparate() if they know their use case better, and know if they are
   // likely to reallocate the buffer later.
   if (capacity <= kDefaultCombinedBufSize) {
     return createCombined(capacity);
   }
   return createSeparate(capacity);
 }

unique_ptr< IOBuf > folly::IOBuf::createChain	(	size_t	totalCapacity,
		std::size_t	maxBufCapacity
	)

static

Allocate a new IOBuf chain with the requested total capacity, allocating no more than maxBufCapacity to each buffer.

Definition at line 272 of file IOBuf.cpp.

References create(), min, and folly::gen::move.

                               {
   unique_ptr<IOBuf> out =
       create(std::min(totalCapacity, size_t(maxBufCapacity)));
   size_t allocatedCapacity = out->capacity();
 
   while (allocatedCapacity < totalCapacity) {
     unique_ptr<IOBuf> newBuf = create(
         std::min(totalCapacity - allocatedCapacity, size_t(maxBufCapacity)));
     allocatedCapacity += newBuf->capacity();
     out->prependChain(std::move(newBuf));
   }
 
   return out;
 }

unique_ptr< IOBuf > folly::IOBuf::createCombined ( std::size_t capacity )

static

Create a new IOBuf, using a single memory allocation to allocate space for both the IOBuf object and the data storage space.

This saves one memory allocation. However, it can be wasteful if you later need to grow the buffer using reserve(). If the buffer needs to be reallocated, the space originally allocated will not be freed() until the IOBuf object itself is also freed. (It can also be slightly wasteful in some cases where you clone this IOBuf and then free the original IOBuf.)

Definition at line 245 of file IOBuf.cpp.

References capacity(), folly::checkedMalloc(), freeInternalBuf(), folly::goodMallocSize(), packFlagsAndSharedInfo(), and uint8_t.

Referenced by create().

                                                           {
   // To save a memory allocation, allocate space for the IOBuf object, the
   // SharedInfo struct, and the data itself all with a single call to malloc().
   size_t requiredStorage = offsetof(HeapFullStorage, align) + capacity;
   size_t mallocSize = goodMallocSize(requiredStorage);
   auto* storage = static_cast<HeapFullStorage*>(checkedMalloc(mallocSize));
 
   new (&storage->hs.prefix) HeapPrefix(kIOBufInUse | kDataInUse);
   new (&storage->shared) SharedInfo(freeInternalBuf, storage);
 
   uint8_t* bufAddr = reinterpret_cast<uint8_t*>(&storage->align);
   uint8_t* storageEnd = reinterpret_cast<uint8_t*>(storage) + mallocSize;
   size_t actualCapacity = size_t(storageEnd - bufAddr);
   unique_ptr<IOBuf> ret(new (&storage->hs.buf) IOBuf(
       InternalConstructor(),
       packFlagsAndSharedInfo(0, &storage->shared),
       bufAddr,
       actualCapacity,
       bufAddr,
       0));
   return ret;
 }

unique_ptr< IOBuf > folly::IOBuf::createSeparate ( std::size_t capacity )

static

Create a new IOBuf, using separate memory allocations for the IOBuf object for the IOBuf and the data storage space.

This requires two memory allocations, but saves space in the long run if you know that you will need to reallocate the data buffer later.

Definition at line 268 of file IOBuf.cpp.

References capacity(), and CREATE.

Referenced by create().

                                                           {
   return std::make_unique<IOBuf>(CREATE, capacity);
 }

const uint8_t* folly::IOBuf::data ( ) const

inline

Get the pointer to the start of the data.

Definition at line 499 of file IOBuf.h.

References data_.

Referenced by TestAsyncTransport::addReadEvent(), appendToIov(), checkBuf(), checkChain(), folly::gen::detail::consumeBufferPlus(), folly::TypedIOBuf< T >::data(), proxygen::HPACKDecodeBuffer::decodeLiteral(), folly::io::StreamCodec::doCompress(), folly::io::StreamCodec::doUncompress(), proxygen::dumpBinToFile(), proxygen::hpack::dumpToFile(), fillIov(), proxygen::SPDYCodec::generateGoaway(), fizz::EncryptedReadRecordLayer::getDecryptedBuf(), IOBuf(), CurlService::CurlClient::onBody(), proxygen::HTTP1xCodec::onBody(), wangle::SSLSessionCacheManager::onGetSuccess(), proxygen::HTTPCodecPrinter::onGoaway(), proxygen::HTTPSession::onGoaway(), proxygen::HTTP1xCodec::onIngress(), folly::io::detail::CursorBase< Cursor, const IOBuf >::operator==(), proxygen::HTTP2Codec::parseGoaway(), proxygen::Hex16Printer::print(), proxygen::HexFollyPrinter::print(), proxygen::BinPrinter::print(), wangle::StringCodec::read(), HTTPUpstreamTest< SPDY3CodecPair >::readAndLoop(), proxygen::RFC1867Codec::readToBoundary(), takeOwnershipIov(), TEST(), TEST_F(), fizz::trimBytes(), wrapIov(), TestAsyncTransport::writeChain(), folly::AsyncUDPSocket::writeGSO(), and ConnectedWriteUDPClient::writePing().

                               {
     return data_;
   }

void folly::IOBuf::decrementRefcount ( )

private

Definition at line 773 of file IOBuf.cpp.

References flags(), freeExtBuffer(), deadlock::info(), kFlagFreeSharedInfo, folly::IOBuf::SharedInfo::refcount, sharedInfo(), and uint32_t.

Referenced by coalesceAndReallocate(), operator=(), unshareOneSlow(), and ~IOBuf().

                               {
   // Externally owned buffers don't have a SharedInfo object and aren't managed
   // by the reference count
   SharedInfo* info = sharedInfo();
   if (!info) {
     return;
   }
 
   // Decrement the refcount
   uint32_t newcnt = info->refcount.fetch_sub(1, std::memory_order_acq_rel);
   // Note that fetch_sub() returns the value before we decremented.
   // If it is 1, we were the only remaining user; if it is greater there are
   // still other users.
   if (newcnt > 1) {
     return;
   }
 
   // We were the last user.  Free the buffer
   freeExtBuffer();
 
   // Free the SharedInfo if it was allocated separately.
   //
   // This is only used by takeOwnership().
   //
   // To avoid this special case handling in decrementRefcount(), we could have
   // takeOwnership() set a custom freeFn() that calls the user's free function
   // then frees the SharedInfo object.  (This would require that
   // takeOwnership() store the user's free function with its allocated
   // SharedInfo object.)  However, handling this specially with a flag seems
   // like it shouldn't be problematic.
   if (flags() & kFlagFreeSharedInfo) {
     delete sharedInfo();
   }
 }

static void folly::IOBuf::destroy ( std::unique_ptr< IOBuf > && data )

inlinestatic

Convenience function to free a chain of IOBufs held by a unique_ptr.

Definition at line 467 of file IOBuf.h.

References data, folly::empty(), and folly::gen::move.

                                                    {
     auto destroyer = std::move(data);
   }

bool folly::IOBuf::empty ( ) const

Check whether the chain is empty (i.e., whether the IOBufs in the chain have a total data length of zero).

This method is semantically equivalent to i->computeChainDataLength()==0 but may run faster because it can short-circuit as soon as it encounters a buffer with length()!=0

Definition at line 482 of file IOBuf.cpp.

References current, length(), and next_.

Referenced by folly::TypedIOBuf< T >::empty(), proxygen::HTTP2Codec::parseAllData(), proxygen::HTTP2Codec::parseDataFrameData(), and folly::io::Codec::uncompress().

                         {
   const IOBuf* current = this;
   do {
     if (current->length() != 0) {
       return false;
     }
     current = current->next_;
   } while (current != this);
   return true;
 }

IOBuf::Iterator folly::IOBuf::end ( ) const

inline

Definition at line 1687 of file IOBuf.h.

References folly::padded::cend(), and FOLLY_POP_WARNING.

Referenced by coalesceSlow().

                                       {
   return cend();
 }

size_t folly::IOBuf::fillIov	(	struct iovec *	iov,
		size_t	len
	)		const

Fill an iovec array with the IOBuf data.

Returns the number of iovec filled. If there are more buffer than iovec, returns 0. This version is suitable to use with stack iovec arrays.

Naturally, the filled iovec data will be invalid if you modify the buffer chain.

Definition at line 1072 of file IOBuf.cpp.

References data(), i, length(), next(), and uint8_t.

Referenced by folly::AsyncUDPSocket::writeGSO(), and ConnectedWriteUDPClient::writePing().

                                                          {
   IOBuf const* p = this;
   size_t i = 0;
   while (i < len) {
     // some code can get confused by empty iovs, so skip them
     if (p->length() > 0) {
       iov[i].iov_base = const_cast<uint8_t*>(p->data());
       iov[i].iov_len = p->length();
       i++;
     }
     p = p->next();
     if (p == this) {
       return i;
     }
   }
   return 0;
 }

uintptr_t folly::IOBuf::flags ( ) const

inlineprivate

Definition at line 1459 of file IOBuf.h.

Referenced by decrementRefcount(), moveToFbString(), and reserveSlow().

                                  {
     return flagsAndSharedInfo_ & kFlagMask;
   }

void folly::IOBuf::freeExtBuffer ( )

private

Definition at line 909 of file IOBuf.cpp.

References buf_, bm::free(), folly::IOBuf::SharedInfo::freeFn, deadlock::info(), sharedInfo(), and folly::IOBuf::SharedInfo::userData.

Referenced by decrementRefcount(), and reserveSlow().

                           {
   SharedInfo* info = sharedInfo();
   DCHECK(info);
 
   if (info->freeFn) {
     try {
       info->freeFn(buf_, info->userData);
     } catch (...) {
       // The user's free function should never throw.  Otherwise we might
       // throw from the IOBuf destructor.  Other code paths like coalesce()
       // also assume that decrementRefcount() cannot throw.
       abort();
     }
   } else {
     free(buf_);
   }
 }

void folly::IOBuf::freeInternalBuf	(	void *	buf,
		void *	userData
	)

staticprivate

Definition at line 190 of file IOBuf.cpp.

References releaseStorage(), and folly::IOBuf::SharedInfo::userData.

Referenced by createCombined().

                                                    {
   auto* storage = static_cast<HeapStorage*>(userData);
   releaseStorage(storage, kDataInUse);
 }

static void folly::IOBuf::freeUniquePtrBuffer	(	void *	ptr,
		void *	userData
	)

inlinestaticprivate

Definition at line 1502 of file IOBuf.h.

                                                              {
     static_cast<DeleterBase*>(userData)->dispose(ptr);
   }

void folly::IOBuf::gather ( std::size_t maxLength )

inline

Ensure that this chain has at least maxLength bytes available as a contiguous memory range.

This method coalesces whole buffers in the chain into this buffer as necessary until this buffer's length() is at least maxLength.

After coalescing, the IOBuf will have at least as much headroom as the first IOBuf in the chain, and at least as much tailroom as the last IOBuf that was coalesced.

Throws std::bad_alloc or std::overflow_error on error. On error the IOBuf chain will be unmodified. Throws std::overflow_error if maxLength is longer than the total chain length.

Upon return, either enough of the chain was coalesced into a contiguous region, or the entire chain was coalesced. That is, length() >= maxLength || !isChained() is true.

Definition at line 1136 of file IOBuf.h.

References length_.

                                    {
     if (!isChained() || length_ >= maxLength) {
       return;
     }
     coalesceSlow(maxLength);
   }

folly::fbvector< struct iovec > folly::IOBuf::getIov ( ) const

Return an iovector suitable for e.g. writev()

auto iov = buf->getIov(); auto xfer = writev(fd, iov.data(), iov.size());

Naturally, the returned iovector is invalid if you modify the buffer chain.

Definition at line 1009 of file IOBuf.cpp.

References appendToIov(), countChainElements(), and folly::fbvector< T, Allocator >::reserve().

                                                 {
   folly::fbvector<struct iovec> iov;
   iov.reserve(countChainElements());
   appendToIov(&iov);
   return iov;
 }

size_t folly::IOBuf::goodExtBufferSize ( std::size_t minCapacity )

staticprivate

Definition at line 938 of file IOBuf.cpp.

References folly::goodMallocSize().

Referenced by allocExtBuffer(), and reserveSlow().

                                                      {
   // Determine how much space we should allocate.  We'll store the SharedInfo
   // for the external buffer just after the buffer itself.  (We store it just
   // after the buffer rather than just before so that the code can still just
   // use free(buf_) to free the buffer.)
   size_t minSize = static_cast<size_t>(minCapacity) + sizeof(SharedInfo);
   // Add room for padding so that the SharedInfo will be aligned on an 8-byte
   // boundary.
   minSize = (minSize + 7) & ~7;
 
   // Use goodMallocSize() to bump up the capacity to a decent size to request
   // from malloc, so we can use all of the space that malloc will probably give
   // us anyway.
   return goodMallocSize(minSize);
 }

std::size_t folly::IOBuf::headroom ( ) const

inline

Get the amount of head room.

Returns the number of bytes in the buffer before the start of the data.

Definition at line 542 of file IOBuf.h.

References buffer(), and data_.

Referenced by cloneCoalescedAsValue(), proxygen::SPDYCodec::generateDataFrame(), folly::TypedIOBuf< T >::headroom(), moveToFbString(), prepend(), reserveSlow(), TEST(), TEST_F(), and unshareOneSlow().

                              {
     return std::size_t(data_ - buffer());
   }

void folly::IOBuf::initExtBuffer	(	uint8_t *	buf,
		size_t	mallocSize,
		SharedInfo **	infoReturn,
		std::size_t *	capacityReturn
	)

staticprivate

Definition at line 954 of file IOBuf.cpp.

References sharedInfo(), and uint8_t.

Referenced by allocExtBuffer(), and reserveSlow().

                                {
   // Find the SharedInfo storage at the end of the buffer
   // and construct the SharedInfo.
   uint8_t* infoStart = (buf + mallocSize) - sizeof(SharedInfo);
   SharedInfo* sharedInfo = new (infoStart) SharedInfo;
 
   *capacityReturn = std::size_t(infoStart - buf);
   *infoReturn = sharedInfo;
 }

bool folly::IOBuf::isChained ( ) const

inline

Return true if this IOBuf is part of a chain of multiple IOBufs, or false if this is the only IOBuf in its chain.

Definition at line 760 of file IOBuf.h.

Referenced by MoveToFbStringTest::check(), cloneCoalescedAsValueWithHeadroomTailroom(), coalesceAndReallocate(), coalesceSlow(), folly::io::StreamCodec::doUncompress(), ZlibServerFilterTest::exercise_compression(), makeManagedChained(), moveToFbString(), TEST(), fizz::test::TEST_F(), TEST_F(), and unshareChained().

                          {
     assert((next_ == this) == (prev_ == this));
     return next_ != this;
   }

bool folly::IOBuf::isManaged ( ) const

inline

Return true if all IOBufs in this chain are managed by the usual refcounting mechanism (and so the lifetime of the underlying memory can be extended by clone()).

Definition at line 920 of file IOBuf.h.

References current, isManagedOne(), and next_.

                          {
     const IOBuf* current = this;
     while (true) {
       if (!current->isManagedOne()) {
         return false;
       }
       current = current->next_;
       if (current == this) {
         return true;
       }
     }
   }

bool folly::IOBuf::isManagedOne ( ) const

inline

Return true if this IOBuf is managed by the usual refcounting mechanism (and so the lifetime of the underlying memory can be extended by cloneOne()).

Definition at line 938 of file IOBuf.h.

Referenced by isManaged().

                             {
     return sharedInfo();
   }

bool folly::IOBuf::isShared ( ) const

inline

Return true if at least one of the IOBufs in this chain are shared, or false if all of the IOBufs point to unique buffers.

Use isSharedOne() to only check this IOBuf rather than the entire chain.

Definition at line 902 of file IOBuf.h.

References current, isSharedOne(), and next_.

Referenced by moveToFbString(), and TEST().

                         {
     const IOBuf* current = this;
     while (true) {
       if (current->isSharedOne()) {
         return true;
       }
       current = current->next_;
       if (current == this) {
         return false;
       }
     }
   }

bool folly::IOBuf::isSharedOne ( ) const

inline

Return true if other IOBufs are also pointing to the buffer used by this IOBuf, and false otherwise.

If this IOBuf points at a buffer owned by another (non-IOBuf) part of the code (i.e., if the IOBuf was created using wrapBuffer(), or was cloned from such an IOBuf), it is always considered shared.

This only checks the current IOBuf, and not other IOBufs in the chain.

Definition at line 952 of file IOBuf.h.

References LIKELY, and UNLIKELY.

Referenced by proxygen::SPDYCodec::generateDataFrame(), isShared(), reserveSlow(), TEST(), unshareChained(), and folly::IOBufQueue::updateWritableTailCache().

                            {
     // If this is a user-owned buffer, it is always considered shared
     if (UNLIKELY(!sharedInfo())) {
       return true;
     }
 
     if (UNLIKELY(sharedInfo()->externallyShared)) {
       return true;
     }
 
     if (LIKELY(!(flags() & kFlagMaybeShared))) {
       return false;
     }
 
     // kFlagMaybeShared is set, so we need to check the reference count.
     // (Checking the reference count requires an atomic operation, which is why
     // we prefer to only check kFlagMaybeShared if possible.)
     bool shared = sharedInfo()->refcount.load(std::memory_order_acquire) > 1;
     if (!shared) {
       // we're the last one left
       clearFlags(kFlagMaybeShared);
     }
     return shared;
   }

std::size_t folly::IOBuf::length ( ) const

inline

Get the data length.

Definition at line 533 of file IOBuf.h.

References length_.

Referenced by TestAsyncTransport::addReadEvent(), appendToIov(), folly::io::detail::CursorBase< Cursor, const IOBuf >::canAdvance(), MoveToFbStringTest::check(), checkBuf(), checkChain(), folly::io::detail::CursorBase< Cursor, const IOBuf >::cloneAtMost(), folly::gen::detail::consumeBufferPlus(), folly::io::StreamCodec::doCompress(), folly::io::StreamCodec::doUncompress(), proxygen::dumpBinToFile(), proxygen::hpack::dumpToFile(), empty(), proxygen::GzipHeaderCodec::encode(), fillBuf(), fillIov(), proxygen::SPDYCodec::generateDataFrame(), fizz::EncryptedWriteRecordLayer::getBufToEncrypt(), fizz::EncryptedReadRecordLayer::getDecryptedBuf(), IOBuf(), folly::io::detail::CursorBase< Cursor, const IOBuf >::isAtEnd(), folly::TypedIOBuf< T >::length(), moveToFbString(), proxygen::HTTPCodecPrinter::onBody(), CurlService::CurlClient::onBody(), proxygen::HTTP1xCodec::onBody(), wangle::SSLSessionCacheManager::onGetSuccess(), proxygen::HTTPCodecPrinter::onGoaway(), proxygen::HTTP1xCodec::onIngress(), proxygen::HTTP2Codec::parseGoaway(), proxygen::Hex16Printer::print(), proxygen::HexFollyPrinter::print(), proxygen::ChainInfoPrinter::print(), proxygen::BinPrinter::print(), proxygen::HTTPSession::processReadData(), wangle::StringCodec::read(), HTTPUpstreamTest< SPDY3CodecPair >::readAndLoop(), proxygen::RFC1867Codec::readToBoundary(), takeOwnership(), TEST(), TEST_F(), fizz::transformBuffer(), fizz::trimBytes(), TestAsyncTransport::writeChain(), folly::AsyncUDPSocket::writeGSO(), and ConnectedWriteUDPClient::writePing().

                            {
     return length_;
   }

void folly::IOBuf::makeManaged ( )

inline

Ensure that the memory that IOBufs in this chain refer to will continue to be allocated for as long as the IOBufs of the chain (or any clone()s created from this point onwards) is alive.

This only has an effect for user-owned buffers (created with the WRAP_BUFFER constructor or wrapBuffer factory function), in which case those buffers are unshared.

Definition at line 1054 of file IOBuf.h.

                      {
     if (isChained()) {
       makeManagedChained();
     } else {
       makeManagedOne();
     }
   }

void folly::IOBuf::makeManagedChained ( )

private

Definition at line 664 of file IOBuf.cpp.

References current, isChained(), makeManagedOne(), and next_.

                                {
   assert(isChained());
 
   IOBuf* current = this;
   while (true) {
     current->makeManagedOne();
     current = current->next_;
     if (current == this) {
       break;
     }
   }
 }

void folly::IOBuf::makeManagedOne ( )

inline

Ensure that the memory that this IOBuf refers to will continue to be allocated for as long as this IOBuf (or any clone()s created from this point onwards) is alive.

This only has an effect for user-owned buffers (created with the WRAP_BUFFER constructor or wrapBuffer factory function), in which case those buffers are unshared.

Definition at line 1071 of file IOBuf.h.

Referenced by makeManagedChained().

                         {
     if (!isManagedOne()) {
       // We can call the internal function directly; unmanaged implies shared.
       unshareOneSlow();
     }
   }

void folly::IOBuf::markExternallyShared ( )

Mark the underlying buffers in this chain as shared with external memory management mechanism. This will make isShared() always returns true.

This function is not thread-safe, and only safe to call immediately after creating an IOBuf, before it has been shared with other threads.

Definition at line 656 of file IOBuf.cpp.

References current, markExternallySharedOne(), and next_.

                                  {
   IOBuf* current = this;
   do {
     current->markExternallySharedOne();
     current = current->next_;
   } while (current != this);
 }

void folly::IOBuf::markExternallySharedOne ( )

inline

Mark the underlying buffer that this IOBuf refers to as shared with external memory management mechanism. This will make isSharedOne() always returns true.

This function is not thread-safe, and only safe to call immediately after creating an IOBuf, before it has been shared with other threads.

Definition at line 1038 of file IOBuf.h.

References folly::IOBuf::SharedInfo::externallyShared, and deadlock::info().

Referenced by markExternallyShared().

                                  {
     SharedInfo* info = sharedInfo();
     if (info) {
       info->externallyShared = true;
     }
   }

std::unique_ptr< IOBuf > folly::IOBuf::maybeCopyBuffer	(	const std::string &	buf,
		std::size_t	headroom = `0`,
		std::size_t	minTailroom = `0`
	)

inlinestatic

A version of copyBuffer() that returns a null pointer if the input string is empty.

Definition at line 1609 of file IOBuf.h.

References fizz::test::copyBuffer().

Referenced by proxygen::ResponseBuilder::body().

                            {
   if (buf.empty()) {
     return nullptr;
   }
   return copyBuffer(buf.data(), buf.size(), headroom, minTailroom);
 }

fbstring folly::IOBuf::moveToFbString ( )

Destructively convert this IOBuf to a fbstring efficiently. We rely on fbstring's AcquireMallocatedString constructor to transfer memory.

Definition at line 968 of file IOBuf.cpp.

References buf_, capacity(), clear(), coalesceAndReallocate(), computeChainDataLength(), flags(), flagsAndSharedInfo_, headroom(), isChained(), isShared(), kFlagFreeSharedInfo, length(), sharedInfo(), tailroom(), writableData(), and writableTail().

Referenced by MoveToFbStringTest::check(), HTTP2FramerTest::dataFrameTest(), TEST(), TEST_F(), TEST_P(), and fizz::test::TEST_P().

                                {
   // malloc-allocated buffers are just fine, everything else needs
   // to be turned into one.
   if (!sharedInfo() || // user owned, not ours to give up
       sharedInfo()->freeFn || // not malloc()-ed
       headroom() != 0 || // malloc()-ed block doesn't start at beginning
       tailroom() == 0 || // no room for NUL terminator
       isShared() || // shared
       isChained()) { // chained
     // We might as well get rid of all head and tailroom if we're going
     // to reallocate; we need 1 byte for NUL terminator.
     coalesceAndReallocate(0, computeChainDataLength(), this, 1);
   }
 
   // Ensure NUL terminated
   *writableTail() = 0;
   fbstring str(
       reinterpret_cast<char*>(writableData()),
       length(),
       capacity(),
       AcquireMallocatedString());
 
   if (flags() & kFlagFreeSharedInfo) {
     delete sharedInfo();
   }
 
   // Reset to a state where we can be deleted cleanly
   flagsAndSharedInfo_ = 0;
   buf_ = nullptr;
   clear();
   return str;
 }

IOBuf* folly::IOBuf::next ( )

inline

Get a pointer to the next IOBuf in this chain.

Definition at line 600 of file IOBuf.h.

Referenced by appendToIov(), folly::io::detail::CursorBase< Cursor, const IOBuf >::canAdvance(), checkChain(), folly::IOBufQueue::clear(), proxygen::ZlibStreamDecompressor::decompress(), folly::io::StreamCodec::doCompress(), folly::io::StreamCodec::doUncompress(), proxygen::dumpBinToFile(), proxygen::hpack::dumpToFile(), ZlibServerFilterTest::exercise_compression(), fillIov(), folly::io::detail::CursorBase< Cursor, const IOBuf >::isAtEnd(), CurlService::CurlClient::onBody(), folly::io::detail::CursorBase< Cursor, const IOBuf >::operator==(), TEST(), TEST_F(), fizz::transformBuffer(), and TestAsyncTransport::writeChain().

                 {
     return next_;
   }

const IOBuf* folly::IOBuf::next ( ) const

inline

Definition at line 603 of file IOBuf.h.

                             {
     return next_;
   }

void folly::IOBuf::operator delete ( void * ptr )

Definition at line 145 of file IOBuf.cpp.

References ptr, releaseStorage(), and uint8_t.

                                      {
   auto* storageAddr = static_cast<uint8_t*>(ptr) - offsetof(HeapStorage, buf);
   auto* storage = reinterpret_cast<HeapStorage*>(storageAddr);
   releaseStorage(storage, kIOBufInUse);
 }

void folly::IOBuf::operator delete	(	void *	ptr,
		void *	placement
	)

Definition at line 151 of file IOBuf.cpp.

                                             {
   // Provide matching operator for `IOBuf::new` to avoid MSVC compilation
   // warning (C4291) about memory leak when exception is thrown in the
   // constructor.
 }

void * folly::IOBuf::operator new ( size_t size )

Definition at line 133 of file IOBuf.cpp.

References folly::checkedMalloc(), and folly::size().

                                      {
   size_t fullSize = offsetof(HeapStorage, buf) + size;
   auto* storage = static_cast<HeapStorage*>(checkedMalloc(fullSize));
 
   new (&storage->prefix) HeapPrefix(kIOBufInUse);
   return &(storage->buf);
 }

void * folly::IOBuf::operator new	(	size_t	size,
		void *	ptr
	)

Definition at line 141 of file IOBuf.cpp.

References ptr.

                                              {
   return ptr;
 }

IOBuf & folly::IOBuf::operator= ( IOBuf && other )

noexcept

Definition at line 428 of file IOBuf.cpp.

References buf_, capacity_, data_, decrementRefcount(), flagsAndSharedInfo_, length_, next_, prev_, and unlink().

                                               {
   if (this == &other) {
     return *this;
   }
 
   // If we are part of a chain, delete the rest of the chain.
   while (next_ != this) {
     // Since unlink() returns unique_ptr() and we don't store it,
     // it will automatically delete the unlinked element.
     (void)next_->unlink();
   }
 
   // Decrement our refcount on the current buffer
   decrementRefcount();
 
   // Take ownership of the other buffer's data
   data_ = other.data_;
   buf_ = other.buf_;
   length_ = other.length_;
   capacity_ = other.capacity_;
   flagsAndSharedInfo_ = other.flagsAndSharedInfo_;
   // Reset other so it is a clean state to be destroyed.
   other.data_ = nullptr;
   other.buf_ = nullptr;
   other.length_ = 0;
   other.capacity_ = 0;
   other.flagsAndSharedInfo_ = 0;
 
   // If other was part of the chain, assume ownership of the rest of its chain.
   // (It's only valid to perform move assignment on the head of a chain.)
   if (other.next_ != &other) {
     next_ = other.next_;
     next_->prev_ = this;
     other.next_ = &other;
 
     prev_ = other.prev_;
     prev_->next_ = this;
     other.prev_ = &other;
   }
 
   // Sanity check to make sure that other is in a valid state to be destroyed.
   DCHECK_EQ(other.prev_, &other);
   DCHECK_EQ(other.next_, &other);
 
   return *this;
 }

IOBuf & folly::IOBuf::operator= ( const IOBuf & other )

Definition at line 475 of file IOBuf.cpp.

References IOBuf().

                                           {
   if (this != &other) {
     *this = IOBuf(other);
   }
   return *this;
 }

static uintptr_t folly::IOBuf::packFlagsAndSharedInfo	(	uintptr_t	flags,
		SharedInfo *	info
	)

inlinestaticprivate

Definition at line 1440 of file IOBuf.h.

References deadlock::info().

Referenced by createCombined().

                         {
     uintptr_t uinfo = reinterpret_cast<uintptr_t>(info);
     DCHECK_EQ(flags & ~kFlagMask, 0u);
     DCHECK_EQ(uinfo & kFlagMask, 0u);
     return flags | uinfo;
   }

std::unique_ptr<IOBuf> folly::IOBuf::pop ( )

inline

Remove this IOBuf from its current chain and return a unique_ptr to the IOBuf that formerly followed it in the chain.

Definition at line 859 of file IOBuf.h.

References cpp.ast::next().

Referenced by proxygen::SPDYCodec::generateDataFrame(), poolPutIOBuf(), and folly::IOBufQueue::pop_front().

                              {
     IOBuf* next = next_;
     next_->prev_ = prev_;
     prev_->next_ = next_;
     prev_ = this;
     next_ = this;
     return std::unique_ptr<IOBuf>((next == this) ? nullptr : next);
   }

void folly::IOBuf::prepend ( std::size_t amount )

inline

Adjust the data pointer to include more valid data at the beginning.

This moves the data pointer backwards to include more of the available buffer. The caller is responsible for ensuring that there is sufficient headroom for the new data. The caller is also responsible for populating this section with valid data.

This does not modify any actual data in the buffer.

Definition at line 673 of file IOBuf.h.

References data_, and length_.

Referenced by proxygen::SPDYCodec::generateSynReply(), proxygen::SPDYCodec::generateSynStream(), prepend(), and folly::TypedIOBuf< T >::prepend().

                                  {
     DCHECK_LE(amount, headroom());
     data_ -= amount;
     length_ += amount;
   }

void folly::IOBuf::prependChain ( std::unique_ptr< IOBuf > && iobuf )

Insert another IOBuf chain immediately before this IOBuf.

For example, if there are two IOBuf chains (A, B, C) and (D, E, F), and B->prependChain(D) is called, the (D, E, F) chain will be subsumed and become part of the chain starting at A, which will now look like (A, D, E, F, B, C)

Note that since IOBuf chains are circular, head->prependChain(other) can be used to append the other chain at the very end of the chain pointed to by head. For example, if there are two IOBuf chains (A, B, C) and (D, E, F), and A->prependChain(D) is called, the chain starting at A will now consist of (A, B, C, D, E, F)

Definition at line 509 of file IOBuf.cpp.

References next_, and prev_.

Referenced by BENCHMARK(), fizz::test::chunkIOBuf(), folly::io::detail::CursorBase< Cursor, const IOBuf >::cloneAtMost(), fizz::test::copyBuffer(), ZlibServerFilterTest::createResponseChain(), fizz::detail::evpEncrypt(), ZlibServerFilterTest::exercise_compression(), TestData::getInBuf(), folly::io::RWCursor< access >::insert(), main(), proxygen::RFC1867Base::parse(), TEST(), TEST_F(), and fizz::EncryptedWriteRecordLayer::write().

                                                   {
   // Take ownership of the specified IOBuf
   IOBuf* other = iobuf.release();
 
   // Remember the pointer to the tail of the other chain
   IOBuf* otherTail = other->prev_;
 
   // Hook up prev_->next_ to point at the start of the other chain,
   // and other->prev_ to point at prev_
   prev_->next_ = other;
   other->prev_ = prev_;
 
   // Hook up otherTail->next_ to point at us,
   // and prev_ to point back at otherTail,
   otherTail->next_ = this;
   prev_ = otherTail;
 }

IOBuf* folly::IOBuf::prev ( )

inline

Get a pointer to the previous IOBuf in this chain.

Definition at line 610 of file IOBuf.h.

Referenced by cloneCoalescedAsValue(), proxygen::ZlibStreamCompressor::compress(), folly::IOBufQueue::dcheckCacheIntegrity(), fizz::detail::evpEncrypt(), folly::IOBufQueue::flushCache(), folly::io::detail::CursorBase< Cursor, const IOBuf >::operator==(), TEST(), fizz::trimBytes(), and folly::IOBufQueue::updateWritableTailCache().

                 {
     return prev_;
   }

const IOBuf* folly::IOBuf::prev ( ) const

inline

Definition at line 613 of file IOBuf.h.

                             {
     return prev_;
   }

void folly::IOBuf::releaseStorage	(	HeapStorage *	storage,
		uint16_t	freeFlags
	)

staticprivate

Definition at line 157 of file IOBuf.cpp.

References folly::IOBuf::HeapPrefix::flags, bm::free(), folly::IOBuf::HeapPrefix::magic, folly::IOBuf::HeapStorage::prefix, and uint16_t.

Referenced by freeInternalBuf(), and operator delete().

                                                                    {
   CHECK_EQ(storage->prefix.magic, static_cast<uint16_t>(kHeapMagic));
 
   // Use relaxed memory order here.  If we are unlucky and happen to get
   // out-of-date data the compare_exchange_weak() call below will catch
   // it and load new data with memory_order_acq_rel.
   auto flags = storage->prefix.flags.load(std::memory_order_acquire);
   DCHECK_EQ((flags & freeFlags), freeFlags);
 
   while (true) {
     uint16_t newFlags = uint16_t(flags & ~freeFlags);
     if (newFlags == 0) {
       // The storage space is now unused.  Free it.
       storage->prefix.HeapPrefix::~HeapPrefix();
       free(storage);
       return;
     }
 
     // This storage segment still contains portions that are in use.
     // Just clear the flags specified in freeFlags for now.
     auto ret = storage->prefix.flags.compare_exchange_weak(
         flags, newFlags, std::memory_order_acq_rel);
     if (ret) {
       // We successfully updated the flags.
       return;
     }
 
     // We failed to update the flags.  Some other thread probably updated them
     // and cleared some of the other bits.  Continue around the loop to see if
     // we are the last user now, or if we need to try updating the flags again.
   }
 }

void folly::IOBuf::reserve	(	std::size_t	minHeadroom,
		std::size_t	minTailroom
	)

inline

Ensure that this buffer has at least minHeadroom headroom bytes and at least minTailroom tailroom bytes. The buffer must be writable (you must call unshare() before this, if necessary).

Postcondition: headroom() >= minHeadroom, tailroom() >= minTailroom, the data (between data() and data() + length()) is preserved.

Definition at line 741 of file IOBuf.h.

References data_.

Referenced by BENCHMARK(), folly::gen::detail::consumeBufferPlus(), folly::TypedIOBuf< T >::reserve(), and TEST().

                                                              {
     // Maybe we don't need to do anything.
     if (headroom() >= minHeadroom && tailroom() >= minTailroom) {
       return;
     }
     // If the buffer is empty but we have enough total room (head + tail),
     // move the data_ pointer around.
     if (length() == 0 && headroom() + tailroom() >= minHeadroom + minTailroom) {
       data_ = writableBuffer() + minHeadroom;
       return;
     }
     // Bah, we have to do actual work.
     reserveSlow(minHeadroom, minTailroom);
   }

void folly::IOBuf::reserveSlow	(	std::size_t	minHeadroom,
		std::size_t	minTailroom
	)

private

Definition at line 808 of file IOBuf.cpp.

References buf_, capacity(), capacity_, folly::checkedMalloc(), data_, flags(), freeExtBuffer(), folly::IOBuf::SharedInfo::freeFn, goodExtBufferSize(), headroom(), deadlock::info(), initExtBuffer(), isSharedOne(), folly::jemallocMinInPlaceExpandable, kFlagFreeSharedInfo, length_, setFlagsAndSharedInfo(), sharedInfo(), tailroom(), uint8_t, UNLIKELY, folly::usingJEMalloc(), writableBuffer(), and xallocx.

                                                                     {
   size_t newCapacity = (size_t)length_ + minHeadroom + minTailroom;
   DCHECK_LT(newCapacity, UINT32_MAX);
 
   // reserveSlow() is dangerous if anyone else is sharing the buffer, as we may
   // reallocate and free the original buffer.  It should only ever be called if
   // we are the only user of the buffer.
   DCHECK(!isSharedOne());
 
   // We'll need to reallocate the buffer.
   // There are a few options.
   // - If we have enough total room, move the data around in the buffer
   //   and adjust the data_ pointer.
   // - If we're using an internal buffer, we'll switch to an external
   //   buffer with enough headroom and tailroom.
   // - If we have enough headroom (headroom() >= minHeadroom) but not too much
   //   (so we don't waste memory), we can try one of two things, depending on
   //   whether we use jemalloc or not:
   //   - If using jemalloc, we can try to expand in place, avoiding a memcpy()
   //   - If not using jemalloc and we don't have too much to copy,
   //     we'll use realloc() (note that realloc might have to copy
   //     headroom + data + tailroom, see smartRealloc in folly/memory/Malloc.h)
   // - Otherwise, bite the bullet and reallocate.
   if (headroom() + tailroom() >= minHeadroom + minTailroom) {
     uint8_t* newData = writableBuffer() + minHeadroom;
     memmove(newData, data_, length_);
     data_ = newData;
     return;
   }
 
   size_t newAllocatedCapacity = 0;
   uint8_t* newBuffer = nullptr;
   std::size_t newHeadroom = 0;
   std::size_t oldHeadroom = headroom();
 
   // If we have a buffer allocated with malloc and we just need more tailroom,
   // try to use realloc()/xallocx() to grow the buffer in place.
   SharedInfo* info = sharedInfo();
   if (info && (info->freeFn == nullptr) && length_ != 0 &&
       oldHeadroom >= minHeadroom) {
     size_t headSlack = oldHeadroom - minHeadroom;
     newAllocatedCapacity = goodExtBufferSize(newCapacity + headSlack);
     if (usingJEMalloc()) {
       // We assume that tailroom is more useful and more important than
       // headroom (not least because realloc / xallocx allow us to grow the
       // buffer at the tail, but not at the head)  So, if we have more headroom
       // than we need, we consider that "wasted".  We arbitrarily define "too
       // much" headroom to be 25% of the capacity.
       if (headSlack * 4 <= newCapacity) {
         size_t allocatedCapacity = capacity() + sizeof(SharedInfo);
         void* p = buf_;
         if (allocatedCapacity >= jemallocMinInPlaceExpandable) {
           if (xallocx(p, newAllocatedCapacity, 0, 0) == newAllocatedCapacity) {
             newBuffer = static_cast<uint8_t*>(p);
             newHeadroom = oldHeadroom;
           }
           // if xallocx failed, do nothing, fall back to malloc/memcpy/free
         }
       }
     } else { // Not using jemalloc
       size_t copySlack = capacity() - length_;
       if (copySlack * 2 <= length_) {
         void* p = realloc(buf_, newAllocatedCapacity);
         if (UNLIKELY(p == nullptr)) {
           throw std::bad_alloc();
         }
         newBuffer = static_cast<uint8_t*>(p);
         newHeadroom = oldHeadroom;
       }
     }
   }
 
   // None of the previous reallocation strategies worked (or we're using
   // an internal buffer).  malloc/copy/free.
   if (newBuffer == nullptr) {
     newAllocatedCapacity = goodExtBufferSize(newCapacity);
     newBuffer = static_cast<uint8_t*>(checkedMalloc(newAllocatedCapacity));
     if (length_ > 0) {
       assert(data_ != nullptr);
       memcpy(newBuffer + minHeadroom, data_, length_);
     }
     if (sharedInfo()) {
       freeExtBuffer();
     }
     newHeadroom = minHeadroom;
   }
 
   std::size_t cap;
   initExtBuffer(newBuffer, newAllocatedCapacity, &info, &cap);
 
   if (flags() & kFlagFreeSharedInfo) {
     delete sharedInfo();
   }
 
   setFlagsAndSharedInfo(0, info);
   capacity_ = cap;
   buf_ = newBuffer;
   data_ = newBuffer + newHeadroom;
   // length_ is unchanged
 }

void folly::IOBuf::retreat ( std::size_t amount )

inline

Shift the data backwards in the buffer.

The caller is responsible for ensuring that there is sufficient headroom in the buffer before calling retreat().

If there is a non-zero data length, retreat() will use memmove() to shift the data backwards in the buffer. In this case, the caller is responsible for making sure the buffer is unshared, so it will not affect other IOBufs that may be sharing the same underlying buffer.

Definition at line 653 of file IOBuf.h.

References data_, and length_.

Referenced by proxygen::SPDYCodec::generateDataFrame(), and folly::TypedIOBuf< T >::retreat().

                                  {
     // In debug builds, assert if there is a problem.
     assert(amount <= headroom());
 
     if (length_ > 0) {
       memmove(data_ - amount, data_, length_);
     }
     data_ -= amount;
   }

std::unique_ptr<IOBuf> folly::IOBuf::separateChain	(	IOBuf *	head,
		IOBuf *	tail
	)

inline

Remove a subchain from this chain.

Remove the subchain starting at head and ending at tail from this chain.

Returns a unique_ptr pointing to head. (In other words, ownership of the head of the subchain is transferred to the caller.) If the caller ignores the return value and lets the unique_ptr be destroyed, the subchain will be immediately destroyed.

The subchain referenced by the specified head and tail must be part of the same chain as the current IOBuf, but must not contain the current IOBuf. However, the specified head and tail may be equal to each other (i.e., they may be a subchain of length 1).

Definition at line 883 of file IOBuf.h.

References next_, and prev_.

Referenced by coalesceAndReallocate().

                                                                {
     assert(head != this);
     assert(tail != this);
 
     head->prev_->next_ = tail->next_;
     tail->next_->prev_ = head->prev_;
 
     head->prev_ = tail;
     tail->next_ = head;
 
     return std::unique_ptr<IOBuf>(head);
   }

void folly::IOBuf::setFlags ( uintptr_t flags ) const

inlineprivate

Definition at line 1464 of file IOBuf.h.

Referenced by cloneOneAsValue().

                                               {
     DCHECK_EQ(flags & ~kFlagMask, 0u);
     flagsAndSharedInfo_ |= flags;
   }

void folly::IOBuf::setFlagsAndSharedInfo	(	uintptr_t	flags,
		SharedInfo *	info
	)

inlineprivate

Definition at line 1474 of file IOBuf.h.

Referenced by coalesceAndReallocate(), reserveSlow(), and unshareOneSlow().

                                                                        {
     flagsAndSharedInfo_ = packFlagsAndSharedInfo(flags, info);
   }

void folly::IOBuf::setSharedInfo ( SharedInfo * info )

inlineprivate

Definition at line 1453 of file IOBuf.h.

References deadlock::info().

Referenced by IOBuf().

                                               {
     uintptr_t uinfo = reinterpret_cast<uintptr_t>(info);
     DCHECK_EQ(uinfo & kFlagMask, 0u);
     flagsAndSharedInfo_ = (flagsAndSharedInfo_ & kFlagMask) | uinfo;
   }

SharedInfo* folly::IOBuf::sharedInfo ( ) const

inlineprivate

Definition at line 1449 of file IOBuf.h.

Referenced by cloneOneAsValue(), decrementRefcount(), freeExtBuffer(), initExtBuffer(), moveToFbString(), reserveSlow(), and unshareOneSlow().

                                         {
     return reinterpret_cast<SharedInfo*>(flagsAndSharedInfo_ & ~kFlagMask);
   }

const uint8_t* folly::IOBuf::tail ( ) const

inline

Get the pointer to the end of the data.

Definition at line 516 of file IOBuf.h.

References data_, and length_.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::operator==(), folly::TypedIOBuf< T >::tail(), and TEST().

                               {
     return data_ + length_;
   }

std::size_t folly::IOBuf::tailroom ( ) const

inline

Get the amount of tail room.

Returns the number of bytes in the buffer after the end of the data.

Definition at line 551 of file IOBuf.h.

Referenced by append(), folly::IOBufQueue::append(), cloneCoalescedAsValue(), coalesceAndReallocate(), folly::IOBufQueue::dcheckCacheIntegrity(), folly::io::StreamCodec::doUncompress(), fizz::detail::evpEncrypt(), moveToFbString(), proxygen::ChainInfoPrinter::print(), reserveSlow(), folly::TypedIOBuf< T >::tailroom(), TEST(), and folly::IOBufQueue::updateWritableTailCache().

                              {
     return std::size_t(bufferEnd() - tail());
   }

static std::unique_ptr<IOBuf> folly::IOBuf::takeOwnership	(	void *	buf,
		std::size_t	capacity,
		FreeFunction	freeFn = `nullptr`,
		void *	userData = `nullptr`,
		bool	freeOnError = `true`
	)

inlinestatic

Create a new IOBuf pointing to an existing data buffer.

The new IOBuffer will assume ownership of the buffer, and free it by calling the specified FreeFunction when the last IOBuf pointing to this buffer is destroyed. The function will be called with a pointer to the buffer as the first argument, and the supplied userData value as the second argument. The free function must never throw exceptions.

If no FreeFunction is specified, the buffer will be freed using free() which will result in undefined behavior if the memory was allocated using 'new'.

The IOBuf data pointer will initially point to the start of the buffer,

In the first version of this function, the length of data is unspecified and is initialized to the capacity of the buffer

In the second version, the user specifies the valid length of data in the buffer

On error, std::bad_alloc will be thrown. If freeOnError is true (the default) the buffer will be freed before throwing the error.

Definition at line 304 of file IOBuf.h.

Referenced by folly::AsyncSocket::handleRead(), takeOwnershipIov(), and folly::ZeroCopyTestAsyncSocket::writeBuffer().

                                {
     return takeOwnership(
         buf, capacity, capacity, freeFn, userData, freeOnError);
   }

unique_ptr< IOBuf > folly::IOBuf::takeOwnership	(	void *	buf,
		std::size_t	capacity,
		std::size_t	length,
		FreeFunction	freeFn = `nullptr`,
		void *	userData = `nullptr`,
		bool	freeOnError = `true`
	)

static

Definition at line 313 of file IOBuf.cpp.

References capacity(), length(), and TAKE_OWNERSHIP.

                       {
   try {
     // TODO: We could allocate the IOBuf object and SharedInfo all in a single
     // memory allocation.  We could use the existing HeapStorage class, and
     // define a new kSharedInfoInUse flag.  We could change our code to call
     // releaseStorage(kFlagFreeSharedInfo) when this kFlagFreeSharedInfo,
     // rather than directly calling delete.
     //
     // Note that we always pass freeOnError as false to the constructor.
     // If the constructor throws we'll handle it below.  (We have to handle
     // allocation failures from std::make_unique too.)
     return std::make_unique<IOBuf>(
         TAKE_OWNERSHIP, buf, capacity, length, freeFn, userData, false);
   } catch (...) {
     takeOwnershipError(freeOnError, buf, freeFn, userData);
     throw;
   }
 }

template<class UniquePtr >

std::enable_if< detail::IsUniquePtrToSL< UniquePtr >::value, std::unique_ptr< IOBuf > >::type folly::IOBuf::takeOwnership	(	UniquePtr &&	buf,
		size_t	count = `1`
	)

static

Create a new IOBuf pointing to an existing data buffer made up of count objects of a given standard-layout type.

This is dangerous – it is essentially equivalent to doing reinterpret_cast<unsigned char*> on your data – but it's often useful for serialization / deserialization.

The new IOBuffer will assume ownership of the buffer, and free it appropriately (by calling the UniquePtr's custom deleter, or by calling delete or delete[] appropriately if there is no custom deleter) when the buffer is destroyed. The custom deleter, if any, must never throw exceptions.

The IOBuf data pointer will initially point to the start of the buffer, and the length will be the full capacity of the buffer (count * sizeof(T)).

On error, std::bad_alloc will be thrown, and the buffer will be freed before throwing the error.

Definition at line 1580 of file IOBuf.h.

References folly::size().

                                                   {
   size_t size = count * sizeof(typename UniquePtr::element_type);
   auto deleter = new UniquePtrDeleter<UniquePtr>(buf.get_deleter());
   return takeOwnership(
       buf.release(), size, &IOBuf::freeUniquePtrBuffer, deleter);
 }

std::unique_ptr< IOBuf > folly::IOBuf::takeOwnershipIov	(	const iovec *	vec,
		size_t	count,
		FreeFunction	freeFn = `nullptr`,
		void *	userData = `nullptr`,
		bool	freeOnError = `true`
	)

static

A helper that takes ownerships a number of iovecs into an IOBuf chain. If count == 0, then a zero length buf is returned. This function never returns nullptr.

Definition at line 1047 of file IOBuf.cpp.

References count, create(), data(), i, folly::gen::move, takeOwnership(), and UNLIKELY.

                       {
   unique_ptr<IOBuf> result = nullptr;
   for (size_t i = 0; i < count; ++i) {
     size_t len = vec[i].iov_len;
     void* data = vec[i].iov_base;
     if (len > 0) {
       auto buf = takeOwnership(data, len, freeFn, userData, freeOnError);
       if (!result) {
         result = std::move(buf);
       } else {
         result->prependChain(std::move(buf));
       }
     }
   }
   if (UNLIKELY(result == nullptr)) {
     return create(0);
   }
   return result;
 }

void folly::IOBuf::trimEnd ( std::size_t amount )

inline

Adjust the tail pointer backwards to include less valid data.

This moves the tail pointer backwards so that the last amount bytes are no longer considered valid data. The caller is responsible for ensuring that amount is less than or equal to the actual data length.

This does not modify any actual data in the buffer.

Definition at line 718 of file IOBuf.h.

References length_.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::cloneAtMost(), proxygen::ZlibStreamCompressor::compress(), proxygen::SPDYCodec::generateDataFrame(), TEST(), fizz::trimBytes(), and folly::TypedIOBuf< T >::trimEnd().

                                  {
     DCHECK_LE(amount, length_);
     length_ -= amount;
   }

void folly::IOBuf::trimStart ( std::size_t amount )

inline

Adjust the data pointer forwards to include less valid data.

This moves the data pointer forwards so that the first amount bytes are no longer considered valid data. The caller is responsible for ensuring that amount is less than or equal to the actual data length.

This does not modify any actual data in the buffer.

Definition at line 703 of file IOBuf.h.

References data_, and length_.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::cloneAtMost(), proxygen::compress::HPACKScheme::decode(), proxygen::compress::QMINScheme::decode(), folly::io::RWCursor< access >::insert(), TEST(), folly::io::test::TEST_P(), and folly::TypedIOBuf< T >::trimStart().

                                    {
     DCHECK_LE(amount, length_);
     data_ += amount;
     length_ -= amount;
   }

std::unique_ptr<IOBuf> folly::IOBuf::unlink ( )

inline

Remove this IOBuf from its current chain.

Since ownership of all elements an IOBuf chain is normally maintained by the head of the chain, unlink() transfers ownership of this IOBuf from the chain and gives it to the caller. A new unique_ptr to the IOBuf is returned to the caller. The caller must store the returned unique_ptr (or call release() on it) to take ownership, otherwise the IOBuf will be immediately destroyed.

Since unlink transfers ownership of the IOBuf to the caller, be careful not to call unlink() on the head of a chain if you already maintain ownership on the head of the chain via other means. The pop() method is a better choice for that situation.

Definition at line 847 of file IOBuf.h.

Referenced by operator=(), TEST(), and ~IOBuf().

                                 {
     next_->prev_ = prev_;
     prev_->next_ = next_;
     prev_ = this;
     next_ = this;
     return std::unique_ptr<IOBuf>(this);
   }

void folly::IOBuf::unshare ( )

inline

Ensure that this IOBuf has a unique buffer that is not shared by other IOBufs.

unshare() operates on an entire chain of IOBuf objects. If the chain is shared, it may also coalesce the chain when making it unique. If the chain is coalesced, subsequent IOBuf objects in the current chain will be automatically deleted.

Note that buffers owned by other (non-IOBuf) users are automatically considered shared.

Throws std::bad_alloc on error. On error the IOBuf chain will be unmodified.

Currently unshare may also throw std::overflow_error if it tries to coalesce. (TODO: In the future it would be nice if unshare() were smart enough not to coalesce the entire buffer if the data is too large. However, in practice this seems unlikely to become an issue.)

Definition at line 997 of file IOBuf.h.

Referenced by fillBuf(), and TEST().

                  {
     if (isChained()) {
       unshareChained();
     } else {
       unshareOne();
     }
   }

void folly::IOBuf::unshareChained ( )

private

Definition at line 632 of file IOBuf.cpp.

References coalesceSlow(), current, isChained(), isSharedOne(), and next_.

                            {
   // unshareChained() should only be called if we are part of a chain of
   // multiple IOBufs.  The caller should have already verified this.
   assert(isChained());
 
   IOBuf* current = this;
   while (true) {
     if (current->isSharedOne()) {
       // we have to unshare
       break;
     }
 
     current = current->next_;
     if (current == this) {
       // None of the IOBufs in the chain are shared,
       // so return without doing anything
       return;
     }
   }
 
   // We have to unshare.  Let coalesceSlow() do the work.
   coalesceSlow();
 }

void folly::IOBuf::unshareOne ( )

inline

Ensure that this IOBuf has a unique buffer that is not shared by other IOBufs.

unshareOne() operates on a single IOBuf object. This IOBuf will have a unique buffer after unshareOne() returns, but other IOBufs in the chain may still be shared after unshareOne() returns.

Throws std::bad_alloc on error. On error the IOBuf will be unmodified.

Definition at line 1015 of file IOBuf.h.

Referenced by TEST().

                     {
     if (isSharedOne()) {
       unshareOneSlow();
     }
   }

void folly::IOBuf::unshareOneSlow ( )

private

Definition at line 606 of file IOBuf.cpp.

References allocExtBuffer(), buf_, capacity_, data_, decrementRefcount(), headroom(), length_, setFlagsAndSharedInfo(), sharedInfo(), and uint8_t.

                            {
   // Allocate a new buffer for the data
   uint8_t* buf;
   SharedInfo* sharedInfo;
   std::size_t actualCapacity;
   allocExtBuffer(capacity_, &buf, &sharedInfo, &actualCapacity);
 
   // Copy the data
   // Maintain the same amount of headroom.  Since we maintained the same
   // minimum capacity we also maintain at least the same amount of tailroom.
   std::size_t headlen = headroom();
   if (length_ > 0) {
     assert(data_ != nullptr);
     memcpy(buf + headlen, data_, length_);
   }
 
   // Release our reference on the old buffer
   decrementRefcount();
   // Make sure kFlagMaybeShared and kFlagFreeSharedInfo are all cleared.
   setFlagsAndSharedInfo(0, sharedInfo);
 
   // Update the buffer pointers to point to the new buffer
   data_ = buf + headlen;
   buf_ = buf;
 }

unique_ptr< IOBuf > folly::IOBuf::wrapBuffer	(	const void *	buf,
		std::size_t	capacity
	)

static

Create a new IOBuf object that points to an existing user-owned buffer.

This should only be used when the caller knows the lifetime of the IOBuf object ahead of time and can ensure that all IOBuf objects that will point to this buffer will be destroyed before the buffer itself is destroyed.

This buffer will not be freed automatically when the last IOBuf referencing it is destroyed. It is the caller's responsibility to free the buffer after the last IOBuf has been destroyed.

The IOBuf data pointer will initially point to the start of the buffer, and the length will be the full capacity of the buffer.

An IOBuf created using wrapBuffer() will always be reported as shared. unshare() may be used to create a writable copy of the buffer.

On error, std::bad_alloc will be thrown.

Definition at line 353 of file IOBuf.cpp.

References capacity(), and WRAP_BUFFER.

Referenced by folly::AsyncSSLSocket::clientHelloParsingCallback(), fizz::server::AeadTokenCipher< AeadType, HkdfType >::createAead(), fizz::sm::getCertificateRequest(), fizz::Exporter::getEkm(), fizz::sm::getHrrKeyExchangers(), fizz::KeyScheduler::getResumptionSecret(), fizz::sm::handleCertMsg(), fizz::sm::handleEarlyAppWrite(), folly::bser::parseBser(), folly::io::test::StreamingCompressionTest::runFlushTest(), folly::io::test::CompressionTest::runSimpleIOBufTest(), folly::io::test::CompressionVarintTest::runSimpleTest(), folly::io::test::CompressionCorruptionTest::runSimpleTest(), folly::io::test::AutomaticCodecTest::runSimpleTest(), folly::io::test::StreamingCompressionTest::runUncompressStreamTest(), fizz::server::test::TEST(), folly::test::TEST(), TEST(), folly::io::test::TEST(), fizz::testing::TEST_P(), folly::io::test::TEST_P(), folly::IOBufQueue::wrapBuffer(), wrapIov(), folly::WriteChainAsyncTransportWrapper< folly::AsyncTransportWrapper >::write(), and folly::AsyncPipeWriter::write().

                                                                        {
   return std::make_unique<IOBuf>(WRAP_BUFFER, buf, capacity);
 }

static std::unique_ptr<IOBuf> folly::IOBuf::wrapBuffer ( ByteRange br )

inlinestatic

Definition at line 387 of file IOBuf.h.

References folly::Range< Iter >::data(), folly::pushmi::__adl::noexcept(), and folly::Range< Iter >::size().

                                                        {
     return wrapBuffer(br.data(), br.size());
   }

IOBuf folly::IOBuf::wrapBufferAsValue	(	const void *	buf,
		std::size_t	capacity
	)

staticnoexcept

Similar to wrapBuffer(), but returns IOBuf by value rather than heap-allocating it.

Definition at line 357 of file IOBuf.cpp.

References capacity(), and IOBuf().

Referenced by fizz::HkdfImpl< Hash >::extract(), fizz::EncryptedReadRecordLayer::getDecryptedBuf(), and fizz::EncryptedWriteRecordLayer::write().

                                                                            {
   return IOBuf(WrapBufferOp::WRAP_BUFFER, buf, capacity);
 }

static IOBuf folly::IOBuf::wrapBufferAsValue ( ByteRange br )

inlinestaticnoexcept

Definition at line 398 of file IOBuf.h.

References fizz::test::copyBuffer(), folly::pushmi::__adl::noexcept(), and folly::size().

                                                         {
     return wrapBufferAsValue(br.data(), br.size());
   }

unique_ptr< IOBuf > folly::IOBuf::wrapIov	(	const iovec *	vec,
		size_t	count
	)

static

A helper that wraps a number of iovecs into an IOBuf chain. If count == 0, then a zero length buf is returned. This function never returns nullptr.

Definition at line 1027 of file IOBuf.cpp.

References count, create(), data(), i, folly::gen::move, UNLIKELY, and wrapBuffer().

Referenced by folly::WriteChainAsyncTransportWrapper< folly::AsyncTransportWrapper >::writev().

                                                                {
   unique_ptr<IOBuf> result = nullptr;
   for (size_t i = 0; i < count; ++i) {
     size_t len = vec[i].iov_len;
     void* data = vec[i].iov_base;
     if (len > 0) {
       auto buf = wrapBuffer(data, len);
       if (!result) {
         result = std::move(buf);
       } else {
         result->prependChain(std::move(buf));
       }
     }
   }
   if (UNLIKELY(result == nullptr)) {
     return create(0);
   }
   return result;
 }

uint8_t* folly::IOBuf::writableBuffer ( )

inline

Get a writable pointer to the start of the buffer.

The caller is responsible for calling unshare() first to ensure that it is actually safe to write to the buffer.

Definition at line 572 of file IOBuf.h.

Referenced by folly::AsyncPipeReader::handlerReady(), reserveSlow(), and folly::TypedIOBuf< T >::writableBuffer().

                             {
     return buf_;
   }

uint8_t* folly::IOBuf::writableData ( )

inline

Get a writable pointer to the start of the data.

The caller is responsible for calling unshare() first to ensure that it is actually safe to write to the buffer.

Definition at line 509 of file IOBuf.h.

References data_.

Referenced by append(), fizz::detail::decFunc(), proxygen::HPACKDecodeBuffer::decodeLiteral(), fizz::detail::encFunc(), proxygen::GzipHeaderCodec::encode(), fizz::detail::evpEncrypt(), fillBuf(), IOBuf(), MoveToFbStringTest::makeBuf(), fizz::testing::modifyData(), fizz::testing::modifySig(), moveToFbString(), prepend(), proxygen::readFileToIOBuf(), CurlService::CurlClient::sendRequest(), TEST(), TEST_F(), fizz::transformBuffer(), and folly::TypedIOBuf< T >::writableData().

                           {
     return data_;
   }

uint8_t* folly::IOBuf::writableTail ( )

inline

Get a writable pointer to the end of the data.

The caller is responsible for calling unshare() first to ensure that it is actually safe to write to the buffer.

Definition at line 526 of file IOBuf.h.

References data_, and length_.

Referenced by folly::IOBufQueue::append(), folly::gen::detail::consumeBufferPlus(), folly::IOBufQueue::dcheckCacheIntegrity(), folly::io::StreamCodec::doUncompress(), moveToFbString(), TEST(), folly::IOBufQueue::updateWritableTailCache(), and folly::TypedIOBuf< T >::writableTail().

                           {
     return data_ + length_;
   }

Member Data Documentation

uint8_t* folly::IOBuf::buf_ {nullptr}

private

Definition at line 1433 of file IOBuf.h.

Referenced by cloneOneAsValue(), coalesceAndReallocate(), freeExtBuffer(), IOBuf(), moveToFbString(), operator=(), reserveSlow(), and unshareOneSlow().

std::size_t folly::IOBuf::capacity_ {0}

private

Definition at line 1435 of file IOBuf.h.

Referenced by cloneOneAsValue(), coalesceAndReallocate(), IOBuf(), operator=(), reserveSlow(), and unshareOneSlow().

uint8_t* folly::IOBuf::data_ {nullptr}

private

Definition at line 1432 of file IOBuf.h.

Referenced by cloneOneAsValue(), coalesceAndReallocate(), IOBuf(), operator=(), reserveSlow(), and unshareOneSlow().

uintptr_t folly::IOBuf::flagsAndSharedInfo_ {0}

mutableprivate

Definition at line 1438 of file IOBuf.h.

Referenced by cloneOneAsValue(), moveToFbString(), and operator=().

std::size_t folly::IOBuf::length_ {0}

private

Definition at line 1434 of file IOBuf.h.

Referenced by cloneOneAsValue(), coalesceAndReallocate(), coalesceSlow(), computeChainDataLength(), operator=(), reserveSlow(), and unshareOneSlow().

IOBuf* folly::IOBuf::next_ {this}

private

Definition at line 1423 of file IOBuf.h.

Referenced by cloneAsValue(), coalesceAndReallocate(), coalesceSlow(), computeChainDataLength(), countChainElements(), empty(), IOBuf(), isManaged(), isShared(), makeManagedChained(), markExternallyShared(), operator=(), prependChain(), separateChain(), unshareChained(), and ~IOBuf().

IOBuf* folly::IOBuf::prev_ {this}

private

Definition at line 1424 of file IOBuf.h.

Referenced by coalesceAndReallocate(), IOBuf(), operator=(), prependChain(), and separateChain().

The documentation for this class was generated from the following files:

proxygen/folly/folly/io/IOBuf.h
proxygen/folly/folly/io/IOBuf.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation