1 files changed, 73 insertions, 19 deletions

diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 16eef03ce0eb..85577a4ffa61 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -34,8 +34,9 @@
 #define HAVE_ALIGNABLE_SKB      /* Ditto 8)                */
 
 #define CHECKSUM_NONE 0
-#define CHECKSUM_HW 1
+#define CHECKSUM_PARTIAL 1
 #define CHECKSUM_UNNECESSARY 2
+#define CHECKSUM_COMPLETE 3
 
 #define SKB_DATA_ALIGN(X)       (((X) + (SMP_CACHE_BYTES - 1)) & \
                                  ~(SMP_CACHE_BYTES - 1))
@@ -56,17 +57,17 @@
  *            Apparently with secret goal to sell you new device, when you
  *            will add new protocol to your host. F.e. IPv6. 8)
  *
- *      HW: the most generic way. Device supplied checksum of _all_
+ *      COMPLETE: the most generic way. Device supplied checksum of _all_
  *          the packet as seen by netif_rx in skb->csum.
  *          NOTE: Even if device supports only some protocols, but
- *          is able to produce some skb->csum, it MUST use HW,
+ *          is able to produce some skb->csum, it MUST use COMPLETE,
  *          not UNNECESSARY.
  *
  * B. Checksumming on output.
  *
  *      NONE: skb is checksummed by protocol or csum is not required.
  *
- *      HW: device is required to csum packet as seen by hard_start_xmit
+ *      PARTIAL: device is required to csum packet as seen by hard_start_xmit
  *      from skb->h.raw to the end and to record the checksum
  *      at skb->h.raw+skb->csum.
  *
@@ -171,7 +172,15 @@ enum {
 
 enum {
         SKB_GSO_TCPV4 = 1 << 0,
-        SKB_GSO_UDPV4 = 1 << 1,
+        SKB_GSO_UDP = 1 << 1,
+
+        /* This indicates the skb is from an untrusted source. */
+        SKB_GSO_DODGY = 1 << 2,
+
+        /* This indicates the tcp segment has CWR set. */
+        SKB_GSO_TCP_ECN = 1 << 3,
+
+        SKB_GSO_TCPV6 = 1 << 4,
 };
 
 /** 
@@ -596,6 +605,14 @@ static inline __u32 skb_queue_len(const struct sk_buff_head *list_)
         return list_->qlen;
 }
 
+/*
+ * This function creates a split out lock class for each invocation;
+ * this is needed for now since a whole lot of users of the skb-queue
+ * infrastructure in drivers have different locking usage (in hardirq)
+ * than the networking core (in softirq only). In the long run either the
+ * network layer or drivers should need annotation to consolidate the
+ * main types of usage into 3 classes.
+ */
 static inline void skb_queue_head_init(struct sk_buff_head *list)
 {
         spin_lock_init(&list->lock);
@@ -1024,6 +1041,21 @@ static inline int pskb_trim(struct sk_buff *skb, unsigned int len)
 }
 
 /**
+ *      pskb_trim_unique - remove end from a paged unique (not cloned) buffer
+ *      @skb: buffer to alter
+ *      @len: new length
+ *
+ *      This is identical to pskb_trim except that the caller knows that
+ *      the skb is not cloned so we should never get an error due to out-
+ *      of-memory.
+ */
+static inline void pskb_trim_unique(struct sk_buff *skb, unsigned int len)
+{
+        int err = pskb_trim(skb, len);
+        BUG_ON(err);
+}
+
+/**
  *      skb_orphan - orphan a buffer
  *      @skb: buffer to orphan
  *
@@ -1055,9 +1087,8 @@ static inline void __skb_queue_purge(struct sk_buff_head *list)
                 kfree_skb(skb);
 }
 
-#ifndef CONFIG_HAVE_ARCH_DEV_ALLOC_SKB
 /**
- *      __dev_alloc_skb - allocate an skbuff for sending
+ *      __dev_alloc_skb - allocate an skbuff for receiving
  *      @length: length to allocate
  *      @gfp_mask: get_free_pages mask, passed to alloc_skb
  *
@@ -1066,7 +1097,7 @@ static inline void __skb_queue_purge(struct sk_buff_head *list)
  *      the headroom they think they need without accounting for the
  *      built in space. The built in space is used for optimisations.
  *
- *      %NULL is returned in there is no free memory.
+ *      %NULL is returned if there is no free memory.
  */
 static inline struct sk_buff *__dev_alloc_skb(unsigned int length,
                                               gfp_t gfp_mask)
@@ -1076,12 +1107,9 @@ static inline struct sk_buff *__dev_alloc_skb(unsigned int length,
                 skb_reserve(skb, NET_SKB_PAD);
         return skb;
 }
-#else
-extern struct sk_buff *__dev_alloc_skb(unsigned int length, int gfp_mask);
-#endif
 
 /**
- *      dev_alloc_skb - allocate an skbuff for sending
+ *      dev_alloc_skb - allocate an skbuff for receiving
  *      @length: length to allocate
  *
  *      Allocate a new &sk_buff and assign it a usage count of one. The
@@ -1089,7 +1117,7 @@ extern struct sk_buff *__dev_alloc_skb(unsigned int length, int gfp_mask);
  *      the headroom they think they need without accounting for the
  *      built in space. The built in space is used for optimisations.
  *
- *      %NULL is returned in there is no free memory. Although this function
+ *      %NULL is returned if there is no free memory. Although this function
  *      allocates memory it can be called from an interrupt.
  */
 static inline struct sk_buff *dev_alloc_skb(unsigned int length)
@@ -1097,6 +1125,28 @@ static inline struct sk_buff *dev_alloc_skb(unsigned int length)
         return __dev_alloc_skb(length, GFP_ATOMIC);
 }
 
+extern struct sk_buff *__netdev_alloc_skb(struct net_device *dev,
+                unsigned int length, gfp_t gfp_mask);
+
+/**
+ *      netdev_alloc_skb - allocate an skbuff for rx on a specific device
+ *      @dev: network device to receive on
+ *      @length: length to allocate
+ *
+ *      Allocate a new &sk_buff and assign it a usage count of one. The
+ *      buffer has unspecified headroom built in. Users should allocate
+ *      the headroom they think they need without accounting for the
+ *      built in space. The built in space is used for optimisations.
+ *
+ *      %NULL is returned if there is no free memory. Although this function
+ *      allocates memory it can be called from an interrupt.
+ */
+static inline struct sk_buff *netdev_alloc_skb(struct net_device *dev,
+                unsigned int length)
+{
+        return __netdev_alloc_skb(dev, length, GFP_ATOMIC);
+}
+
 /**
  *      skb_cow - copy header of skb when it is required
  *      @skb: buffer to cow
@@ -1212,14 +1262,14 @@ static inline int skb_linearize_cow(struct sk_buff *skb)
  *      @len: length of data pulled
  *
  *      After doing a pull on a received packet, you need to call this to
- *      update the CHECKSUM_HW checksum, or set ip_summed to CHECKSUM_NONE
- *      so that it can be recomputed from scratch.
+ *      update the CHECKSUM_COMPLETE checksum, or set ip_summed to
+ *      CHECKSUM_NONE so that it can be recomputed from scratch.
  */
 
 static inline void skb_postpull_rcsum(struct sk_buff *skb,
                                       const void *start, unsigned int len)
 {
-        if (skb->ip_summed == CHECKSUM_HW)
+        if (skb->ip_summed == CHECKSUM_COMPLETE)
                 skb->csum = csum_sub(skb->csum, csum_partial(start, len, 0));
 }
 
@@ -1238,7 +1288,7 @@ static inline int pskb_trim_rcsum(struct sk_buff *skb, unsigned int len)
 {
         if (likely(len >= skb->len))
                 return 0;
-        if (skb->ip_summed == CHECKSUM_HW)
+        if (skb->ip_summed == CHECKSUM_COMPLETE)
                 skb->ip_summed = CHECKSUM_NONE;
         return __pskb_trim(skb, len);
 }
@@ -1298,8 +1348,7 @@ extern void	       skb_copy_and_csum_dev(const struct sk_buff *skb, u8 *to);
 extern void            skb_split(struct sk_buff *skb,
                                  struct sk_buff *skb1, const u32 len);
 
-extern void            skb_release_data(struct sk_buff *skb);
-extern struct sk_buff *skb_segment(struct sk_buff *skb, int sg);
+extern struct sk_buff *skb_segment(struct sk_buff *skb, int features);
 
 static inline void *skb_header_pointer(const struct sk_buff *skb, int offset,
                                        int len, void *buffer)
@@ -1445,5 +1494,10 @@ static inline void skb_init_secmark(struct sk_buff *skb)
 { }
 #endif
 
+static inline int skb_is_gso(const struct sk_buff *skb)
+{
+        return skb_shinfo(skb)->gso_size;
+}
+
 #endif  /* __KERNEL__ */
 #endif  /* _LINUX_SKBUFF_H */