From: Greg Kroah-Hartman Date: Wed, 5 Jun 2013 21:12:30 +0000 (-0700) Subject: 3.9-stable patches X-Git-Tag: v3.0.81~1 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=7da1b66b20b4a45f463d72c113da04dd9dea8591;p=thirdparty%2Fkernel%2Fstable-queue.git 3.9-stable patches added patches: xen-netback-better-names-for-thresholds.patch --- diff --git a/queue-3.9/series b/queue-3.9/series index c7739d14ef1..8d89b2ed6bd 100644 --- a/queue-3.9/series +++ b/queue-3.9/series @@ -124,3 +124,4 @@ xen-netback-avoid-allocating-variable-size-array-on-stack.patch xen-netfront-reduce-gso_max_size-to-account-for-max-tcp-header.patch iwlwifi-mvm-remove-p2p_device-support.patch mac80211_hwsim-remove-p2p_device-support.patch +xen-netback-better-names-for-thresholds.patch diff --git a/queue-3.9/xen-netback-better-names-for-thresholds.patch b/queue-3.9/xen-netback-better-names-for-thresholds.patch new file mode 100644 index 00000000000..0d7675033bd --- /dev/null +++ b/queue-3.9/xen-netback-better-names-for-thresholds.patch @@ -0,0 +1,149 @@ +From 376414945d15aa636e65f7e773c1e398b7a21cb9 Mon Sep 17 00:00:00 2001 +From: Wei Liu +Date: Thu, 2 May 2013 00:43:59 +0000 +Subject: xen-netback: better names for thresholds + +From: Wei Liu + +commit 376414945d15aa636e65f7e773c1e398b7a21cb9 upstream. + +This patch only changes some names to avoid confusion. + +In this patch we have: + + MAX_SKB_SLOTS_DEFAULT -> FATAL_SKB_SLOTS_DEFAULT + max_skb_slots -> fatal_skb_slots + #define XEN_NETBK_LEGACY_SLOTS_MAX XEN_NETIF_NR_SLOTS_MIN + +The fatal_skb_slots is the threshold to determine whether a packet is +malicious. + +XEN_NETBK_LEGACY_SLOTS_MAX is the maximum slots a valid packet can have at +this point. It is defined to be XEN_NETIF_NR_SLOTS_MIN because that's +guaranteed to be supported by all backends. + +Suggested-by: Ian Campbell +Signed-off-by: Wei Liu +Signed-off-by: David S. Miller +Signed-off-by: Greg Kroah-Hartman + +--- + drivers/net/xen-netback/netback.c | 49 ++++++++++++++++++++++---------------- + 1 file changed, 29 insertions(+), 20 deletions(-) + +--- a/drivers/net/xen-netback/netback.c ++++ b/drivers/net/xen-netback/netback.c +@@ -51,9 +51,17 @@ + * This is the maximum slots a skb can have. If a guest sends a skb + * which exceeds this limit it is considered malicious. + */ +-#define MAX_SKB_SLOTS_DEFAULT 20 +-static unsigned int max_skb_slots = MAX_SKB_SLOTS_DEFAULT; +-module_param(max_skb_slots, uint, 0444); ++#define FATAL_SKB_SLOTS_DEFAULT 20 ++static unsigned int fatal_skb_slots = FATAL_SKB_SLOTS_DEFAULT; ++module_param(fatal_skb_slots, uint, 0444); ++ ++/* ++ * To avoid confusion, we define XEN_NETBK_LEGACY_SLOTS_MAX indicating ++ * the maximum slots a valid packet can use. Now this value is defined ++ * to be XEN_NETIF_NR_SLOTS_MIN, which is supposed to be supported by ++ * all backend. ++ */ ++#define XEN_NETBK_LEGACY_SLOTS_MAX XEN_NETIF_NR_SLOTS_MIN + + typedef unsigned int pending_ring_idx_t; + #define INVALID_PENDING_RING_IDX (~0U) +@@ -953,25 +961,26 @@ static int netbk_count_requests(struct x + /* This guest is really using too many slots and + * considered malicious. + */ +- if (unlikely(slots >= max_skb_slots)) { ++ if (unlikely(slots >= fatal_skb_slots)) { + netdev_err(vif->dev, + "Malicious frontend using %d slots, threshold %u\n", +- slots, max_skb_slots); ++ slots, fatal_skb_slots); + netbk_fatal_tx_err(vif); + return -E2BIG; + } + + /* Xen network protocol had implicit dependency on +- * MAX_SKB_FRAGS. XEN_NETIF_NR_SLOTS_MIN is set to the +- * historical MAX_SKB_FRAGS value 18 to honor the same +- * behavior as before. Any packet using more than 18 +- * slots but less than max_skb_slots slots is dropped ++ * MAX_SKB_FRAGS. XEN_NETBK_LEGACY_SLOTS_MAX is set to ++ * the historical MAX_SKB_FRAGS value 18 to honor the ++ * same behavior as before. Any packet using more than ++ * 18 slots but less than fatal_skb_slots slots is ++ * dropped + */ +- if (!drop_err && slots >= XEN_NETIF_NR_SLOTS_MIN) { ++ if (!drop_err && slots >= XEN_NETBK_LEGACY_SLOTS_MAX) { + if (net_ratelimit()) + netdev_dbg(vif->dev, + "Too many slots (%d) exceeding limit (%d), dropping packet\n", +- slots, XEN_NETIF_NR_SLOTS_MIN); ++ slots, XEN_NETBK_LEGACY_SLOTS_MAX); + drop_err = -E2BIG; + } + +@@ -1053,7 +1062,7 @@ static struct gnttab_copy *xen_netbk_get + struct pending_tx_info *first = NULL; + + /* At this point shinfo->nr_frags is in fact the number of +- * slots, which can be as large as XEN_NETIF_NR_SLOTS_MIN. ++ * slots, which can be as large as XEN_NETBK_LEGACY_SLOTS_MAX. + */ + nr_slots = shinfo->nr_frags; + +@@ -1420,12 +1429,12 @@ static unsigned xen_netbk_tx_build_gops( + struct sk_buff *skb; + int ret; + +- while ((nr_pending_reqs(netbk) + XEN_NETIF_NR_SLOTS_MIN ++ while ((nr_pending_reqs(netbk) + XEN_NETBK_LEGACY_SLOTS_MAX + < MAX_PENDING_REQS) && + !list_empty(&netbk->net_schedule_list)) { + struct xenvif *vif; + struct xen_netif_tx_request txreq; +- struct xen_netif_tx_request txfrags[XEN_NETIF_NR_SLOTS_MIN]; ++ struct xen_netif_tx_request txfrags[XEN_NETBK_LEGACY_SLOTS_MAX]; + struct page *page; + struct xen_netif_extra_info extras[XEN_NETIF_EXTRA_TYPE_MAX-1]; + u16 pending_idx; +@@ -1513,7 +1522,7 @@ static unsigned xen_netbk_tx_build_gops( + pending_idx = netbk->pending_ring[index]; + + data_len = (txreq.size > PKT_PROT_LEN && +- ret < XEN_NETIF_NR_SLOTS_MIN) ? ++ ret < XEN_NETBK_LEGACY_SLOTS_MAX) ? + PKT_PROT_LEN : txreq.size; + + skb = alloc_skb(data_len + NET_SKB_PAD + NET_IP_ALIGN, +@@ -1789,7 +1798,7 @@ static inline int rx_work_todo(struct xe + static inline int tx_work_todo(struct xen_netbk *netbk) + { + +- if ((nr_pending_reqs(netbk) + XEN_NETIF_NR_SLOTS_MIN ++ if ((nr_pending_reqs(netbk) + XEN_NETBK_LEGACY_SLOTS_MAX + < MAX_PENDING_REQS) && + !list_empty(&netbk->net_schedule_list)) + return 1; +@@ -1874,11 +1883,11 @@ static int __init netback_init(void) + if (!xen_domain()) + return -ENODEV; + +- if (max_skb_slots < XEN_NETIF_NR_SLOTS_MIN) { ++ if (fatal_skb_slots < XEN_NETBK_LEGACY_SLOTS_MAX) { + printk(KERN_INFO +- "xen-netback: max_skb_slots too small (%d), bump it to XEN_NETIF_NR_SLOTS_MIN (%d)\n", +- max_skb_slots, XEN_NETIF_NR_SLOTS_MIN); +- max_skb_slots = XEN_NETIF_NR_SLOTS_MIN; ++ "xen-netback: fatal_skb_slots too small (%d), bump it to XEN_NETBK_LEGACY_SLOTS_MAX (%d)\n", ++ fatal_skb_slots, XEN_NETBK_LEGACY_SLOTS_MAX); ++ fatal_skb_slots = XEN_NETBK_LEGACY_SLOTS_MAX; + } + + xen_netbk_group_nr = num_online_cpus();