/* Initializes 'b' as an empty ofpbuf that contains the 'allocated' bytes of * memory starting at 'base'. 'base' should point to a buffer on the stack. * (Nothing actually relies on 'base' being allocated on the stack. It could * be static or malloc()'d memory. But stack space is the most common use * case.) * * 'base' should be appropriately aligned. Using an array of uint32_t or * uint64_t for the buffer is a reasonable way to ensure appropriate alignment * for 32- or 64-bit data. * * An ofpbuf operation that requires reallocating data will copy the provided * buffer into a malloc()'d buffer. Thus, it is wise to call ofpbuf_uninit() * on an ofpbuf initialized by this function, so that if it expanded into the * heap, that memory is freed. */ void ofpbuf_use_stub(struct ofpbuf *b, void *base, size_t allocated) { ofpbuf_use__(b, base, allocated, OFPBUF_STUB); }
/* Initializes 'b' as an empty ofpbuf that contains the 'allocated' bytes of * memory starting at 'base'. 'base' should be the first byte of a region * obtained from malloc(). It will be freed (with free()) if 'b' is resized or * freed. */ void ofpbuf_use(struct ofpbuf *b, void *base, size_t allocated) { ofpbuf_use__(b, base, allocated, OFPBUF_MALLOC); }
/* Initializes 'b' as an empty ofpbuf that contains the 'allocated' bytes of * memory starting at 'base'. 'base' should point to a buffer on the stack. * (Nothing actually relies on 'base' being allocated on the stack. It could * be static or malloc()'d memory. But stack space is the most common use * case.) * * 'base' should be appropriately aligned. Using an array of uint32_t or * uint64_t for the buffer is a reasonable way to ensure appropriate alignment * for 32- or 64-bit data. * * An ofpbuf operation that requires reallocating data will assert-fail if this * function was used to initialize it. Thus, one need not call ofpbuf_uninit() * on an ofpbuf initialized by this function (though doing so is harmless), * because it is guaranteed that 'b' does not own any heap-allocated memory. */ void ofpbuf_use_stack(struct ofpbuf *b, void *base, size_t allocated) { ofpbuf_use__(b, base, allocated, OFPBUF_STACK); }
/* Initializes 'b' as an ofpbuf whose data starts at 'data' and continues for * 'size' bytes. This is appropriate for an ofpbuf that will be used to * inspect existing data, without moving it around or reallocating it, and * generally without modifying it at all. * * An ofpbuf operation that requires reallocating data will assert-fail if this * function was used to initialize it. */ void ofpbuf_use_const(struct ofpbuf *b, const void *data, size_t size) { ofpbuf_use__(b, (void *) data, size, OFPBUF_STACK); b->size = size; }