Removing unnecessary messages saves code and text.
Site specific OOM messages are duplications of a generic MM
out of memory message and aren't really useful, so just
delete them.
Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
        u16 capab;
 
        skb = dev_alloc_skb(sizeof(*mgmt) + local->hw.extra_tx_headroom);
-
-       if (!skb) {
-               printk(KERN_DEBUG "%s: failed to allocate buffer "
-                      "for addba resp frame\n", sdata->name);
+       if (!skb)
                return;
-       }
 
        skb_reserve(skb, local->hw.extra_tx_headroom);
        mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
 
        /* prepare A-MPDU MLME for Rx aggregation */
        tid_agg_rx = kmalloc(sizeof(struct tid_ampdu_rx), GFP_KERNEL);
-       if (!tid_agg_rx) {
-#ifdef CONFIG_MAC80211_HT_DEBUG
-               if (net_ratelimit())
-                       printk(KERN_ERR "allocate rx mlme to tid %d failed\n",
-                                       tid);
-#endif
+       if (!tid_agg_rx)
                goto end;
-       }
 
        spin_lock_init(&tid_agg_rx->reorder_lock);
 
        tid_agg_rx->reorder_time =
                kcalloc(buf_size, sizeof(unsigned long), GFP_KERNEL);
        if (!tid_agg_rx->reorder_buf || !tid_agg_rx->reorder_time) {
-#ifdef CONFIG_MAC80211_HT_DEBUG
-               if (net_ratelimit())
-                       printk(KERN_ERR "can not allocate reordering buffer "
-                              "to tid %d\n", tid);
-#endif
                kfree(tid_agg_rx->reorder_buf);
                kfree(tid_agg_rx->reorder_time);
                kfree(tid_agg_rx);
 
 
        skb = dev_alloc_skb(sizeof(*mgmt) + local->hw.extra_tx_headroom);
 
-       if (!skb) {
-               printk(KERN_ERR "%s: failed to allocate buffer "
-                               "for addba request frame\n", sdata->name);
+       if (!skb)
                return;
-       }
+
        skb_reserve(skb, local->hw.extra_tx_headroom);
        mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
        memset(mgmt, 0, 24);
        u16 bar_control = 0;
 
        skb = dev_alloc_skb(sizeof(*bar) + local->hw.extra_tx_headroom);
-       if (!skb) {
-               printk(KERN_ERR "%s: failed to allocate buffer for "
-                       "bar frame\n", sdata->name);
+       if (!skb)
                return;
-       }
+
        skb_reserve(skb, local->hw.extra_tx_headroom);
        bar = (struct ieee80211_bar *)skb_put(skb, sizeof(*bar));
        memset(bar, 0, sizeof(*bar));
        /* prepare A-MPDU MLME for Tx aggregation */
        tid_tx = kzalloc(sizeof(struct tid_ampdu_tx), GFP_ATOMIC);
        if (!tid_tx) {
-#ifdef CONFIG_MAC80211_HT_DEBUG
-               if (net_ratelimit())
-                       printk(KERN_ERR "allocate tx mlme to tid %d failed\n",
-                                       tid);
-#endif
                ret = -ENOMEM;
                goto err_unlock_sta;
        }
        struct ieee80211_ra_tid *ra_tid;
        struct sk_buff *skb = dev_alloc_skb(0);
 
-       if (unlikely(!skb)) {
-#ifdef CONFIG_MAC80211_HT_DEBUG
-               if (net_ratelimit())
-                       printk(KERN_WARNING "%s: Not enough memory, "
-                              "dropping start BA session", sdata->name);
-#endif
+       if (unlikely(!skb))
                return;
-       }
+
        ra_tid = (struct ieee80211_ra_tid *) &skb->cb;
        memcpy(&ra_tid->ra, ra, ETH_ALEN);
        ra_tid->tid = tid;
        struct ieee80211_ra_tid *ra_tid;
        struct sk_buff *skb = dev_alloc_skb(0);
 
-       if (unlikely(!skb)) {
-#ifdef CONFIG_MAC80211_HT_DEBUG
-               if (net_ratelimit())
-                       printk(KERN_WARNING "%s: Not enough memory, "
-                              "dropping stop BA session", sdata->name);
-#endif
+       if (unlikely(!skb))
                return;
-       }
+
        ra_tid = (struct ieee80211_ra_tid *) &skb->cb;
        memcpy(&ra_tid->ra, ra, ETH_ALEN);
        ra_tid->tid = tid;
 
        char *buf = kzalloc(mxln, GFP_KERNEL);
        int sf = 0; /* how many written so far */
 
+       if (!buf)
+               return 0;
+
        sf += snprintf(buf, mxln - sf, "0x%x\n", local->hw.flags);
        if (local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL)
                sf += snprintf(buf + sf, mxln - sf, "HAS_RATE_CONTROL\n");
 
        u16 params;
 
        skb = dev_alloc_skb(sizeof(*mgmt) + local->hw.extra_tx_headroom);
-
-       if (!skb) {
-               printk(KERN_ERR "%s: failed to allocate buffer "
-                                       "for delba frame\n", sdata->name);
+       if (!skb)
                return;
-       }
 
        skb_reserve(skb, local->hw.extra_tx_headroom);
        mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
 
        }
 
        p = kmem_cache_alloc(rm_cache, GFP_ATOMIC);
-       if (!p) {
-               printk(KERN_DEBUG "o11s: could not allocate RMC entry\n");
+       if (!p)
                return 0;
-       }
+
        p->seqnum = seqnum;
        p->exp_time = jiffies + RMC_TIMEOUT;
        memcpy(p->sa, sa, ETH_ALEN);
 
        struct ieee80211_mgmt *mgmt;
 
        skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt));
-       if (!skb) {
-               printk(KERN_DEBUG "%s: failed to allocate buffer for "
-                      "deauth/disassoc frame\n", sdata->name);
+       if (!skb)
                return;
-       }
+
        skb_reserve(skb, local->hw.extra_tx_headroom);
 
        mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
                return;
 
        skb = dev_alloc_skb(local->hw.extra_tx_headroom + 30);
-       if (!skb) {
-               printk(KERN_DEBUG "%s: failed to allocate buffer for 4addr "
-                      "nullfunc frame\n", sdata->name);
+       if (!skb)
                return;
-       }
+
        skb_reserve(skb, local->hw.extra_tx_headroom);
 
        nullfunc = (struct ieee80211_hdr *) skb_put(skb, 30);
        int err;
 
        sta = sta_info_alloc(sdata, bssid, GFP_KERNEL);
-       if (!sta) {
-               printk(KERN_DEBUG "%s: failed to alloc STA entry for"
-                          " the AP\n", sdata->name);
+       if (!sta)
                return -ENOMEM;
-       }
 
        sta->dummy = true;
 
 
 
        skb = dev_alloc_skb(sizeof(*msr_report) + local->hw.extra_tx_headroom +
                                sizeof(struct ieee80211_msrment_ie));
-
-       if (!skb) {
-               printk(KERN_ERR "%s: failed to allocate buffer for "
-                               "measurement report frame\n", sdata->name);
+       if (!skb)
                return;
-       }
 
        skb_reserve(skb, local->hw.extra_tx_headroom);
        msr_report = (struct ieee80211_mgmt *)skb_put(skb, 24);
 
        local = sdata->local;
 
        skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*pspoll));
-       if (!skb) {
-               printk(KERN_DEBUG "%s: failed to allocate buffer for "
-                      "pspoll template\n", sdata->name);
+       if (!skb)
                return NULL;
-       }
+
        skb_reserve(skb, local->hw.extra_tx_headroom);
 
        pspoll = (struct ieee80211_pspoll *) skb_put(skb, sizeof(*pspoll));
        local = sdata->local;
 
        skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*nullfunc));
-       if (!skb) {
-               printk(KERN_DEBUG "%s: failed to allocate buffer for nullfunc "
-                      "template\n", sdata->name);
+       if (!skb)
                return NULL;
-       }
+
        skb_reserve(skb, local->hw.extra_tx_headroom);
 
        nullfunc = (struct ieee80211_hdr_3addr *) skb_put(skb,
 
        skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*hdr) +
                            ie_ssid_len + ie_len);
-       if (!skb) {
-               printk(KERN_DEBUG "%s: failed to allocate buffer for probe "
-                      "request template\n", sdata->name);
+       if (!skb)
                return NULL;
-       }
 
        skb_reserve(skb, local->hw.extra_tx_headroom);
 
 
 
        skb = dev_alloc_skb(local->hw.extra_tx_headroom +
                            sizeof(*mgmt) + 6 + extra_len);
-       if (!skb) {
-               printk(KERN_DEBUG "%s: failed to allocate buffer for auth "
-                      "frame\n", sdata->name);
+       if (!skb)
                return;
-       }
+
        skb_reserve(skb, local->hw.extra_tx_headroom);
 
        mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24 + 6);
 
        /* FIXME: come up with a proper value */
        buf = kmalloc(200 + ie_len, GFP_KERNEL);
-       if (!buf) {
-               printk(KERN_DEBUG "%s: failed to allocate temporary IE "
-                      "buffer\n", sdata->name);
+       if (!buf)
                return NULL;
-       }
 
        /*
         * Do not send DS Channel parameter for directed probe requests
 
                        wk->ie_len + /* extra IEs */
                        9, /* WMM */
                        GFP_KERNEL);
-       if (!skb) {
-               printk(KERN_DEBUG "%s: failed to allocate buffer for assoc "
-                      "frame\n", sdata->name);
+       if (!skb)
                return;
-       }
+
        skb_reserve(skb, local->hw.extra_tx_headroom);
 
        capab = WLAN_CAPABILITY_ESS;