[ovs-dev,[PATCH,RFC] 06/17] dp-packet: Use p for packet and b for batch.

diff --git a/lib/dp-packet.c b/lib/dp-packet.c
index 72f6d09ac..b4ee8c33c 100644
--- a/lib/dp-packet.c
+++ b/lib/dp-packet.c
@@ -25,58 +25,58 @@ 
 #include "util.h"
 
 static void
-dp_packet_init__(struct dp_packet *b, size_t allocated, enum dp_packet_source source)
-{
-    dp_packet_set_allocated(b, allocated);
-    b->source = source;
-    dp_packet_reset_offsets(b);
-    pkt_metadata_init(&b->md, 0);
-    dp_packet_reset_cutlen(b);
-    dp_packet_reset_offload(b);
+dp_packet_init__(struct dp_packet *p, size_t allocated, enum dp_packet_source source)
+{
+    dp_packet_set_allocated(p, allocated);
+    p->source = source;
+    dp_packet_reset_offsets(p);
+    pkt_metadata_init(&p->md, 0);
+    dp_packet_reset_cutlen(p);
+    dp_packet_reset_offload(p);
     /* Initialize implementation-specific fields of dp_packet. */
-    dp_packet_init_specific(b);
+    dp_packet_init_specific(p);
     /* By default assume the packet type to be Ethernet. */
-    b->packet_type = htonl(PT_ETH);
+    p->packet_type = htonl(PT_ETH);
 }
 
 static void
-dp_packet_use__(struct dp_packet *b, void *base, size_t allocated,
+dp_packet_use__(struct dp_packet *p, void *base, size_t allocated,
              enum dp_packet_source source)
 {
-    dp_packet_set_base(b, base);
-    dp_packet_set_data(b, base);
-    dp_packet_set_size(b, 0);
+    dp_packet_set_base(p, base);
+    dp_packet_set_data(p, base);
+    dp_packet_set_size(p, 0);
 
-    dp_packet_init__(b, allocated, source);
+    dp_packet_init__(p, allocated, source);
 }
 
-/* Initializes 'b' as an empty dp_packet that contains the 'allocated' bytes of
+/* Initializes 'p' as an empty dp_packet 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
+ * obtained from malloc().  It will be freed (with free()) if 'p' is resized or
  * freed. */
 void
-dp_packet_use(struct dp_packet *b, void *base, size_t allocated)
+dp_packet_use(struct dp_packet *p, void *base, size_t allocated)
 {
-    dp_packet_use__(b, base, allocated, DPBUF_MALLOC);
+    dp_packet_use__(p, base, allocated, DPBUF_MALLOC);
 }
 
 #if HAVE_AF_XDP
-/* Initialize 'b' as an empty dp_packet that contains
+/* Initialize 'p' as an empty dp_packet that contains
  * memory starting at AF_XDP umem base.
  */
 void
-dp_packet_use_afxdp(struct dp_packet *b, void *data, size_t allocated,
+dp_packet_use_afxdp(struct dp_packet *p, void *data, size_t allocated,
                     size_t headroom)
 {
-    dp_packet_set_base(b, (char *)data - headroom);
-    dp_packet_set_data(b, data);
-    dp_packet_set_size(b, 0);
+    dp_packet_set_base(p, (char *)data - headroom);
+    dp_packet_set_data(p, data);
+    dp_packet_set_size(p, 0);
 
-    dp_packet_init__(b, allocated, DPBUF_AFXDP);
+    dp_packet_init__(p, allocated, DPBUF_AFXDP);
 }
 #endif
 
-/* Initializes 'b' as an empty dp_packet that contains the 'allocated' bytes of
+/* Initializes 'p' as an empty dp_packet 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
@@ -91,12 +91,12 @@  dp_packet_use_afxdp(struct dp_packet *b, void *data, size_t allocated,
  * on an dp_packet initialized by this function, so that if it expanded into the
  * heap, that memory is freed. */
 void
-dp_packet_use_stub(struct dp_packet *b, void *base, size_t allocated)
+dp_packet_use_stub(struct dp_packet *p, void *base, size_t allocated)
 {
-    dp_packet_use__(b, base, allocated, DPBUF_STUB);
+    dp_packet_use__(p, base, allocated, DPBUF_STUB);
 }
 
-/* Initializes 'b' as an dp_packet whose data starts at 'data' and continues for
+/* Initializes 'p' as an dp_packet whose data starts at 'data' and continues for
  * 'size' bytes.  This is appropriate for an dp_packet that will be used to
  * inspect existing data, without moving it around or reallocating it, and
  * generally without modifying it at all.
@@ -104,43 +104,43 @@  dp_packet_use_stub(struct dp_packet *b, void *base, size_t allocated)
  * An dp_packet operation that requires reallocating data will assert-fail if this
  * function was used to initialize it. */
 void
-dp_packet_use_const(struct dp_packet *b, const void *data, size_t size)
+dp_packet_use_const(struct dp_packet *p, const void *data, size_t size)
 {
-    dp_packet_use__(b, CONST_CAST(void *, data), size, DPBUF_STACK);
-    dp_packet_set_size(b, size);
+    dp_packet_use__(p, CONST_CAST(void *, data), size, DPBUF_STACK);
+    dp_packet_set_size(p, size);
 }
 
-/* Initializes 'b' as a DPDK dp-packet, which must have been allocated from a
+/* Initializes 'p' as a DPDK dp-packet, which must have been allocated from a
  * DPDK memory pool. */
 void
-dp_packet_init_dpdk(struct dp_packet *b)
+dp_packet_init_dpdk(struct dp_packet *p)
 {
-    b->source = DPBUF_DPDK;
+    p->source = DPBUF_DPDK;
 }
 
-/* Initializes 'b' as an empty dp_packet with an initial capacity of 'size'
+/* Initializes 'p' as an empty dp_packet with an initial capacity of 'size'
  * bytes. */
 void
-dp_packet_init(struct dp_packet *b, size_t size)
+dp_packet_init(struct dp_packet *p, size_t size)
 {
-    dp_packet_use(b, size ? xmalloc(size) : NULL, size);
+    dp_packet_use(p, size ? xmalloc(size) : NULL, size);
 }
 
-/* Frees memory that 'b' points to. */
+/* Frees memory that 'p' points to. */
 void
-dp_packet_uninit(struct dp_packet *b)
+dp_packet_uninit(struct dp_packet *p)
 {
-    if (b) {
-        if (b->source == DPBUF_MALLOC) {
-            free(dp_packet_base(b));
-        } else if (b->source == DPBUF_DPDK) {
+    if (p) {
+        if (p->source == DPBUF_MALLOC) {
+            free(dp_packet_base(p));
+        } else if (p->source == DPBUF_DPDK) {
 #ifdef DPDK_NETDEV
             /* If this dp_packet was allocated by DPDK it must have been
              * created as a dp_packet */
-            free_dpdk_buf((struct dp_packet*) b);
+            free_dpdk_buf((struct dp_packet*) p);
 #endif
-        } else if (b->source == DPBUF_AFXDP) {
-            free_afxdp_buf(b);
+        } else if (p->source == DPBUF_AFXDP) {
+            free_afxdp_buf(p);
         }
     }
 }
@@ -150,9 +150,9 @@  dp_packet_uninit(struct dp_packet *b)
 struct dp_packet *
 dp_packet_new(size_t size)
 {
-    struct dp_packet *b = xmalloc(sizeof *b);
-    dp_packet_init(b, size);
-    return b;
+    struct dp_packet *p = xmalloc(sizeof *p);
+    dp_packet_init(p, size);
+    return p;
 }
 
 /* Creates and returns a new dp_packet with an initial capacity of 'size +
@@ -160,45 +160,45 @@  dp_packet_new(size_t size)
 struct dp_packet *
 dp_packet_new_with_headroom(size_t size, size_t headroom)
 {
-    struct dp_packet *b = dp_packet_new(size + headroom);
-    dp_packet_reserve(b, headroom);
-    return b;
+    struct dp_packet *p = dp_packet_new(size + headroom);
+    dp_packet_reserve(p, headroom);
+    return p;
 }
 
 /* Creates and returns a new dp_packet that initially contains a copy of the
  * 'dp_packet_size(buffer)' bytes of data starting at 'buffer->data' with no headroom or
  * tailroom. */
 struct dp_packet *
-dp_packet_clone(const struct dp_packet *buffer)
+dp_packet_clone(const struct dp_packet *p)
 {
-    return dp_packet_clone_with_headroom(buffer, 0);
+    return dp_packet_clone_with_headroom(p, 0);
 }
 
-/* Creates and returns a new dp_packet whose data are copied from 'buffer'.
+/* Creates and returns a new dp_packet whose data are copied from packet 'p'.
  * The returned dp_packet will additionally have 'headroom' bytes of
  * headroom. */
 struct dp_packet *
-dp_packet_clone_with_headroom(const struct dp_packet *buffer, size_t headroom)
+dp_packet_clone_with_headroom(const struct dp_packet *p, size_t headroom)
 {
     struct dp_packet *new_buffer;
     uint32_t mark;
 
-    new_buffer = dp_packet_clone_data_with_headroom(dp_packet_data(buffer),
-                                                 dp_packet_size(buffer),
-                                                 headroom);
+    new_buffer = dp_packet_clone_data_with_headroom(dp_packet_data(p),
+                                                    dp_packet_size(p),
+                                                    headroom);
     /* Copy the following fields into the returned buffer: l2_pad_size,
      * l2_5_ofs, l3_ofs, l4_ofs, cutlen, packet_type and md. */
-    memcpy(&new_buffer->l2_pad_size, &buffer->l2_pad_size,
+    memcpy(&new_buffer->l2_pad_size, &p->l2_pad_size,
             sizeof(struct dp_packet) -
             offsetof(struct dp_packet, l2_pad_size));
 
-    *dp_packet_ol_flags_ptr(new_buffer) = *dp_packet_ol_flags_ptr(buffer);
+    *dp_packet_ol_flags_ptr(new_buffer) = *dp_packet_ol_flags_ptr(p);
     *dp_packet_ol_flags_ptr(new_buffer) &= DP_PACKET_OL_SUPPORTED_MASK;
 
-    if (dp_packet_rss_valid(buffer)) {
-        dp_packet_set_rss_hash(new_buffer, dp_packet_get_rss_hash(buffer));
+    if (dp_packet_rss_valid(p)) {
+        dp_packet_set_rss_hash(new_buffer, dp_packet_get_rss_hash(p));
     }
-    if (dp_packet_has_flow_mark(buffer, &mark)) {
+    if (dp_packet_has_flow_mark(p, &mark)) {
         dp_packet_set_flow_mark(new_buffer, mark);
     }
 
@@ -219,47 +219,47 @@  dp_packet_clone_data(const void *data, size_t size)
 struct dp_packet *
 dp_packet_clone_data_with_headroom(const void *data, size_t size, size_t headroom)
 {
-    struct dp_packet *b = dp_packet_new_with_headroom(size, headroom);
-    dp_packet_put(b, data, size);
-    return b;
+    struct dp_packet *p = dp_packet_new_with_headroom(size, headroom);
+    dp_packet_put(p, data, size);
+    return p;
 }
 
 static void
-dp_packet_copy__(struct dp_packet *b, uint8_t *new_base,
+dp_packet_copy__(struct dp_packet *p, uint8_t *new_base,
               size_t new_headroom, size_t new_tailroom)
 {
-    const uint8_t *old_base = dp_packet_base(b);
-    size_t old_headroom = dp_packet_headroom(b);
-    size_t old_tailroom = dp_packet_tailroom(b);
+    const uint8_t *old_base = dp_packet_base(p);
+    size_t old_headroom = dp_packet_headroom(p);
+    size_t old_tailroom = dp_packet_tailroom(p);
     size_t copy_headroom = MIN(old_headroom, new_headroom);
     size_t copy_tailroom = MIN(old_tailroom, new_tailroom);
 
     memcpy(&new_base[new_headroom - copy_headroom],
            &old_base[old_headroom - copy_headroom],
-           copy_headroom + dp_packet_size(b) + copy_tailroom);
+           copy_headroom + dp_packet_size(p) + copy_tailroom);
 }
 
-/* Reallocates 'b' so that it has exactly 'new_headroom' and 'new_tailroom'
+/* Reallocates 'p' so that it has exactly 'new_headroom' and 'new_tailroom'
  * bytes of headroom and tailroom, respectively. */
 void
-dp_packet_resize(struct dp_packet *b, size_t new_headroom, size_t new_tailroom)
+dp_packet_resize(struct dp_packet *p, size_t new_headroom, size_t new_tailroom)
 {
     void *new_base, *new_data;
     size_t new_allocated;
 
-    new_allocated = new_headroom + dp_packet_size(b) + new_tailroom;
+    new_allocated = new_headroom + dp_packet_size(p) + new_tailroom;
 
-    switch (b->source) {
+    switch (p->source) {
     case DPBUF_DPDK:
         OVS_NOT_REACHED();
 
     case DPBUF_MALLOC:
-        if (new_headroom == dp_packet_headroom(b)) {
-            new_base = xrealloc(dp_packet_base(b), new_allocated);
+        if (new_headroom == dp_packet_headroom(p)) {
+            new_base = xrealloc(dp_packet_base(p), new_allocated);
         } else {
             new_base = xmalloc(new_allocated);
-            dp_packet_copy__(b, new_base, new_headroom, new_tailroom);
-            free(dp_packet_base(b));
+            dp_packet_copy__(p, new_base, new_headroom, new_tailroom);
+            free(dp_packet_base(p));
         }
         break;
 
@@ -270,108 +270,108 @@  dp_packet_resize(struct dp_packet *b, size_t new_headroom, size_t new_tailroom)
         OVS_NOT_REACHED();
 
     case DPBUF_STUB:
-        b->source = DPBUF_MALLOC;
+        p->source = DPBUF_MALLOC;
         new_base = xmalloc(new_allocated);
-        dp_packet_copy__(b, new_base, new_headroom, new_tailroom);
+        dp_packet_copy__(p, new_base, new_headroom, new_tailroom);
         break;
 
     default:
         OVS_NOT_REACHED();
     }
 
-    dp_packet_set_allocated(b, new_allocated);
-    dp_packet_set_base(b, new_base);
+    dp_packet_set_allocated(p, new_allocated);
+    dp_packet_set_base(p, new_base);
 
     new_data = (char *) new_base + new_headroom;
-    if (dp_packet_data(b) != new_data) {
-        dp_packet_set_data(b, new_data);
+    if (dp_packet_data(p) != new_data) {
+        dp_packet_set_data(p, new_data);
     }
 }
 
-/* Ensures that 'b' has room for at least 'size' bytes at its tail end,
+/* Ensures that 'p' has room for at least 'size' bytes at its tail end,
  * reallocating and copying its data if necessary.  Its headroom, if any, is
  * preserved. */
 void
-dp_packet_prealloc_tailroom(struct dp_packet *b, size_t size)
+dp_packet_prealloc_tailroom(struct dp_packet *p, size_t size)
 {
-    if (size > dp_packet_tailroom(b)) {
-        dp_packet_resize(b, dp_packet_headroom(b), MAX(size, 64));
+    if (size > dp_packet_tailroom(p)) {
+        dp_packet_resize(p, dp_packet_headroom(p), MAX(size, 64));
     }
 }
 
-/* Ensures that 'b' has room for at least 'size' bytes at its head,
+/* Ensures that 'p' has room for at least 'size' bytes at its head,
  * reallocating and copying its data if necessary.  Its tailroom, if any, is
  * preserved. */
 void
-dp_packet_prealloc_headroom(struct dp_packet *b, size_t size)
+dp_packet_prealloc_headroom(struct dp_packet *p, size_t size)
 {
-    if (size > dp_packet_headroom(b)) {
-        dp_packet_resize(b, MAX(size, 64), dp_packet_tailroom(b));
+    if (size > dp_packet_headroom(p)) {
+        dp_packet_resize(p, MAX(size, 64), dp_packet_tailroom(p));
     }
 }
 
-/* Shifts all of the data within the allocated space in 'b' by 'delta' bytes.
+/* Shifts all of the data within the allocated space in 'p' by 'delta' bytes.
  * For example, a 'delta' of 1 would cause each byte of data to move one byte
  * forward (from address 'p' to 'p+1'), and a 'delta' of -1 would cause each
  * byte to move one byte backward (from 'p' to 'p-1'). */
 void
-dp_packet_shift(struct dp_packet *b, int delta)
+dp_packet_shift(struct dp_packet *p, int delta)
 {
-    ovs_assert(delta > 0 ? delta <= dp_packet_tailroom(b)
-               : delta < 0 ? -delta <= dp_packet_headroom(b)
+    ovs_assert(delta > 0 ? delta <= dp_packet_tailroom(p)
+               : delta < 0 ? -delta <= dp_packet_headroom(p)
                : true);
 
     if (delta != 0) {
-        char *dst = (char *) dp_packet_data(b) + delta;
-        memmove(dst, dp_packet_data(b), dp_packet_size(b));
-        dp_packet_set_data(b, dst);
+        char *dst = (char *) dp_packet_data(p) + delta;
+        memmove(dst, dp_packet_data(p), dp_packet_size(p));
+        dp_packet_set_data(p, dst);
     }
 }
 
-/* Appends 'size' bytes of data to the tail end of 'b', reallocating and
+/* Appends 'size' bytes of data to the tail end of 'p', reallocating and
  * copying its data if necessary.  Returns a pointer to the first byte of the
  * new data, which is left uninitialized. */
 void *
-dp_packet_put_uninit(struct dp_packet *b, size_t size)
+dp_packet_put_uninit(struct dp_packet *p, size_t size)
 {
-    void *p;
-    dp_packet_prealloc_tailroom(b, size);
-    p = dp_packet_tail(b);
-    dp_packet_set_size(b, dp_packet_size(b) + size);
-    return p;
+    void *tail;
+    dp_packet_prealloc_tailroom(p, size);
+    tail = dp_packet_tail(p);
+    dp_packet_set_size(p, dp_packet_size(p) + size);
+    return tail;
 }
 
-/* Appends 'size' zeroed bytes to the tail end of 'b'.  Data in 'b' is
+/* Appends 'size' zeroed bytes to the tail end of 'p'.  Data in 'p' is
  * reallocated and copied if necessary.  Returns a pointer to the first byte of
  * the data's location in the dp_packet. */
 void *
-dp_packet_put_zeros(struct dp_packet *b, size_t size)
+dp_packet_put_zeros(struct dp_packet *p, size_t size)
 {
-    void *dst = dp_packet_put_uninit(b, size);
+    void *dst = dp_packet_put_uninit(p, size);
     memset(dst, 0, size);
     return dst;
 }
 
-/* Appends the 'size' bytes of data in 'p' to the tail end of 'b'.  Data in 'b'
- * is reallocated and copied if necessary.  Returns a pointer to the first
- * byte of the data's location in the dp_packet. */
+/* Appends the 'size' bytes of data in 'data' to the tail end of 'p'.
+ * Data in 'data' is reallocated and copied if necessary.  Returns
+ * a pointer to the first byte of the data's location in the dp_packet. */
 void *
-dp_packet_put(struct dp_packet *b, const void *p, size_t size)
+dp_packet_put(struct dp_packet *p, const void *data, size_t size)
 {
-    void *dst = dp_packet_put_uninit(b, size);
-    memcpy(dst, p, size);
+    void *dst = dp_packet_put_uninit(p, size);
+    memcpy(dst, data, size);
     return dst;
 }
 
 /* Parses as many pairs of hex digits as possible (possibly separated by
- * spaces) from the beginning of 's', appending bytes for their values to 'b'.
+ * spaces) from the beginning of 's', appending bytes for their values to 'p'.
  * Returns the first character of 's' that is not the first of a pair of hex
- * digits.  If 'n' is nonnull, stores the number of bytes added to 'b' in
+ * digits.  If 'n' is nonnull, stores the number of bytes added to 'p' in
  * '*n'. */
 char *
-dp_packet_put_hex(struct dp_packet *b, const char *s, size_t *n)
+dp_packet_put_hex(struct dp_packet *p, const char *s, size_t *n)
 {
-    size_t initial_size = dp_packet_size(b);
+    size_t initial_size = dp_packet_size(p);
     for (;;) {
         uint8_t byte;
         bool ok;
@@ -380,12 +380,12 @@  dp_packet_put_hex(struct dp_packet *b, const char *s, size_t *n)
         byte = hexits_value(s, 2, &ok);
         if (!ok) {
             if (n) {
-                *n = dp_packet_size(b) - initial_size;
+                *n = dp_packet_size(p) - initial_size;
             }
             return CONST_CAST(char *, s);
         }
 
-        dp_packet_put(b, &byte, 1);
+        dp_packet_put(p, &byte, 1);
         s += 2;
     }
 }
@@ -393,80 +393,80 @@  dp_packet_put_hex(struct dp_packet *b, const char *s, size_t *n)
 /* Reserves 'size' bytes of headroom so that they can be later allocated with
  * dp_packet_push_uninit() without reallocating the dp_packet. */
 void
-dp_packet_reserve(struct dp_packet *b, size_t size)
+dp_packet_reserve(struct dp_packet *p, size_t size)
 {
-    ovs_assert(!dp_packet_size(b));
-    dp_packet_prealloc_tailroom(b, size);
-    dp_packet_set_data(b, (char*)dp_packet_data(b) + size);
+    ovs_assert(!dp_packet_size(p));
+    dp_packet_prealloc_tailroom(p, size);
+    dp_packet_set_data(p, (char*)dp_packet_data(p) + size);
 }
 
 /* Reserves 'headroom' bytes at the head and 'tailroom' at the end so that
  * they can be later allocated with dp_packet_push_uninit() or
  * dp_packet_put_uninit() without reallocating the dp_packet. */
 void
-dp_packet_reserve_with_tailroom(struct dp_packet *b, size_t headroom,
+dp_packet_reserve_with_tailroom(struct dp_packet *p, size_t headroom,
                              size_t tailroom)
 {
-    ovs_assert(!dp_packet_size(b));
-    dp_packet_prealloc_tailroom(b, headroom + tailroom);
-    dp_packet_set_data(b, (char*)dp_packet_data(b) + headroom);
+    ovs_assert(!dp_packet_size(p));
+    dp_packet_prealloc_tailroom(p, headroom + tailroom);
+    dp_packet_set_data(p, (char*)dp_packet_data(p) + headroom);
 }
 
-/* Prefixes 'size' bytes to the head end of 'b', reallocating and copying its
+/* Prefixes 'size' bytes to the head end of 'p', reallocating and copying its
  * data if necessary.  Returns a pointer to the first byte of the data's
  * location in the dp_packet.  The new data is left uninitialized. */
 void *
-dp_packet_push_uninit(struct dp_packet *b, size_t size)
+dp_packet_push_uninit(struct dp_packet *p, size_t size)
 {
-    dp_packet_prealloc_headroom(b, size);
-    dp_packet_set_data(b, (char*)dp_packet_data(b) - size);
-    dp_packet_set_size(b, dp_packet_size(b) + size);
-    return dp_packet_data(b);
+    dp_packet_prealloc_headroom(p, size);
+    dp_packet_set_data(p, (char*)dp_packet_data(p) - size);
+    dp_packet_set_size(p, dp_packet_size(p) + size);
+    return dp_packet_data(p);
 }
 
-/* Prefixes 'size' zeroed bytes to the head end of 'b', reallocating and
+/* Prefixes 'size' zeroed bytes to the head end of 'p', reallocating and
  * copying its data if necessary.  Returns a pointer to the first byte of the
  * data's location in the dp_packet. */
 void *
-dp_packet_push_zeros(struct dp_packet *b, size_t size)
+dp_packet_push_zeros(struct dp_packet *p, size_t size)
 {
-    void *dst = dp_packet_push_uninit(b, size);
+    void *dst = dp_packet_push_uninit(p, size);
     memset(dst, 0, size);
     return dst;
 }
 
-/* Copies the 'size' bytes starting at 'p' to the head end of 'b', reallocating
- * and copying its data if necessary.  Returns a pointer to the first byte of
- * the data's location in the dp_packet. */
+/* Copies the 'size' bytes starting at 'data' to the head end of 'p',
+ * reallocating and copying its data if necessary.  Returns a pointer
+ * to the first byte of the data's location in the dp_packet. */
 void *
-dp_packet_push(struct dp_packet *b, const void *p, size_t size)
+dp_packet_push(struct dp_packet *p, const void *data, size_t size)
 {
-    void *dst = dp_packet_push_uninit(b, size);
-    memcpy(dst, p, size);
+    void *dst = dp_packet_push_uninit(p, size);
+    memcpy(dst, data, size);
     return dst;
 }
 
-/* Returns the data in 'b' as a block of malloc()'d memory and frees the buffer
- * within 'b'.  (If 'b' itself was dynamically allocated, e.g. with
+/* Returns the data in 'p' as a block of malloc()'d memory and frees the buffer
+ * within 'p'.  (If 'p' itself was dynamically allocated, e.g. with
  * dp_packet_new(), then it should still be freed with, e.g., dp_packet_delete().) */
 void *
-dp_packet_steal_data(struct dp_packet *b)
+dp_packet_steal_data(struct dp_packet *p)
 {
-    void *p;
-    ovs_assert(b->source != DPBUF_DPDK);
-    ovs_assert(b->source != DPBUF_AFXDP);
+    void *data;
+    ovs_assert(p->source != DPBUF_DPDK);
+    ovs_assert(p->source != DPBUF_AFXDP);
 
-    if (b->source == DPBUF_MALLOC && dp_packet_data(b) == dp_packet_base(b)) {
-        p = dp_packet_data(b);
+    if (p->source == DPBUF_MALLOC && dp_packet_data(p) == dp_packet_base(p)) {
+        data = dp_packet_data(p);
     } else {
-        p = xmemdup(dp_packet_data(b), dp_packet_size(b));
-        if (b->source == DPBUF_MALLOC) {
-            free(dp_packet_base(b));
+        data = xmemdup(dp_packet_data(p), dp_packet_size(p));
+        if (p->source == DPBUF_MALLOC) {
+            free(dp_packet_base(p));
         }
     }
-    dp_packet_set_base(b, NULL);
-    dp_packet_set_data(b, NULL);
-    return p;
+    dp_packet_set_base(p, NULL);
+    dp_packet_set_data(p, NULL);
+    return data;
 }
 
 static inline void
@@ -481,28 +481,28 @@  dp_packet_adjust_layer_offset(uint16_t *offset, int increment)
  * pointer and the layer offsets.  The caller is responsible for
  * modifying the contents. */
 void *
-dp_packet_resize_l2_5(struct dp_packet *b, int increment)
+dp_packet_resize_l2_5(struct dp_packet *p, int increment)
 {
     if (increment >= 0) {
-        dp_packet_push_uninit(b, increment);
+        dp_packet_push_uninit(p, increment);
     } else {
-        dp_packet_pull(b, -increment);
+        dp_packet_pull(p, -increment);
     }
 
     /* Adjust layer offsets after l2_5. */
-    dp_packet_adjust_layer_offset(&b->l3_ofs, increment);
-    dp_packet_adjust_layer_offset(&b->l4_ofs, increment);
+    dp_packet_adjust_layer_offset(&p->l3_ofs, increment);
+    dp_packet_adjust_layer_offset(&p->l4_ofs, increment);
 
-    return dp_packet_data(b);
+    return dp_packet_data(p);
 }
 
 /* Adjust the size of the l2 portion of the dp_packet, updating the l2
  * pointer and the layer offsets.  The caller is responsible for
  * modifying the contents. */
 void *
-dp_packet_resize_l2(struct dp_packet *b, int increment)
+dp_packet_resize_l2(struct dp_packet *p, int increment)
 {
-    dp_packet_resize_l2_5(b, increment);
-    dp_packet_adjust_layer_offset(&b->l2_5_ofs, increment);
-    return dp_packet_data(b);
+    dp_packet_resize_l2_5(p, increment);
+    dp_packet_adjust_layer_offset(&p->l2_5_ofs, increment);
+    return dp_packet_data(p);
 }
diff --git a/lib/dp-packet.h b/lib/dp-packet.h
index 82eae87b6..8b06e457b 100644
--- a/lib/dp-packet.h
+++ b/lib/dp-packet.h
@@ -196,7 +196,7 @@  struct dp_packet *dp_packet_clone_with_headroom(const struct dp_packet *,
 struct dp_packet *dp_packet_clone_data(const void *, size_t);
 struct dp_packet *dp_packet_clone_data_with_headroom(const void *, size_t,
                                                      size_t headroom);
-void dp_packet_resize(struct dp_packet *b, size_t new_headroom,
+void dp_packet_resize(struct dp_packet *p, size_t new_headroom,
                       size_t new_tailroom);
 static inline void dp_packet_delete(struct dp_packet *);
 static inline void dp_packet_swap(struct dp_packet *, struct dp_packet *);
@@ -235,25 +235,25 @@  static inline bool dp_packet_equal(const struct dp_packet *,
                                    const struct dp_packet *);
 
 
-/* Frees memory that 'b' points to, as well as 'b' itself. */
+/* Frees memory that 'p' points to, as well as 'p' itself. */
 static inline void
-dp_packet_delete(struct dp_packet *b)
+dp_packet_delete(struct dp_packet *p)
 {
-    if (b) {
-        if (b->source == DPBUF_DPDK) {
+    if (p) {
+        if (p->source == DPBUF_DPDK) {
             /* If this dp_packet was allocated by DPDK it must have been
              * created as a dp_packet */
-            free_dpdk_buf((struct dp_packet*) b);
+            free_dpdk_buf((struct dp_packet*) p);
             return;
         }
 
-        if (b->source == DPBUF_AFXDP) {
-            free_afxdp_buf(b);
+        if (p->source == DPBUF_AFXDP) {
+            free_afxdp_buf(p);
             return;
         }
 
-        dp_packet_uninit(b);
-        free(b);
+        dp_packet_uninit(p);
+        free(p);
     }
 }
 
@@ -269,207 +269,207 @@  dp_packet_swap(struct dp_packet *a, struct dp_packet *b)
     *b = c;
 }
 
-/* If 'b' contains at least 'offset + size' bytes of data, returns a pointer to
+/* If 'p' contains at least 'offset + size' bytes of data, returns a pointer to
  * byte 'offset'.  Otherwise, returns a null pointer. */
 static inline void *
-dp_packet_at(const struct dp_packet *b, size_t offset, size_t size)
+dp_packet_at(const struct dp_packet *p, size_t offset, size_t size)
 {
-    return offset + size <= dp_packet_size(b)
-           ? (char *) dp_packet_data(b) + offset
+    return offset + size <= dp_packet_size(p)
+           ? (char *) dp_packet_data(p) + offset
            : NULL;
 }
 
-/* Returns a pointer to byte 'offset' in 'b', which must contain at least
+/* Returns a pointer to byte 'offset' in 'p', which must contain at least
  * 'offset + size' bytes of data. */
 static inline void *
-dp_packet_at_assert(const struct dp_packet *b, size_t offset, size_t size)
+dp_packet_at_assert(const struct dp_packet *p, size_t offset, size_t size)
 {
-    ovs_assert(offset + size <= dp_packet_size(b));
-    return ((char *) dp_packet_data(b)) + offset;
+    ovs_assert(offset + size <= dp_packet_size(p));
+    return ((char *) dp_packet_data(p)) + offset;
 }
 
-/* Returns a pointer to byte following the last byte of data in use in 'b'. */
+/* Returns a pointer to byte following the last byte of data in use in 'p'. */
 static inline void *
-dp_packet_tail(const struct dp_packet *b)
+dp_packet_tail(const struct dp_packet *p)
 {
-    return (char *) dp_packet_data(b) + dp_packet_size(b);
+    return (char *) dp_packet_data(p) + dp_packet_size(p);
 }
 
 /* Returns a pointer to byte following the last byte allocated for use (but
- * not necessarily in use) in 'b'. */
+ * not necessarily in use) in 'p'. */
 static inline void *
-dp_packet_end(const struct dp_packet *b)
+dp_packet_end(const struct dp_packet *p)
 {
-    return (char *) dp_packet_base(b) + dp_packet_get_allocated(b);
+    return (char *) dp_packet_base(p) + dp_packet_get_allocated(p);
 }
 
-/* Returns the number of bytes of headroom in 'b', that is, the number of bytes
- * of unused space in dp_packet 'b' before the data that is in use.  (Most
+/* Returns the number of bytes of headroom in 'p', that is, the number of bytes
+ * of unused space in dp_packet 'p' before the data that is in use.  (Most
  * commonly, the data in a dp_packet is at its beginning, and thus the
  * dp_packet's headroom is 0.) */
 static inline size_t
-dp_packet_headroom(const struct dp_packet *b)
+dp_packet_headroom(const struct dp_packet *p)
 {
-    return (char *) dp_packet_data(b) - (char *) dp_packet_base(b);
+    return (char *) dp_packet_data(p) - (char *) dp_packet_base(p);
 }
 
 /* Returns the number of bytes that may be appended to the tail end of
- * dp_packet 'b' before the dp_packet must be reallocated. */
+ * dp_packet 'p' before the dp_packet must be reallocated. */
 static inline size_t
-dp_packet_tailroom(const struct dp_packet *b)
+dp_packet_tailroom(const struct dp_packet *p)
 {
-    return (char *) dp_packet_end(b) - (char *) dp_packet_tail(b);
+    return (char *) dp_packet_end(p) - (char *) dp_packet_tail(p);
 }
 
-/* Clears any data from 'b'. */
+/* Clears any data from 'p'. */
 static inline void
-dp_packet_clear(struct dp_packet *b)
+dp_packet_clear(struct dp_packet *p)
 {
-    dp_packet_set_data(b, dp_packet_base(b));
-    dp_packet_set_size(b, 0);
+    dp_packet_set_data(p, dp_packet_base(p));
+    dp_packet_set_size(p, 0);
 }
 
-/* Removes 'size' bytes from the head end of 'b', which must contain at least
+/* Removes 'size' bytes from the head end of 'p', which must contain at least
  * 'size' bytes of data.  Returns the first byte of data removed. */
 static inline void *
-dp_packet_pull(struct dp_packet *b, size_t size)
+dp_packet_pull(struct dp_packet *p, size_t size)
 {
-    void *data = dp_packet_data(b);
-    ovs_assert(dp_packet_size(b) - dp_packet_l2_pad_size(b) >= size);
-    dp_packet_set_data(b, (char *) dp_packet_data(b) + size);
-    dp_packet_set_size(b, dp_packet_size(b) - size);
+    void *data = dp_packet_data(p);
+    ovs_assert(dp_packet_size(p) - dp_packet_l2_pad_size(p) >= size);
+    dp_packet_set_data(p, (char *) dp_packet_data(p) + size);
+    dp_packet_set_size(p, dp_packet_size(p) - size);
     return data;
 }
 
-/* If 'b' has at least 'size' bytes of data, removes that many bytes from the
- * head end of 'b' and returns the first byte removed.  Otherwise, returns a
- * null pointer without modifying 'b'. */
+/* If 'p' has at least 'size' bytes of data, removes that many bytes from the
+ * head end of 'p' and returns the first byte removed.  Otherwise, returns a
+ * null pointer without modifying 'p'. */
 static inline void *
-dp_packet_try_pull(struct dp_packet *b, size_t size)
+dp_packet_try_pull(struct dp_packet *p, size_t size)
 {
-    return dp_packet_size(b) - dp_packet_l2_pad_size(b) >= size
-        ? dp_packet_pull(b, size) : NULL;
+    return dp_packet_size(p) - dp_packet_l2_pad_size(p) >= size
+        ? dp_packet_pull(p, size) : NULL;
 }
 
 static inline bool
-dp_packet_equal(const struct dp_packet *a, const struct dp_packet *b)
+dp_packet_equal(const struct dp_packet *p1, const struct dp_packet *p2)
 {
-    return dp_packet_size(a) == dp_packet_size(b) &&
-           !memcmp(dp_packet_data(a), dp_packet_data(b), dp_packet_size(a));
+    return dp_packet_size(p1) == dp_packet_size(p2) &&
+           !memcmp(dp_packet_data(p1), dp_packet_data(p2), dp_packet_size(p1));
 }
 
 static inline bool
-dp_packet_is_eth(const struct dp_packet *b)
+dp_packet_is_eth(const struct dp_packet *p)
 {
-    return b->packet_type == htonl(PT_ETH);
+    return p->packet_type == htonl(PT_ETH);
 }
 
 /* Get the start of the Ethernet frame. 'l3_ofs' marks the end of the l2
  * headers, so return NULL if it is not set. */
 static inline void *
-dp_packet_eth(const struct dp_packet *b)
+dp_packet_eth(const struct dp_packet *p)
 {
-    return (dp_packet_is_eth(b) && b->l3_ofs != UINT16_MAX)
-            ? dp_packet_data(b) : NULL;
+    return (dp_packet_is_eth(p) && p->l3_ofs != UINT16_MAX)
+            ? dp_packet_data(p) : NULL;
 }
 
 /* Resets all layer offsets.  'l3' offset must be set before 'l2' can be
  * retrieved. */
 static inline void
-dp_packet_reset_offsets(struct dp_packet *b)
+dp_packet_reset_offsets(struct dp_packet *p)
 {
-    b->l2_pad_size = 0;
-    b->l2_5_ofs = UINT16_MAX;
-    b->l3_ofs = UINT16_MAX;
-    b->l4_ofs = UINT16_MAX;
+    p->l2_pad_size = 0;
+    p->l2_5_ofs = UINT16_MAX;
+    p->l3_ofs = UINT16_MAX;
+    p->l4_ofs = UINT16_MAX;
 }
 
 static inline uint16_t
-dp_packet_l2_pad_size(const struct dp_packet *b)
+dp_packet_l2_pad_size(const struct dp_packet *p)
 {
-    return b->l2_pad_size;
+    return p->l2_pad_size;
 }
 
 static inline void
-dp_packet_set_l2_pad_size(struct dp_packet *b, uint16_t pad_size)
+dp_packet_set_l2_pad_size(struct dp_packet *p, uint16_t pad_size)
 {
-    ovs_assert(pad_size <= dp_packet_size(b));
-    b->l2_pad_size = pad_size;
+    ovs_assert(pad_size <= dp_packet_size(p));
+    p->l2_pad_size = pad_size;
 }
 
 static inline void *
-dp_packet_l2_5(const struct dp_packet *b)
+dp_packet_l2_5(const struct dp_packet *p)
 {
-    return b->l2_5_ofs != UINT16_MAX
-           ? (char *) dp_packet_data(b) + b->l2_5_ofs
+    return p->l2_5_ofs != UINT16_MAX
+           ? (char *) dp_packet_data(p) + p->l2_5_ofs
            : NULL;
 }
 
 static inline void
-dp_packet_set_l2_5(struct dp_packet *b, void *l2_5)
+dp_packet_set_l2_5(struct dp_packet *p, void *l2_5)
 {
-    b->l2_5_ofs = l2_5
-                  ? (char *) l2_5 - (char *) dp_packet_data(b)
+    p->l2_5_ofs = l2_5
+                  ? (char *) l2_5 - (char *) dp_packet_data(p)
                   : UINT16_MAX;
 }
 
 static inline void *
-dp_packet_l3(const struct dp_packet *b)
+dp_packet_l3(const struct dp_packet *p)
 {
-    return b->l3_ofs != UINT16_MAX
-           ? (char *) dp_packet_data(b) + b->l3_ofs
+    return p->l3_ofs != UINT16_MAX
+           ? (char *) dp_packet_data(p) + p->l3_ofs
            : NULL;
 }
 
 static inline void
-dp_packet_set_l3(struct dp_packet *b, void *l3)
+dp_packet_set_l3(struct dp_packet *p, void *l3)
 {
-    b->l3_ofs = l3 ? (char *) l3 - (char *) dp_packet_data(b) : UINT16_MAX;
+    p->l3_ofs = l3 ? (char *) l3 - (char *) dp_packet_data(p) : UINT16_MAX;
 }
 
 static inline void *
-dp_packet_l4(const struct dp_packet *b)
+dp_packet_l4(const struct dp_packet *p)
 {
-    return b->l4_ofs != UINT16_MAX
-           ? (char *) dp_packet_data(b) + b->l4_ofs
+    return p->l4_ofs != UINT16_MAX
+           ? (char *) dp_packet_data(p) + p->l4_ofs
            : NULL;
 }
 
 static inline void
-dp_packet_set_l4(struct dp_packet *b, void *l4)
+dp_packet_set_l4(struct dp_packet *p, void *l4)
 {
-    b->l4_ofs = l4 ? (char *) l4 - (char *) dp_packet_data(b) : UINT16_MAX;
+    p->l4_ofs = l4 ? (char *) l4 - (char *) dp_packet_data(p) : UINT16_MAX;
 }
 
 /* Returns the size of the packet from the beginning of the L3 header to the
  * end of the L3 payload.  Hence L2 padding is not included. */
 static inline size_t
-dp_packet_l3_size(const struct dp_packet *b)
+dp_packet_l3_size(const struct dp_packet *p)
 {
-    return OVS_LIKELY(b->l3_ofs != UINT16_MAX)
-        ? (const char *)dp_packet_tail(b) - (const char *)dp_packet_l3(b)
-        - dp_packet_l2_pad_size(b)
+    return OVS_LIKELY(p->l3_ofs != UINT16_MAX)
+        ? (const char *)dp_packet_tail(p) - (const char *)dp_packet_l3(p)
+        - dp_packet_l2_pad_size(p)
         : 0;
 }
 
 /* Returns the size of the packet from the beginning of the L4 header to the
  * end of the L4 payload.  Hence L2 padding is not included. */
 static inline size_t
-dp_packet_l4_size(const struct dp_packet *b)
+dp_packet_l4_size(const struct dp_packet *p)
 {
-    return OVS_LIKELY(b->l4_ofs != UINT16_MAX)
-        ? (const char *)dp_packet_tail(b) - (const char *)dp_packet_l4(b)
-        - dp_packet_l2_pad_size(b)
+    return OVS_LIKELY(p->l4_ofs != UINT16_MAX)
+        ? (const char *)dp_packet_tail(p) - (const char *)dp_packet_l4(p)
+        - dp_packet_l2_pad_size(p)
         : 0;
 }
 
 static inline const void *
-dp_packet_get_tcp_payload(const struct dp_packet *b)
+dp_packet_get_tcp_payload(const struct dp_packet *p)
 {
-    size_t l4_size = dp_packet_l4_size(b);
+    size_t l4_size = dp_packet_l4_size(p);
 
     if (OVS_LIKELY(l4_size >= TCP_HEADER_LEN)) {
-        struct tcp_header *tcp = dp_packet_l4(b);
+        struct tcp_header *tcp = dp_packet_l4(p);
         int tcp_len = TCP_OFFSET(tcp->tcp_ctl) * 4;
 
         if (OVS_LIKELY(tcp_len >= TCP_HEADER_LEN && tcp_len <= l4_size)) {
@@ -480,11 +480,11 @@  dp_packet_get_tcp_payload(const struct dp_packet *b)
 }
 
 static inline uint32_t
-dp_packet_get_tcp_payload_length(const struct dp_packet *pkt)
+dp_packet_get_tcp_payload_length(const struct dp_packet *p)
 {
-    const char *tcp_payload = dp_packet_get_tcp_payload(pkt);
+    const char *tcp_payload = dp_packet_get_tcp_payload(p);
     if (tcp_payload) {
-        return ((char *) dp_packet_tail(pkt) - dp_packet_l2_pad_size(pkt)
+        return ((char *) dp_packet_tail(p) - dp_packet_l2_pad_size(p)
                 - tcp_payload);
     } else {
         return 0;
@@ -492,69 +492,69 @@  dp_packet_get_tcp_payload_length(const struct dp_packet *pkt)
 }
 
 static inline const void *
-dp_packet_get_udp_payload(const struct dp_packet *b)
+dp_packet_get_udp_payload(const struct dp_packet *p)
 {
-    return OVS_LIKELY(dp_packet_l4_size(b) >= UDP_HEADER_LEN)
-        ? (const char *)dp_packet_l4(b) + UDP_HEADER_LEN : NULL;
+    return OVS_LIKELY(dp_packet_l4_size(p) >= UDP_HEADER_LEN)
+        ? (const char *)dp_packet_l4(p) + UDP_HEADER_LEN : NULL;
 }
 
 static inline const void *
-dp_packet_get_sctp_payload(const struct dp_packet *b)
+dp_packet_get_sctp_payload(const struct dp_packet *p)
 {
-    return OVS_LIKELY(dp_packet_l4_size(b) >= SCTP_HEADER_LEN)
-        ? (const char *)dp_packet_l4(b) + SCTP_HEADER_LEN : NULL;
+    return OVS_LIKELY(dp_packet_l4_size(p) >= SCTP_HEADER_LEN)
+        ? (const char *)dp_packet_l4(p) + SCTP_HEADER_LEN : NULL;
 }
 
 static inline const void *
-dp_packet_get_icmp_payload(const struct dp_packet *b)
+dp_packet_get_icmp_payload(const struct dp_packet *p)
 {
-    return OVS_LIKELY(dp_packet_l4_size(b) >= ICMP_HEADER_LEN)
-        ? (const char *)dp_packet_l4(b) + ICMP_HEADER_LEN : NULL;
+    return OVS_LIKELY(dp_packet_l4_size(p) >= ICMP_HEADER_LEN)
+        ? (const char *)dp_packet_l4(p) + ICMP_HEADER_LEN : NULL;
 }
 
 static inline const void *
-dp_packet_get_nd_payload(const struct dp_packet *b)
+dp_packet_get_nd_payload(const struct dp_packet *p)
 {
-    return OVS_LIKELY(dp_packet_l4_size(b) >= ND_MSG_LEN)
-        ? (const char *)dp_packet_l4(b) + ND_MSG_LEN : NULL;
+    return OVS_LIKELY(dp_packet_l4_size(p) >= ND_MSG_LEN)
+        ? (const char *)dp_packet_l4(p) + ND_MSG_LEN : NULL;
 }
 
 #ifdef DPDK_NETDEV
 static inline uint64_t *
-dp_packet_ol_flags_ptr(const struct dp_packet *b)
+dp_packet_ol_flags_ptr(const struct dp_packet *p)
 {
-    return CONST_CAST(uint64_t *, &b->mbuf.ol_flags);
+    return CONST_CAST(uint64_t *, &p->mbuf.ol_flags);
 }
 
 static inline uint32_t *
-dp_packet_rss_ptr(const struct dp_packet *b)
+dp_packet_rss_ptr(const struct dp_packet *p)
 {
-    return CONST_CAST(uint32_t *, &b->mbuf.hash.rss);
+    return CONST_CAST(uint32_t *, &p->mbuf.hash.rss);
 }
 
 static inline uint32_t *
-dp_packet_flow_mark_ptr(const struct dp_packet *b)
+dp_packet_flow_mark_ptr(const struct dp_packet *p)
 {
-    return CONST_CAST(uint32_t *, &b->mbuf.hash.fdir.hi);
+    return CONST_CAST(uint32_t *, &p->mbuf.hash.fdir.hi);
 }
 
 #else
 static inline uint32_t *
-dp_packet_ol_flags_ptr(const struct dp_packet *b)
+dp_packet_ol_flags_ptr(const struct dp_packet *p)
 {
-    return CONST_CAST(uint32_t *, &b->ol_flags);
+    return CONST_CAST(uint32_t *, &p->ol_flags);
 }
 
 static inline uint32_t *
-dp_packet_rss_ptr(const struct dp_packet *b)
+dp_packet_rss_ptr(const struct dp_packet *p)
 {
-    return CONST_CAST(uint32_t *, &b->rss_hash);
+    return CONST_CAST(uint32_t *, &p->rss_hash);
 }
 
 static inline uint32_t *
-dp_packet_flow_mark_ptr(const struct dp_packet *b)
+dp_packet_flow_mark_ptr(const struct dp_packet *p)
 {
-    return CONST_CAST(uint32_t *, &b->flow_mark);
+    return CONST_CAST(uint32_t *, &p->flow_mark);
 }
 #endif
 
@@ -572,25 +572,25 @@  dp_packet_init_specific(struct dp_packet *p)
 }
 
 static inline void *
-dp_packet_base(const struct dp_packet *b)
+dp_packet_base(const struct dp_packet *p)
 {
-    return b->mbuf.buf_addr;
+    return p->mbuf.buf_addr;
 }
 
 static inline void
-dp_packet_set_base(struct dp_packet *b, void *d)
+dp_packet_set_base(struct dp_packet *p, void *d)
 {
-    b->mbuf.buf_addr = d;
+    p->mbuf.buf_addr = d;
 }
 
 static inline uint32_t
-dp_packet_size(const struct dp_packet *b)
+dp_packet_size(const struct dp_packet *p)
 {
-    return b->mbuf.pkt_len;
+    return p->mbuf.pkt_len;
 }
 
 static inline void
-dp_packet_set_size(struct dp_packet *b, uint32_t v)
+dp_packet_set_size(struct dp_packet *p, uint32_t v)
 {
     /* netdev-dpdk does not currently support segmentation; consequently, for
      * all intents and purposes, 'data_len' (16 bit) and 'pkt_len' (32 bit) may
@@ -600,33 +600,33 @@  dp_packet_set_size(struct dp_packet *b, uint32_t v)
      * (and thus 'v') will always be <= UINT16_MAX; this means that there is no
      * loss of accuracy in assigning 'v' to 'data_len'.
      */
-    b->mbuf.data_len = (uint16_t)v;  /* Current seg length. */
-    b->mbuf.pkt_len = v;             /* Total length of all segments linked to
+    p->mbuf.data_len = (uint16_t)v;  /* Current seg length. */
+    p->mbuf.pkt_len = v;             /* Total length of all segments linked to
                                       * this segment. */
 }
 
 static inline uint16_t
-__packet_data(const struct dp_packet *b)
+__packet_data(const struct dp_packet *p)
 {
-    return b->mbuf.data_off;
+    return p->mbuf.data_off;
 }
 
 static inline void
-__packet_set_data(struct dp_packet *b, uint16_t v)
+__packet_set_data(struct dp_packet *p, uint16_t v)
 {
-    b->mbuf.data_off = v;
+    p->mbuf.data_off = v;
 }
 
 static inline uint16_t
-dp_packet_get_allocated(const struct dp_packet *b)
+dp_packet_get_allocated(const struct dp_packet *p)
 {
-    return b->mbuf.buf_len;
+    return p->mbuf.buf_len;
 }
 
 static inline void
-dp_packet_set_allocated(struct dp_packet *b, uint16_t s)
+dp_packet_set_allocated(struct dp_packet *p, uint16_t s)
 {
-    b->mbuf.buf_len = s;
+    p->mbuf.buf_len = s;
 }
 
 #else /* DPDK_NETDEV */
@@ -638,112 +638,112 @@  dp_packet_init_specific(struct dp_packet *p OVS_UNUSED)
 }
 
 static inline void *
-dp_packet_base(const struct dp_packet *b)
+dp_packet_base(const struct dp_packet *p)
 {
-    return b->base_;
+    return p->base_;
 }
 
 static inline void
-dp_packet_set_base(struct dp_packet *b, void *d)
+dp_packet_set_base(struct dp_packet *p, void *d)
 {
-    b->base_ = d;
+    p->base_ = d;
 }
 
 static inline uint32_t
-dp_packet_size(const struct dp_packet *b)
+dp_packet_size(const struct dp_packet *p)
 {
-    return b->size_;
+    return p->size_;
 }
 
 static inline void
-dp_packet_set_size(struct dp_packet *b, uint32_t v)
+dp_packet_set_size(struct dp_packet *p, uint32_t v)
 {
-    b->size_ = v;
+    p->size_ = v;
 }
 
 static inline uint16_t
-__packet_data(const struct dp_packet *b)
+__packet_data(const struct dp_packet *p)
 {
-    return b->data_ofs;
+    return p->data_ofs;
 }
 
 static inline void
-__packet_set_data(struct dp_packet *b, uint16_t v)
+__packet_set_data(struct dp_packet *p, uint16_t v)
 {
-    b->data_ofs = v;
+    p->data_ofs = v;
 }
 
 static inline uint16_t
-dp_packet_get_allocated(const struct dp_packet *b)
+dp_packet_get_allocated(const struct dp_packet *p)
 {
-    return b->allocated_;
+    return p->allocated_;
 }
 
 static inline void
-dp_packet_set_allocated(struct dp_packet *b, uint16_t s)
+dp_packet_set_allocated(struct dp_packet *p, uint16_t s)
 {
-    b->allocated_ = s;
+    p->allocated_ = s;
 }
 
 #endif /* DPDK_NETDEV */
 
 static inline void
-dp_packet_reset_cutlen(struct dp_packet *b)
+dp_packet_reset_cutlen(struct dp_packet *p)
 {
-    b->cutlen = 0;
+    p->cutlen = 0;
 }
 
 static inline uint32_t
-dp_packet_set_cutlen(struct dp_packet *b, uint32_t max_len)
+dp_packet_set_cutlen(struct dp_packet *p, uint32_t max_len)
 {
     if (max_len < ETH_HEADER_LEN) {
         max_len = ETH_HEADER_LEN;
     }
 
-    if (max_len >= dp_packet_size(b)) {
-        b->cutlen = 0;
+    if (max_len >= dp_packet_size(p)) {
+        p->cutlen = 0;
     } else {
-        b->cutlen = dp_packet_size(b) - max_len;
+        p->cutlen = dp_packet_size(p) - max_len;
     }
-    return b->cutlen;
+    return p->cutlen;
 }
 
 static inline uint32_t
-dp_packet_get_cutlen(const struct dp_packet *b)
+dp_packet_get_cutlen(const struct dp_packet *p)
 {
     /* Always in valid range if user uses dp_packet_set_cutlen. */
-    return b->cutlen;
+    return p->cutlen;
 }
 
 static inline uint32_t
-dp_packet_get_send_len(const struct dp_packet *b)
+dp_packet_get_send_len(const struct dp_packet *p)
 {
-    return dp_packet_size(b) - dp_packet_get_cutlen(b);
+    return dp_packet_size(p) - dp_packet_get_cutlen(p);
 }
 
 static inline void *
-dp_packet_data(const struct dp_packet *b)
+dp_packet_data(const struct dp_packet *p)
 {
-    return __packet_data(b) != UINT16_MAX
-           ? (char *) dp_packet_base(b) + __packet_data(b) : NULL;
+    return __packet_data(p) != UINT16_MAX
+           ? (char *) dp_packet_base(p) + __packet_data(p) : NULL;
 }
 
 static inline void
-dp_packet_set_data(struct dp_packet *b, void *data)
+dp_packet_set_data(struct dp_packet *p, void *data)
 {
     if (data) {
-        __packet_set_data(b, (char *) data - (char *) dp_packet_base(b));
+        __packet_set_data(p, (char *) data - (char *) dp_packet_base(p));
     } else {
-        __packet_set_data(b, UINT16_MAX);
+        __packet_set_data(p, UINT16_MAX);
     }
 }
 
 static inline void
-dp_packet_reset_packet(struct dp_packet *b, int off)
+dp_packet_reset_packet(struct dp_packet *p, int off)
 {
-    dp_packet_set_size(b, dp_packet_size(b) - off);
-    dp_packet_set_data(b, ((unsigned char *) dp_packet_data(b) + off));
-    dp_packet_reset_offsets(b);
+    dp_packet_set_size(p, dp_packet_size(p) - off);
+    dp_packet_set_data(p, ((unsigned char *) dp_packet_data(p) + off));
+    dp_packet_reset_offsets(p);
 }
 
 enum { NETDEV_MAX_BURST = 32 }; /* Maximum number packets in a batch. */
@@ -755,69 +755,69 @@  struct dp_packet_batch {
 };
 
 static inline void
-dp_packet_batch_init(struct dp_packet_batch *batch)
+dp_packet_batch_init(struct dp_packet_batch *b)
 {
-    batch->count = 0;
-    batch->trunc = false;
+    b->count = 0;
+    b->trunc = false;
 }
 
 static inline void
-dp_packet_batch_add__(struct dp_packet_batch *batch,
+dp_packet_batch_add__(struct dp_packet_batch *b,
                       struct dp_packet *packet, size_t limit)
 {
-    if (batch->count < limit) {
-        batch->packets[batch->count++] = packet;
+    if (b->count < limit) {
+        b->packets[b->count++] = packet;
     } else {
         dp_packet_delete(packet);
     }
 }
 
-/* When the batch is full, 'packet' will be dropped and freed. */
+/* When the batch 'b' is full, packet 'p' will be dropped and freed. */
 static inline void
-dp_packet_batch_add(struct dp_packet_batch *batch, struct dp_packet *packet)
+dp_packet_batch_add(struct dp_packet_batch *b, struct dp_packet *p)
 {
-    dp_packet_batch_add__(batch, packet, NETDEV_MAX_BURST);
+    dp_packet_batch_add__(b, p, NETDEV_MAX_BURST);
 }
 
 static inline size_t
-dp_packet_batch_size(const struct dp_packet_batch *batch)
+dp_packet_batch_size(const struct dp_packet_batch *b)
 {
-    return batch->count;
+    return b->count;
 }
 
-/* Clear 'batch' for refill. Use dp_packet_batch_refill() to add
- * packets back into the 'batch'. */
+/* Clear batch 'b' for refill. Use dp_packet_batch_refill() to add
+ * packets back into the batch 'b'. */
 static inline void
-dp_packet_batch_refill_init(struct dp_packet_batch *batch)
+dp_packet_batch_refill_init(struct dp_packet_batch *b)
 {
-    batch->count = 0;
+    b->count = 0;
 };
 
 static inline void
-dp_packet_batch_refill(struct dp_packet_batch *batch,
+dp_packet_batch_refill(struct dp_packet_batch *b,
                        struct dp_packet *packet, size_t idx)
 {
-    dp_packet_batch_add__(batch, packet, MIN(NETDEV_MAX_BURST, idx + 1));
+    dp_packet_batch_add__(b, packet, MIN(NETDEV_MAX_BURST, idx + 1));
 }
 
 static inline void
-dp_packet_batch_init_packet(struct dp_packet_batch *batch, struct dp_packet *p)
+dp_packet_batch_init_packet(struct dp_packet_batch *b, struct dp_packet *p)
 {
-    dp_packet_batch_init(batch);
-    batch->count = 1;
-    batch->packets[0] = p;
+    dp_packet_batch_init(b);
+    b->count = 1;
+    b->packets[0] = p;
 }
 
 static inline bool
-dp_packet_batch_is_empty(const struct dp_packet_batch *batch)
+dp_packet_batch_is_empty(const struct dp_packet_batch *b)
 {
-    return !dp_packet_batch_size(batch);
+    return !dp_packet_batch_size(b);
 }
 
 static inline bool
-dp_packet_batch_is_full(const struct dp_packet_batch *batch)
+dp_packet_batch_is_full(const struct dp_packet_batch *b)
 {
-    return dp_packet_batch_size(batch) == NETDEV_MAX_BURST;
+    return dp_packet_batch_size(b) == NETDEV_MAX_BURST;
 }
 
 #define DP_PACKET_BATCH_FOR_EACH(IDX, PACKET, BATCH)                \
@@ -861,53 +861,53 @@  dp_packet_batch_clone(struct dp_packet_batch *dst,
 }
 
 static inline void
-dp_packet_delete_batch(struct dp_packet_batch *batch, bool should_steal)
+dp_packet_delete_batch(struct dp_packet_batch *b, bool should_steal)
 {
     if (should_steal) {
         struct dp_packet *packet;
 
-        DP_PACKET_BATCH_FOR_EACH (i, packet, batch) {
+        DP_PACKET_BATCH_FOR_EACH (i, packet, b) {
             dp_packet_delete(packet);
         }
-        dp_packet_batch_init(batch);
+        dp_packet_batch_init(b);
     }
 }
 
 static inline void
-dp_packet_batch_init_packet_fields(struct dp_packet_batch *batch)
+dp_packet_batch_init_packet_fields(struct dp_packet_batch *b)
 {
     struct dp_packet *packet;
 
-    DP_PACKET_BATCH_FOR_EACH (i, packet, batch) {
+    DP_PACKET_BATCH_FOR_EACH (i, packet, b) {
         dp_packet_reset_cutlen(packet);
         packet->packet_type = htonl(PT_ETH);
     }
 }
 
 static inline void
-dp_packet_batch_apply_cutlen(struct dp_packet_batch *batch)
+dp_packet_batch_apply_cutlen(struct dp_packet_batch *b)
 {
-    if (batch->trunc) {
+    if (b->trunc) {
         struct dp_packet *packet;
 
-        DP_PACKET_BATCH_FOR_EACH (i, packet, batch) {
+        DP_PACKET_BATCH_FOR_EACH (i, packet, b) {
             dp_packet_set_size(packet, dp_packet_get_send_len(packet));
             dp_packet_reset_cutlen(packet);
         }
-        batch->trunc = false;
+        b->trunc = false;
     }
 }
 
 static inline void
-dp_packet_batch_reset_cutlen(struct dp_packet_batch *batch)
+dp_packet_batch_reset_cutlen(struct dp_packet_batch *b)
 {
-    if (batch->trunc) {
+    if (b->trunc) {
         struct dp_packet *packet;
 
-        DP_PACKET_BATCH_FOR_EACH (i, packet, batch) {
+        DP_PACKET_BATCH_FOR_EACH (i, packet, b) {
             dp_packet_reset_cutlen(packet);
         }
-        batch->trunc = false;
+        b->trunc = false;
     }
 }
 
@@ -958,101 +958,101 @@  dp_packet_set_flow_mark(struct dp_packet *p, uint32_t mark)
 
 /* Returns the L4 cksum offload bitmask. */
 static inline uint64_t
-dp_packet_ol_l4_mask(const struct dp_packet *b)
+dp_packet_ol_l4_mask(const struct dp_packet *p)
 {
-    return *dp_packet_ol_flags_ptr(b) & DP_PACKET_OL_TX_L4_MASK;
+    return *dp_packet_ol_flags_ptr(p) & DP_PACKET_OL_TX_L4_MASK;
 }
 
-/* Return true if the packet 'b' requested L4 checksum offload. */
+/* Return true if the packet 'p' requested L4 checksum offload. */
 static inline bool
-dp_packet_ol_tx_l4_csum(const struct dp_packet *b)
+dp_packet_ol_tx_l4_csum(const struct dp_packet *p)
 {
-    return !!dp_packet_ol_l4_mask(b);
+    return !!dp_packet_ol_l4_mask(p);
 }
 
-/* Returns 'true' if packet 'b' is marked for TCP segmentation offloading. */
+/* Returns 'true' if packet 'p' is marked for TCP segmentation offloading. */
 static inline bool
-dp_packet_ol_is_tso(const struct dp_packet *b)
+dp_packet_ol_is_tso(const struct dp_packet *p)
 {
-    return !!(*dp_packet_ol_flags_ptr(b) & DP_PACKET_OL_TX_TCP_SEG);
+    return !!(*dp_packet_ol_flags_ptr(p) & DP_PACKET_OL_TX_TCP_SEG);
 }
 
-/* Returns 'true' if packet 'b' is marked for IPv4 checksum offloading. */
+/* Returns 'true' if packet 'p' is marked for IPv4 checksum offloading. */
 static inline bool
-dp_packet_ol_is_ipv4(const struct dp_packet *b)
+dp_packet_ol_is_ipv4(const struct dp_packet *p)
 {
-    return !!(*dp_packet_ol_flags_ptr(b) & DP_PACKET_OL_TX_IPV4);
+    return !!(*dp_packet_ol_flags_ptr(p) & DP_PACKET_OL_TX_IPV4);
 }
 
-/* Returns 'true' if packet 'b' is marked for TCP checksum offloading. */
+/* Returns 'true' if packet 'p' is marked for TCP checksum offloading. */
 static inline bool
-dp_packet_ol_l4_is_tcp(const struct dp_packet *b)
+dp_packet_ol_l4_is_tcp(const struct dp_packet *p)
 {
-    return (*dp_packet_ol_flags_ptr(b) & DP_PACKET_OL_TX_L4_MASK) ==
+    return (*dp_packet_ol_flags_ptr(p) & DP_PACKET_OL_TX_L4_MASK) ==
             DP_PACKET_OL_TX_TCP_CSUM;
 }
 
-/* Returns 'true' if packet 'b' is marked for UDP checksum offloading. */
+/* Returns 'true' if packet 'p' is marked for UDP checksum offloading. */
 static inline bool
-dp_packet_ol_l4_is_udp(struct dp_packet *b)
+dp_packet_ol_l4_is_udp(struct dp_packet *p)
 {
-    return (*dp_packet_ol_flags_ptr(b) & DP_PACKET_OL_TX_L4_MASK) ==
+    return (*dp_packet_ol_flags_ptr(p) & DP_PACKET_OL_TX_L4_MASK) ==
             DP_PACKET_OL_TX_UDP_CSUM;
 }
 
-/* Returns 'true' if packet 'b' is marked for SCTP checksum offloading. */
+/* Returns 'true' if packet 'p' is marked for SCTP checksum offloading. */
 static inline bool
-dp_packet_ol_l4_is_sctp(struct dp_packet *b)
+dp_packet_ol_l4_is_sctp(struct dp_packet *p)
 {
-    return (*dp_packet_ol_flags_ptr(b) & DP_PACKET_OL_TX_L4_MASK) ==
+    return (*dp_packet_ol_flags_ptr(p) & DP_PACKET_OL_TX_L4_MASK) ==
             DP_PACKET_OL_TX_SCTP_CSUM;
 }
 
-/* Mark packet 'b' for IPv4 checksum offloading. */
+/* Mark packet 'p' for IPv4 checksum offloading. */
 static inline void
-dp_packet_ol_set_tx_ipv4(struct dp_packet *b)
+dp_packet_ol_set_tx_ipv4(struct dp_packet *p)
 {
-    *dp_packet_ol_flags_ptr(b) |= DP_PACKET_OL_TX_IPV4;
+    *dp_packet_ol_flags_ptr(p) |= DP_PACKET_OL_TX_IPV4;
 }
 
-/* Mark packet 'b' for IPv6 checksum offloading. */
+/* Mark packet 'p' for IPv6 checksum offloading. */
 static inline void
-dp_packet_ol_set_tx_ipv6(struct dp_packet *b)
+dp_packet_ol_set_tx_ipv6(struct dp_packet *p)
 {
-    *dp_packet_ol_flags_ptr(b) |= DP_PACKET_OL_TX_IPV6;
+    *dp_packet_ol_flags_ptr(p) |= DP_PACKET_OL_TX_IPV6;
 }
 
-/* Mark packet 'b' for TCP checksum offloading.  It implies that either
- * the packet 'b' is marked for IPv4 or IPv6 checksum offloading. */
+/* Mark packet 'p' for TCP checksum offloading.  It implies that either
+ * the packet 'p' is marked for IPv4 or IPv6 checksum offloading. */
 static inline void
-dp_packet_ol_set_csum_tcp(struct dp_packet *b)
+dp_packet_ol_set_csum_tcp(struct dp_packet *p)
 {
-    *dp_packet_ol_flags_ptr(b) |= DP_PACKET_OL_TX_TCP_CSUM;
+    *dp_packet_ol_flags_ptr(p) |= DP_PACKET_OL_TX_TCP_CSUM;
 }
 
-/* Mark packet 'b' for UDP checksum offloading.  It implies that either
- * the packet 'b' is marked for IPv4 or IPv6 checksum offloading. */
+/* Mark packet 'p' for UDP checksum offloading.  It implies that either
+ * the packet 'p' is marked for IPv4 or IPv6 checksum offloading. */
 static inline void
-dp_packet_ol_set_csum_udp(struct dp_packet *b)
+dp_packet_ol_set_csum_udp(struct dp_packet *p)
 {
-    *dp_packet_ol_flags_ptr(b) |= DP_PACKET_OL_TX_UDP_CSUM;
+    *dp_packet_ol_flags_ptr(p) |= DP_PACKET_OL_TX_UDP_CSUM;
 }
 
-/* Mark packet 'b' for SCTP checksum offloading.  It implies that either
- * the packet 'b' is marked for IPv4 or IPv6 checksum offloading. */
+/* Mark packet 'p' for SCTP checksum offloading.  It implies that either
+ * the packet 'p' is marked for IPv4 or IPv6 checksum offloading. */
 static inline void
-dp_packet_ol_set_csum_sctp(struct dp_packet *b)
+dp_packet_ol_set_csum_sctp(struct dp_packet *p)
 {
-    *dp_packet_ol_flags_ptr(b) |= DP_PACKET_OL_TX_SCTP_CSUM;
+    *dp_packet_ol_flags_ptr(p) |= DP_PACKET_OL_TX_SCTP_CSUM;
 }
 
-/* Mark packet 'b' for TCP segmentation offloading.  It implies that
- * either the packet 'b' is marked for IPv4 or IPv6 checksum offloading
+/* Mark packet 'p' for TCP segmentation offloading.  It implies that
+ * either the packet 'p' is marked for IPv4 or IPv6 checksum offloading
  * and also for TCP checksum offloading. */
 static inline void
-dp_packet_ol_set_tcp_seg(struct dp_packet *b)
+dp_packet_ol_set_tcp_seg(struct dp_packet *p)
 {
-    *dp_packet_ol_flags_ptr(b) |= DP_PACKET_OL_TX_TCP_SEG;
+    *dp_packet_ol_flags_ptr(p) |= DP_PACKET_OL_TX_TCP_SEG;
 }
 
 static inline bool