Changeset 19484


Ignore:
Timestamp:
Jul 14, 2012, 1:26:03 PM (5 years ago)
Author:
BrainSlayer
Message:

Update to 3.2.23

Location:
src/linux/universal/linux-3.2
Files:
56 edited

Legend:

Unmodified
Added
Removed
  • src/linux/universal/linux-3.2/Makefile

    r19457 r19484  
    11VERSION = 3
    22PATCHLEVEL = 2
    3 SUBLEVEL = 22
     3SUBLEVEL = 23
    44EXTRAVERSION =
    55NAME = Saber-toothed Squirrel
  • src/linux/universal/linux-3.2/arch/arm/kernel/smp.c

    r19243 r19484  
    472472{
    473473        struct clock_event_device *evt = &__get_cpu_var(percpu_clockevent);
    474         irq_enter();
    475474        evt->event_handler(evt);
    476         irq_exit();
    477475}
    478476
     
    573571        switch (ipinr) {
    574572        case IPI_TIMER:
     573                irq_enter();
    575574                ipi_timer();
     575                irq_exit();
    576576                break;
    577577
     
    581581
    582582        case IPI_CALL_FUNC:
     583                irq_enter();
    583584                generic_smp_call_function_interrupt();
     585                irq_exit();
    584586                break;
    585587
    586588        case IPI_CALL_FUNC_SINGLE:
     589                irq_enter();
    587590                generic_smp_call_function_single_interrupt();
     591                irq_exit();
    588592                break;
    589593
    590594        case IPI_CPU_STOP:
     595                irq_enter();
    591596                ipi_cpu_stop(cpu);
     597                irq_exit();
    592598                break;
    593599
  • src/linux/universal/linux-3.2/arch/powerpc/kvm/book3s_hv_rmhandlers.S

    r18171 r19484  
    764764        lwz     r4,VCPU_PTID(r9)
    765765        li      r0,1
    766         sldi    r0,r0,r4
     766        sld     r0,r0,r4
    767767        andc.   r3,r3,r0                /* no sense IPI'ing ourselves */
    768768        beq     43f
  • src/linux/universal/linux-3.2/arch/powerpc/xmon/xmon.c

    r18171 r19484  
    976976                printf("cpus stopped:");
    977977                count = 0;
    978                 for (cpu = 0; cpu < NR_CPUS; ++cpu) {
     978                for_each_possible_cpu(cpu) {
    979979                        if (cpumask_test_cpu(cpu, &cpus_in_xmon)) {
    980980                                if (count == 0)
  • src/linux/universal/linux-3.2/drivers/block/umem.c

    r18171 r19484  
    514514}
    515515
     516struct mm_plug_cb {
     517        struct blk_plug_cb cb;
     518        struct cardinfo *card;
     519};
     520
     521static void mm_unplug(struct blk_plug_cb *cb)
     522{
     523        struct mm_plug_cb *mmcb = container_of(cb, struct mm_plug_cb, cb);
     524
     525        spin_lock_irq(&mmcb->card->lock);
     526        activate(mmcb->card);
     527        spin_unlock_irq(&mmcb->card->lock);
     528        kfree(mmcb);
     529}
     530
     531static int mm_check_plugged(struct cardinfo *card)
     532{
     533        struct blk_plug *plug = current->plug;
     534        struct mm_plug_cb *mmcb;
     535
     536        if (!plug)
     537                return 0;
     538
     539        list_for_each_entry(mmcb, &plug->cb_list, cb.list) {
     540                if (mmcb->cb.callback == mm_unplug && mmcb->card == card)
     541                        return 1;
     542        }
     543        /* Not currently on the callback list */
     544        mmcb = kmalloc(sizeof(*mmcb), GFP_ATOMIC);
     545        if (!mmcb)
     546                return 0;
     547
     548        mmcb->card = card;
     549        mmcb->cb.callback = mm_unplug;
     550        list_add(&mmcb->cb.list, &plug->cb_list);
     551        return 1;
     552}
     553
    516554static void mm_make_request(struct request_queue *q, struct bio *bio)
    517555{
     
    524562        bio->bi_next = NULL;
    525563        card->biotail = &bio->bi_next;
     564        if (bio->bi_rw & REQ_SYNC || !mm_check_plugged(card))
     565                activate(card);
    526566        spin_unlock_irq(&card->lock);
    527567
  • src/linux/universal/linux-3.2/drivers/gpu/drm/i915/i915_dma.c

    r18470 r19484  
    18911891}
    18921892
     1893static void i915_kick_out_firmware_fb(struct drm_i915_private *dev_priv)
     1894{
     1895        struct apertures_struct *ap;
     1896        struct pci_dev *pdev = dev_priv->dev->pdev;
     1897        bool primary;
     1898
     1899        ap = alloc_apertures(1);
     1900        if (!ap)
     1901                return;
     1902
     1903        ap->ranges[0].base = dev_priv->dev->agp->base;
     1904        ap->ranges[0].size =
     1905                dev_priv->mm.gtt->gtt_mappable_entries << PAGE_SHIFT;
     1906        primary =
     1907                pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW;
     1908
     1909        remove_conflicting_framebuffers(ap, "inteldrmfb", primary);
     1910
     1911        kfree(ap);
     1912}
     1913
    18931914/**
    18941915 * i915_driver_load - setup chip and create an initial config
     
    19281949        }
    19291950
     1951        dev_priv->mm.gtt = intel_gtt_get();
     1952        if (!dev_priv->mm.gtt) {
     1953                DRM_ERROR("Failed to initialize GTT\n");
     1954                ret = -ENODEV;
     1955                goto put_bridge;
     1956        }
     1957
     1958        i915_kick_out_firmware_fb(dev_priv);
     1959
    19301960        /* overlay on gen2 is broken and can't address above 1G */
    19311961        if (IS_GEN2(dev))
     
    19491979                ret = -EIO;
    19501980                goto put_bridge;
    1951         }
    1952 
    1953         dev_priv->mm.gtt = intel_gtt_get();
    1954         if (!dev_priv->mm.gtt) {
    1955                 DRM_ERROR("Failed to initialize GTT\n");
    1956                 ret = -ENODEV;
    1957                 goto out_rmmap;
    19581981        }
    19591982
  • src/linux/universal/linux-3.2/drivers/md/persistent-data/dm-space-map-checker.c

    r18171 r19484  
    99#include <linux/device-mapper.h>
    1010#include <linux/export.h>
     11#include <linux/vmalloc.h>
    1112
    1213#ifdef CONFIG_DM_DEBUG_SPACE_MAPS
     
    9091        ca->nr = nr_blocks;
    9192        ca->nr_free = nr_blocks;
    92         ca->counts = kzalloc(sizeof(*ca->counts) * nr_blocks, GFP_KERNEL);
    93         if (!ca->counts)
    94                 return -ENOMEM;
    95 
    96         return 0;
     93
     94        if (!nr_blocks)
     95                ca->counts = NULL;
     96        else {
     97                ca->counts = vzalloc(sizeof(*ca->counts) * nr_blocks);
     98                if (!ca->counts)
     99                        return -ENOMEM;
     100        }
     101
     102        return 0;
     103}
     104
     105static void ca_destroy(struct count_array *ca)
     106{
     107        vfree(ca->counts);
    97108}
    98109
     
    127138{
    128139        dm_block_t nr_blocks = ca->nr + extra_blocks;
    129         uint32_t *counts = kzalloc(sizeof(*counts) * nr_blocks, GFP_KERNEL);
     140        uint32_t *counts = vzalloc(sizeof(*counts) * nr_blocks);
    130141        if (!counts)
    131142                return -ENOMEM;
    132143
    133         memcpy(counts, ca->counts, sizeof(*counts) * ca->nr);
    134         kfree(ca->counts);
     144        if (ca->counts) {
     145                memcpy(counts, ca->counts, sizeof(*counts) * ca->nr);
     146                ca_destroy(ca);
     147        }
    135148        ca->nr = nr_blocks;
    136149        ca->nr_free += extra_blocks;
     
    150163        memcpy(old->counts, new->counts, sizeof(*old->counts) * old->nr);
    151164        return 0;
    152 }
    153 
    154 static void ca_destroy(struct count_array *ca)
    155 {
    156         kfree(ca->counts);
    157165}
    158166
     
    344352        struct sm_checker *smc;
    345353
    346         if (!sm)
    347                 return NULL;
     354        if (IS_ERR_OR_NULL(sm))
     355                return ERR_PTR(-EINVAL);
    348356
    349357        smc = kmalloc(sizeof(*smc), GFP_KERNEL);
    350358        if (!smc)
    351                 return NULL;
     359                return ERR_PTR(-ENOMEM);
    352360
    353361        memcpy(&smc->sm, &ops_, sizeof(smc->sm));
     
    355363        if (r) {
    356364                kfree(smc);
    357                 return NULL;
     365                return ERR_PTR(r);
    358366        }
    359367
     
    362370                ca_destroy(&smc->old_counts);
    363371                kfree(smc);
    364                 return NULL;
     372                return ERR_PTR(r);
    365373        }
    366374
     
    372380                ca_destroy(&smc->old_counts);
    373381                kfree(smc);
    374                 return NULL;
     382                return ERR_PTR(r);
    375383        }
    376384
     
    380388                ca_destroy(&smc->old_counts);
    381389                kfree(smc);
    382                 return NULL;
     390                return ERR_PTR(r);
    383391        }
    384392
     
    392400        struct sm_checker *smc;
    393401
    394         if (!sm)
    395                 return NULL;
     402        if (IS_ERR_OR_NULL(sm))
     403                return ERR_PTR(-EINVAL);
    396404
    397405        smc = kmalloc(sizeof(*smc), GFP_KERNEL);
    398406        if (!smc)
    399                 return NULL;
     407                return ERR_PTR(-ENOMEM);
    400408
    401409        memcpy(&smc->sm, &ops_, sizeof(smc->sm));
     
    403411        if (r) {
    404412                kfree(smc);
    405                 return NULL;
     413                return ERR_PTR(r);
    406414        }
    407415
     
    410418                ca_destroy(&smc->old_counts);
    411419                kfree(smc);
    412                 return NULL;
     420                return ERR_PTR(r);
    413421        }
    414422
  • src/linux/universal/linux-3.2/drivers/md/persistent-data/dm-space-map-disk.c

    r18171 r19484  
    291291{
    292292        struct dm_space_map *sm = dm_sm_disk_create_real(tm, nr_blocks);
    293         return dm_sm_checker_create_fresh(sm);
     293        struct dm_space_map *smc;
     294
     295        if (IS_ERR_OR_NULL(sm))
     296                return sm;
     297
     298        smc = dm_sm_checker_create_fresh(sm);
     299        if (IS_ERR(smc))
     300                dm_sm_destroy(sm);
     301
     302        return smc;
    294303}
    295304EXPORT_SYMBOL_GPL(dm_sm_disk_create);
  • src/linux/universal/linux-3.2/drivers/md/persistent-data/dm-transaction-manager.c

    r18171 r19484  
    139139void dm_tm_destroy(struct dm_transaction_manager *tm)
    140140{
     141        if (!tm->is_clone)
     142                wipe_shadow_table(tm);
     143
    141144        kfree(tm);
    142145}
     
    343346
    344347                *sm = dm_sm_checker_create(inner);
    345                 if (!*sm)
     348                if (IS_ERR(*sm)) {
     349                        r = PTR_ERR(*sm);
    346350                        goto bad2;
     351                }
    347352
    348353        } else {
     
    363368
    364369                *sm = dm_sm_checker_create(inner);
    365                 if (!*sm)
     370                if (IS_ERR(*sm)) {
     371                        r = PTR_ERR(*sm);
    366372                        goto bad2;
     373                }
    367374        }
    368375
  • src/linux/universal/linux-3.2/drivers/md/raid10.c

    r18879 r19484  
    19201920                                             r10_bio->devs[sl].addr +
    19211921                                             sect,
    1922                                              s<<9, conf->tmppage, WRITE)
     1922                                             s, conf->tmppage, WRITE)
    19231923                            == 0) {
    19241924                                /* Well, this device is dead */
     
    19571957                                             r10_bio->devs[sl].addr +
    19581958                                             sect,
    1959                                              s<<9, conf->tmppage,
     1959                                             s, conf->tmppage,
    19601960                                                 READ)) {
    19611961                        case 0:
     
    21202120        printk_ratelimited(
    21212121                KERN_ERR
    2122                 "md/raid10:%s: %s: redirecting"
     2122                "md/raid10:%s: %s: redirecting "
    21232123                "sector %llu to another mirror\n",
    21242124                mdname(mddev),
     
    24372437                        rb2 = r10_bio;
    24382438                        sect = raid10_find_virt(conf, sector_nr, i);
     2439                        if (sect >= mddev->resync_max_sectors) {
     2440                                /* last stripe is not complete - don't
     2441                                 * try to recover this sector.
     2442                                 */
     2443                                continue;
     2444                        }
    24392445                        /* Unless we are doing a full sync, we only need
    24402446                         * to recover the block if it is set in the bitmap
  • src/linux/universal/linux-3.2/drivers/md/raid5.c

    r18171 r19484  
    543543                                        md_check_recovery(conf->mddev);
    544544                                }
     545                                /*
     546                                 * Because md_wait_for_blocked_rdev
     547                                 * will dec nr_pending, we must
     548                                 * increment it first.
     549                                 */
     550                                atomic_inc(&rdev->nr_pending);
    545551                                md_wait_for_blocked_rdev(rdev, conf->mddev);
    546552                        } else {
     
    36223628                align_bi->bi_bdev =  rdev->bdev;
    36233629                align_bi->bi_flags &= ~(1 << BIO_SEG_VALID);
    3624                 align_bi->bi_sector += rdev->data_offset;
    36253630
    36263631                if (!bio_fits_rdev(align_bi) ||
     
    36323637                        return 0;
    36333638                }
     3639
     3640                /* No reshape active, so we can trust rdev->data_offset */
     3641                align_bi->bi_sector += rdev->data_offset;
    36343642
    36353643                spin_lock_irq(&conf->device_lock);
  • src/linux/universal/linux-3.2/drivers/mtd/nand/cafe_nand.c

    r18171 r19484  
    103103{
    104104        struct cafe_priv *cafe = mtd->priv;
    105         int result = !!(cafe_readl(cafe, NAND_STATUS) | 0x40000000);
     105        int result = !!(cafe_readl(cafe, NAND_STATUS) & 0x40000000);
    106106        uint32_t irqs = cafe_readl(cafe, NAND_IRQ);
    107107
  • src/linux/universal/linux-3.2/drivers/net/bonding/bond_main.c

    r19243 r19484  
    7878#include <net/net_namespace.h>
    7979#include <net/netns/generic.h>
     80#include <net/pkt_sched.h>
    8081#include "bonding.h"
    8182#include "bond_3ad.h"
     
    389390}
    390391
    391 #define bond_queue_mapping(skb) (*(u16 *)((skb)->cb))
    392 
    393392/**
    394393 * bond_dev_queue_xmit - Prepare skb for xmit.
     
    403402        skb->dev = slave_dev;
    404403
    405         skb->queue_mapping = bond_queue_mapping(skb);
     404        BUILD_BUG_ON(sizeof(skb->queue_mapping) !=
     405                     sizeof(qdisc_skb_cb(skb)->bond_queue_mapping));
     406        skb->queue_mapping = qdisc_skb_cb(skb)->bond_queue_mapping;
    406407
    407408        if (unlikely(netpoll_tx_running(slave_dev)))
     
    43014302         * Save the original txq to restore before passing to the driver
    43024303         */
    4303         bond_queue_mapping(skb) = skb->queue_mapping;
     4304        qdisc_skb_cb(skb)->bond_queue_mapping = skb->queue_mapping;
    43044305
    43054306        if (unlikely(txq >= dev->real_num_tx_queues)) {
  • src/linux/universal/linux-3.2/drivers/net/dummy.c

    r19243 r19484  
    3838#include <net/rtnetlink.h>
    3939#include <linux/u64_stats_sync.h>
     40#include <linux/sched.h>
    4041
    4142static int numdummies = 1;
     
    187188        err = __rtnl_link_register(&dummy_link_ops);
    188189
    189         for (i = 0; i < numdummies && !err; i++)
     190        for (i = 0; i < numdummies && !err; i++) {
    190191                err = dummy_init_one();
     192                cond_resched();
     193        }
    191194        if (err < 0)
    192195                __rtnl_link_unregister(&dummy_link_ops);
  • src/linux/universal/linux-3.2/drivers/net/ethernet/emulex/benet/be_main.c

    r18171 r19484  
    697697        copied = make_tx_wrbs(adapter, txq, skb, wrb_cnt, dummy_wrb);
    698698        if (copied) {
     699                int gso_segs = skb_shinfo(skb)->gso_segs;
     700
    699701                /* record the sent skb in the sent_skb table */
    700702                BUG_ON(txo->sent_skb_list[start]);
     
    714716                be_txq_notify(adapter, txq->id, wrb_cnt);
    715717
    716                 be_tx_stats_update(txo, wrb_cnt, copied,
    717                                 skb_shinfo(skb)->gso_segs, stopped);
     718                be_tx_stats_update(txo, wrb_cnt, copied, gso_segs, stopped);
    718719        } else {
    719720                txq->head = start;
  • src/linux/universal/linux-3.2/drivers/net/ethernet/marvell/sky2.c

    r19278 r19484  
    43624362        u32 changed = dev->features ^ features;
    43634363
    4364         if (changed & NETIF_F_RXCSUM) {
    4365                 u32 on = features & NETIF_F_RXCSUM;
    4366                 sky2_write32(sky2->hw, Q_ADDR(rxqaddr[sky2->port], Q_CSR),
    4367                              on ? BMU_ENA_RX_CHKSUM : BMU_DIS_RX_CHKSUM);
     4364        if ((changed & NETIF_F_RXCSUM) &&
     4365            !(sky2->hw->flags & SKY2_HW_NEW_LE)) {
     4366                sky2_write32(sky2->hw,
     4367                             Q_ADDR(rxqaddr[sky2->port], Q_CSR),
     4368                             (features & NETIF_F_RXCSUM)
     4369                             ? BMU_ENA_RX_CHKSUM : BMU_DIS_RX_CHKSUM);
    43684370        }
    43694371
  • src/linux/universal/linux-3.2/drivers/net/wireless/ath/ath.h

    r18171 r19484  
    144144        DECLARE_BITMAP(keymap, ATH_KEYMAX);
    145145        DECLARE_BITMAP(tkip_keymap, ATH_KEYMAX);
     146        DECLARE_BITMAP(ccmp_keymap, ATH_KEYMAX);
    146147        enum ath_crypt_caps crypt_caps;
    147148
  • src/linux/universal/linux-3.2/drivers/net/wireless/ath/ath9k/hw.c

    r19457 r19484  
    558558        if (ah->config.serialize_regmode == SER_REG_MODE_AUTO) {
    559559                if (ah->hw_version.macVersion == AR_SREV_VERSION_5416_PCI ||
    560                     ((AR_SREV_9160(ah) || AR_SREV_9280(ah)) &&
     560                    ((AR_SREV_9160(ah) || AR_SREV_9280(ah) || AR_SREV_9287(ah)) &&
    561561                     !ah->is_pciexpress)) {
    562562                        ah->config.serialize_regmode =
  • src/linux/universal/linux-3.2/drivers/net/wireless/ath/ath9k/recv.c

    r18520 r19484  
    830830         * mostly with CCMP encryption.
    831831         */
    832         if (rx_stats->rs_keyix == ATH9K_RXKEYIX_INVALID)
     832        if (rx_stats->rs_keyix == ATH9K_RXKEYIX_INVALID ||
     833            !test_bit(rx_stats->rs_keyix, common->ccmp_keymap))
    833834                rx_stats->rs_status &= ~ATH9K_RXERR_KEYMISS;
    834835
  • src/linux/universal/linux-3.2/drivers/net/wireless/ath/key.c

    r18171 r19484  
    557557
    558558        set_bit(idx, common->keymap);
     559        if (key->cipher == WLAN_CIPHER_SUITE_CCMP)
     560                set_bit(idx, common->ccmp_keymap);
     561
    559562        if (key->cipher == WLAN_CIPHER_SUITE_TKIP) {
    560563                set_bit(idx + 64, common->keymap);
     
    583586
    584587        clear_bit(key->hw_key_idx, common->keymap);
     588        clear_bit(key->hw_key_idx, common->ccmp_keymap);
    585589        if (key->cipher != WLAN_CIPHER_SUITE_TKIP)
    586590                return;
  • src/linux/universal/linux-3.2/drivers/net/wireless/mwifiex/11n_rxreorder.c

    r18171 r19484  
    268268                last_seq = priv->rx_seq[tid];
    269269
    270         if (last_seq >= new_node->start_win)
     270        if (last_seq != MWIFIEX_DEF_11N_RX_SEQ_NUM &&
     271            last_seq >= new_node->start_win)
    271272                new_node->start_win = last_seq + 1;
    272273
     
    612613
    613614        INIT_LIST_HEAD(&priv->rx_reorder_tbl_ptr);
    614         memset(priv->rx_seq, 0, sizeof(priv->rx_seq));
    615 }
     615        mwifiex_reset_11n_rx_seq_num(priv);
     616}
  • src/linux/universal/linux-3.2/drivers/net/wireless/mwifiex/11n_rxreorder.h

    r18171 r19484  
    3838#define ADDBA_RSP_STATUS_ACCEPT 0
    3939
     40#define MWIFIEX_DEF_11N_RX_SEQ_NUM      0xffff
     41
     42static inline void mwifiex_reset_11n_rx_seq_num(struct mwifiex_private *priv)
     43{
     44        memset(priv->rx_seq, 0xff, sizeof(priv->rx_seq));
     45}
     46
    4047int mwifiex_11n_rx_reorder_pkt(struct mwifiex_private *,
    4148                               u16 seqNum,
  • src/linux/universal/linux-3.2/drivers/net/wireless/mwifiex/cfg80211.c

    r18171 r19484  
    11781178
    11791179        if (!priv)
    1180                 return NULL;
     1180                return ERR_PTR(-EFAULT);
    11811181
    11821182        adapter = priv->adapter;
    11831183        if (!adapter)
    1184                 return NULL;
     1184                return ERR_PTR(-EFAULT);
    11851185
    11861186        switch (type) {
     
    11911191                        wiphy_err(wiphy, "cannot create multiple"
    11921192                                        " station/adhoc interfaces\n");
    1193                         return NULL;
     1193                        return ERR_PTR(-EINVAL);
    11941194                }
    11951195
     
    12091209        default:
    12101210                wiphy_err(wiphy, "type not supported\n");
    1211                 return NULL;
     1211                return ERR_PTR(-EINVAL);
    12121212        }
    12131213
     
    12161216        if (!dev) {
    12171217                wiphy_err(wiphy, "no memory available for netdevice\n");
    1218                 goto error;
     1218                priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
     1219                return ERR_PTR(-ENOMEM);
    12191220        }
    12201221
     
    12411242        if (register_netdevice(dev)) {
    12421243                wiphy_err(wiphy, "cannot register virtual network device\n");
    1243                 goto error;
     1244                free_netdev(dev);
     1245                priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
     1246                return ERR_PTR(-EFAULT);
    12441247        }
    12451248
     
    12531256#endif
    12541257        return dev;
    1255 error:
    1256         if (dev && (dev->reg_state == NETREG_UNREGISTERED))
    1257                 free_netdev(dev);
    1258         priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
    1259 
    1260         return NULL;
    12611258}
    12621259EXPORT_SYMBOL_GPL(mwifiex_add_virtual_intf);
  • src/linux/universal/linux-3.2/drivers/net/wireless/mwifiex/wmm.c

    r18171 r19484  
    406406                priv->add_ba_param.tx_win_size = MWIFIEX_AMPDU_DEF_TXWINSIZE;
    407407                priv->add_ba_param.rx_win_size = MWIFIEX_AMPDU_DEF_RXWINSIZE;
     408
     409                mwifiex_reset_11n_rx_seq_num(priv);
    408410
    409411                atomic_set(&priv->wmm.tx_pkts_queued, 0);
     
    12101212        }
    12111213
    1212         if (!ptr->is_11n_enabled || mwifiex_is_ba_stream_setup(priv, ptr, tid)
    1213             || ((priv->sec_info.wpa_enabled
    1214                   || priv->sec_info.wpa2_enabled) && !priv->wpa_is_gtk_set)
    1215                 ) {
     1214        if (!ptr->is_11n_enabled ||
     1215            mwifiex_is_ba_stream_setup(priv, ptr, tid) ||
     1216            priv->wps.session_enable ||
     1217            ((priv->sec_info.wpa_enabled ||
     1218              priv->sec_info.wpa2_enabled) &&
     1219             !priv->wpa_is_gtk_set)) {
    12161220                mwifiex_send_single_packet(priv, ptr, ptr_index, flags);
    12171221                /* ra_list_spinlock has been freed in
  • src/linux/universal/linux-3.2/drivers/net/wireless/rtlwifi/rtl8192cu/sw.c

    r18701 r19484  
    312312        {RTL_USB_DEVICE(0x07b8, 0x8189, rtl92cu_hal_cfg)}, /*Funai - Abocom*/
    313313        {RTL_USB_DEVICE(0x0846, 0x9041, rtl92cu_hal_cfg)}, /*NetGear WNA1000M*/
     314        {RTL_USB_DEVICE(0x0bda, 0x5088, rtl92cu_hal_cfg)}, /*Thinkware-CC&C*/
    314315        {RTL_USB_DEVICE(0x0df6, 0x0052, rtl92cu_hal_cfg)}, /*Sitecom - Edimax*/
    315316        {RTL_USB_DEVICE(0x0df6, 0x005c, rtl92cu_hal_cfg)}, /*Sitecom - Edimax*/
    316317        {RTL_USB_DEVICE(0x0eb0, 0x9071, rtl92cu_hal_cfg)}, /*NO Brand - Etop*/
     318        {RTL_USB_DEVICE(0x4856, 0x0091, rtl92cu_hal_cfg)}, /*NetweeN - Feixun*/
    317319        /* HP - Lite-On ,8188CUS Slim Combo */
    318320        {RTL_USB_DEVICE(0x103c, 0x1629, rtl92cu_hal_cfg)},
     
    356358        {RTL_USB_DEVICE(0x0846, 0x9021, rtl92cu_hal_cfg)}, /*Netgear-Sercomm*/
    357359        {RTL_USB_DEVICE(0x0b05, 0x17ab, rtl92cu_hal_cfg)}, /*ASUS-Edimax*/
     360        {RTL_USB_DEVICE(0x0bda, 0x8186, rtl92cu_hal_cfg)}, /*Realtek 92CE-VAU*/
    358361        {RTL_USB_DEVICE(0x0df6, 0x0061, rtl92cu_hal_cfg)}, /*Sitecom-Edimax*/
    359362        {RTL_USB_DEVICE(0x0e66, 0x0019, rtl92cu_hal_cfg)}, /*Hawking-Edimax*/
  • src/linux/universal/linux-3.2/drivers/target/tcm_fc/tfc_sess.c

    r18171 r19484  
    6262        int i;
    6363
    64         tport = rcu_dereference(lport->prov[FC_TYPE_FCP]);
     64        tport = rcu_dereference_protected(lport->prov[FC_TYPE_FCP],
     65                                          lockdep_is_held(&ft_lport_lock));
    6566        if (tport && tport->tpg)
    6667                return tport;
  • src/linux/universal/linux-3.2/fs/btrfs/tree-log.c

    r18171 r19484  
    693693
    694694        iput(inode);
     695
     696        btrfs_run_delayed_items(trans, root);
    695697        return ret;
    696698}
     
    898900                                                         inode, victim_name,
    899901                                                         victim_name_len);
     902                                btrfs_run_delayed_items(trans, root);
    900903                        }
    901904                        kfree(victim_name);
     
    14781481                                                 name, name_len);
    14791482                        BUG_ON(ret);
     1483
     1484                        btrfs_run_delayed_items(trans, root);
     1485
    14801486                        kfree(name);
    14811487                        iput(inode);
  • src/linux/universal/linux-3.2/fs/cifs/connect.c

    r18879 r19484  
    29762976         * bufsize for reads, testing against win98se shows that it throws
    29772977         * INVALID_PARAMETER errors if you try to request too large a read.
     2978         * OS/2 just sends back short reads.
    29782979         *
    2979          * If the server advertises a MaxBufferSize of less than one page,
    2980          * assume that it also can't satisfy reads larger than that either.
    2981          *
    2982          * FIXME: Is there a better heuristic for this?
     2980         * If the server doesn't advertise CAP_LARGE_READ_X, then assume that
     2981         * it can't handle a read request larger than its MaxBufferSize either.
    29832982         */
    29842983        if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_READ_CAP))
     
    29862985        else if (server->capabilities & CAP_LARGE_READ_X)
    29872986                defsize = CIFS_DEFAULT_NON_POSIX_RSIZE;
    2988         else if (server->maxBuf >= PAGE_CACHE_SIZE)
    2989                 defsize = CIFSMaxBufSize;
    29902987        else
    29912988                defsize = server->maxBuf - sizeof(READ_RSP);
  • src/linux/universal/linux-3.2/fs/ocfs2/file.c

    r18171 r19484  
    24232423        }
    24242424
    2425         if (unaligned_dio)
     2425        if (unaligned_dio) {
     2426                ocfs2_iocb_clear_unaligned_aio(iocb);
    24262427                atomic_dec(&OCFS2_I(inode)->ip_unaligned_aio);
     2428        }
    24272429
    24282430out:
  • src/linux/universal/linux-3.2/fs/open.c

    r18171 r19484  
    397397        struct file *file;
    398398        struct inode *inode;
    399         int error;
     399        int error, fput_needed;
    400400
    401401        error = -EBADF;
    402         file = fget(fd);
     402        file = fget_raw_light(fd, &fput_needed);
    403403        if (!file)
    404404                goto out;
     
    414414                set_fs_pwd(current->fs, &file->f_path);
    415415out_putf:
    416         fput(file);
     416        fput_light(file, fput_needed);
    417417out:
    418418        return error;
  • src/linux/universal/linux-3.2/fs/splice.c

    r19243 r19484  
    275275 * descriptions.
    276276 */
    277 int splice_grow_spd(struct pipe_inode_info *pipe, struct splice_pipe_desc *spd)
    278 {
    279         if (pipe->buffers <= PIPE_DEF_BUFFERS)
     277int splice_grow_spd(const struct pipe_inode_info *pipe, struct splice_pipe_desc *spd)
     278{
     279        unsigned int buffers = ACCESS_ONCE(pipe->buffers);
     280
     281        spd->nr_pages_max = buffers;
     282        if (buffers <= PIPE_DEF_BUFFERS)
    280283                return 0;
    281284
    282         spd->pages = kmalloc(pipe->buffers * sizeof(struct page *), GFP_KERNEL);
    283         spd->partial = kmalloc(pipe->buffers * sizeof(struct partial_page), GFP_KERNEL);
     285        spd->pages = kmalloc(buffers * sizeof(struct page *), GFP_KERNEL);
     286        spd->partial = kmalloc(buffers * sizeof(struct partial_page), GFP_KERNEL);
    284287
    285288        if (spd->pages && spd->partial)
     
    291294}
    292295
    293 void splice_shrink_spd(struct pipe_inode_info *pipe,
    294                        struct splice_pipe_desc *spd)
    295 {
    296         if (pipe->buffers <= PIPE_DEF_BUFFERS)
     296void splice_shrink_spd(struct splice_pipe_desc *spd)
     297{
     298        if (spd->nr_pages_max <= PIPE_DEF_BUFFERS)
    297299                return;
    298300
     
    317319                .pages = pages,
    318320                .partial = partial,
     321                .nr_pages_max = PIPE_DEF_BUFFERS,
    319322                .flags = flags,
    320323                .ops = &page_cache_pipe_buf_ops,
     
    328331        loff = *ppos & ~PAGE_CACHE_MASK;
    329332        req_pages = (len + loff + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
    330         nr_pages = min(req_pages, pipe->buffers);
     333        nr_pages = min(req_pages, spd.nr_pages_max);
    331334
    332335        /*
     
    499502                error = splice_to_pipe(pipe, &spd);
    500503
    501         splice_shrink_spd(pipe, &spd);
     504        splice_shrink_spd(&spd);
    502505        return error;
    503506}
     
    600603                .pages = pages,
    601604                .partial = partial,
     605                .nr_pages_max = PIPE_DEF_BUFFERS,
    602606                .flags = flags,
    603607                .ops = &default_pipe_buf_ops,
     
    610614        res = -ENOMEM;
    611615        vec = __vec;
    612         if (pipe->buffers > PIPE_DEF_BUFFERS) {
    613                 vec = kmalloc(pipe->buffers * sizeof(struct iovec), GFP_KERNEL);
     616        if (spd.nr_pages_max > PIPE_DEF_BUFFERS) {
     617                vec = kmalloc(spd.nr_pages_max * sizeof(struct iovec), GFP_KERNEL);
    614618                if (!vec)
    615619                        goto shrink_ret;
     
    619623        nr_pages = (len + offset + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
    620624
    621         for (i = 0; i < nr_pages && i < pipe->buffers && len; i++) {
     625        for (i = 0; i < nr_pages && i < spd.nr_pages_max && len; i++) {
    622626                struct page *page;
    623627
     
    667671        if (vec != __vec)
    668672                kfree(vec);
    669         splice_shrink_spd(pipe, &spd);
     673        splice_shrink_spd(&spd);
    670674        return res;
    671675
     
    16181622                .pages = pages,
    16191623                .partial = partial,
     1624                .nr_pages_max = PIPE_DEF_BUFFERS,
    16201625                .flags = flags,
    16211626                .ops = &user_page_pipe_buf_ops,
     
    16331638        spd.nr_pages = get_iovec_page_array(iov, nr_segs, spd.pages,
    16341639                                            spd.partial, flags & SPLICE_F_GIFT,
    1635                                             pipe->buffers);
     1640                                            spd.nr_pages_max);
    16361641        if (spd.nr_pages <= 0)
    16371642                ret = spd.nr_pages;
     
    16391644                ret = splice_to_pipe(pipe, &spd);
    16401645
    1641         splice_shrink_spd(pipe, &spd);
     1646        splice_shrink_spd(&spd);
    16421647        return ret;
    16431648}
  • src/linux/universal/linux-3.2/fs/udf/super.c

    r18470 r19484  
    5757#include <linux/bitmap.h>
    5858#include <linux/crc-itu-t.h>
     59#include <linux/log2.h>
    5960#include <asm/byteorder.h>
    6061
     
    12181219}
    12191220
     1221static int udf_load_sparable_map(struct super_block *sb,
     1222                                 struct udf_part_map *map,
     1223                                 struct sparablePartitionMap *spm)
     1224{
     1225        uint32_t loc;
     1226        uint16_t ident;
     1227        struct sparingTable *st;
     1228        struct udf_sparing_data *sdata = &map->s_type_specific.s_sparing;
     1229        int i;
     1230        struct buffer_head *bh;
     1231
     1232        map->s_partition_type = UDF_SPARABLE_MAP15;
     1233        sdata->s_packet_len = le16_to_cpu(spm->packetLength);
     1234        if (!is_power_of_2(sdata->s_packet_len)) {
     1235                udf_err(sb, "error loading logical volume descriptor: "
     1236                        "Invalid packet length %u\n",
     1237                        (unsigned)sdata->s_packet_len);
     1238                return -EIO;
     1239        }
     1240        if (spm->numSparingTables > 4) {
     1241                udf_err(sb, "error loading logical volume descriptor: "
     1242                        "Too many sparing tables (%d)\n",
     1243                        (int)spm->numSparingTables);
     1244                return -EIO;
     1245        }
     1246
     1247        for (i = 0; i < spm->numSparingTables; i++) {
     1248                loc = le32_to_cpu(spm->locSparingTable[i]);
     1249                bh = udf_read_tagged(sb, loc, loc, &ident);
     1250                if (!bh)
     1251                        continue;
     1252
     1253                st = (struct sparingTable *)bh->b_data;
     1254                if (ident != 0 ||
     1255                    strncmp(st->sparingIdent.ident, UDF_ID_SPARING,
     1256                            strlen(UDF_ID_SPARING)) ||
     1257                    sizeof(*st) + le16_to_cpu(st->reallocationTableLen) >
     1258                                                        sb->s_blocksize) {
     1259                        brelse(bh);
     1260                        continue;
     1261                }
     1262
     1263                sdata->s_spar_map[i] = bh;
     1264        }
     1265        map->s_partition_func = udf_get_pblock_spar15;
     1266        return 0;
     1267}
     1268
    12201269static int udf_load_logicalvol(struct super_block *sb, sector_t block,
    12211270                               struct kernel_lb_addr *fileset)
    12221271{
    12231272        struct logicalVolDesc *lvd;
    1224         int i, j, offset;
     1273        int i, offset;
    12251274        uint8_t type;
    12261275        struct udf_sb_info *sbi = UDF_SB(sb);
     
    12281277        uint16_t ident;
    12291278        struct buffer_head *bh;
     1279        unsigned int table_len;
    12301280        int ret = 0;
    12311281
     
    12351285        BUG_ON(ident != TAG_IDENT_LVD);
    12361286        lvd = (struct logicalVolDesc *)bh->b_data;
    1237 
    1238         i = udf_sb_alloc_partition_maps(sb, le32_to_cpu(lvd->numPartitionMaps));
    1239         if (i != 0) {
    1240                 ret = i;
     1287        table_len = le32_to_cpu(lvd->mapTableLength);
     1288        if (sizeof(*lvd) + table_len > sb->s_blocksize) {
     1289                udf_err(sb, "error loading logical volume descriptor: "
     1290                        "Partition table too long (%u > %lu)\n", table_len,
     1291                        sb->s_blocksize - sizeof(*lvd));
    12411292                goto out_bh;
    12421293        }
    12431294
     1295        ret = udf_sb_alloc_partition_maps(sb, le32_to_cpu(lvd->numPartitionMaps));
     1296        if (ret)
     1297                goto out_bh;
     1298
    12441299        for (i = 0, offset = 0;
    1245              i < sbi->s_partitions && offset < le32_to_cpu(lvd->mapTableLength);
     1300             i < sbi->s_partitions && offset < table_len;
    12461301             i++, offset += gpm->partitionMapLength) {
    12471302                struct udf_part_map *map = &sbi->s_partmaps[i];
     
    12781333                                                UDF_ID_SPARABLE,
    12791334                                                strlen(UDF_ID_SPARABLE))) {
    1280                                 uint32_t loc;
    1281                                 struct sparingTable *st;
    1282                                 struct sparablePartitionMap *spm =
    1283                                         (struct sparablePartitionMap *)gpm;
    1284 
    1285                                 map->s_partition_type = UDF_SPARABLE_MAP15;
    1286                                 map->s_type_specific.s_sparing.s_packet_len =
    1287                                                 le16_to_cpu(spm->packetLength);
    1288                                 for (j = 0; j < spm->numSparingTables; j++) {
    1289                                         struct buffer_head *bh2;
    1290 
    1291                                         loc = le32_to_cpu(
    1292                                                 spm->locSparingTable[j]);
    1293                                         bh2 = udf_read_tagged(sb, loc, loc,
    1294                                                              &ident);
    1295                                         map->s_type_specific.s_sparing.
    1296                                                         s_spar_map[j] = bh2;
    1297 
    1298                                         if (bh2 == NULL)
    1299                                                 continue;
    1300 
    1301                                         st = (struct sparingTable *)bh2->b_data;
    1302                                         if (ident != 0 || strncmp(
    1303                                                 st->sparingIdent.ident,
    1304                                                 UDF_ID_SPARING,
    1305                                                 strlen(UDF_ID_SPARING))) {
    1306                                                 brelse(bh2);
    1307                                                 map->s_type_specific.s_sparing.
    1308                                                         s_spar_map[j] = NULL;
    1309                                         }
    1310                                 }
    1311                                 map->s_partition_func = udf_get_pblock_spar15;
     1335                                if (udf_load_sparable_map(sb, map,
     1336                                    (struct sparablePartitionMap *)gpm) < 0)
     1337                                        goto out_bh;
    13121338                        } else if (!strncmp(upm2->partIdent.ident,
    13131339                                                UDF_ID_METADATA,
  • src/linux/universal/linux-3.2/include/linux/aio.h

    r18171 r19484  
    141141                (x)->ki_obj.tsk = tsk;                  \
    142142                (x)->ki_user_data = 0;                  \
     143                (x)->private = NULL;                    \
    143144        } while (0)
    144145
  • src/linux/universal/linux-3.2/include/linux/splice.h

    r18171 r19484  
    5252        struct page **pages;            /* page map */
    5353        struct partial_page *partial;   /* pages[] may not be contig */
    54         int nr_pages;                   /* number of pages in map */
     54        int nr_pages;                   /* number of populated pages in map */
     55        unsigned int nr_pages_max;      /* pages[] & partial[] arrays size */
    5556        unsigned int flags;             /* splice flags */
    5657        const struct pipe_buf_operations *ops;/* ops associated with output pipe */
     
    8687 * for dynamic pipe sizing
    8788 */
    88 extern int splice_grow_spd(struct pipe_inode_info *, struct splice_pipe_desc *);
    89 extern void splice_shrink_spd(struct pipe_inode_info *,
    90                                 struct splice_pipe_desc *);
     89extern int splice_grow_spd(const struct pipe_inode_info *, struct splice_pipe_desc *);
     90extern void splice_shrink_spd(struct splice_pipe_desc *);
    9191extern void spd_release_page(struct splice_pipe_desc *, unsigned int);
    9292
  • src/linux/universal/linux-3.2/include/net/cipso_ipv4.h

    r18171 r19484  
    4343#include <net/request_sock.h>
    4444#include <linux/atomic.h>
     45#include <asm/unaligned.h>
    4546
    4647/* known doi values */
     
    286287                                    unsigned char **option)
    287288{
    288         return -ENOSYS;
     289        unsigned char *opt = *option;
     290        unsigned char err_offset = 0;
     291        u8 opt_len = opt[1];
     292        u8 opt_iter;
     293
     294        if (opt_len < 8) {
     295                err_offset = 1;
     296                goto out;
     297        }
     298
     299        if (get_unaligned_be32(&opt[2]) == 0) {
     300                err_offset = 2;
     301                goto out;
     302        }
     303
     304        for (opt_iter = 6; opt_iter < opt_len;) {
     305                if (opt[opt_iter + 1] > (opt_len - opt_iter)) {
     306                        err_offset = opt_iter + 1;
     307                        goto out;
     308                }
     309                opt_iter += opt[opt_iter + 1];
     310        }
     311
     312out:
     313        *option = opt + err_offset;
     314        return err_offset;
     315
    289316}
    290317#endif /* CONFIG_NETLABEL */
  • src/linux/universal/linux-3.2/include/net/sch_generic.h

    r18597 r19484  
    221221struct qdisc_skb_cb {
    222222        unsigned int            pkt_len;
    223         unsigned char           data[24];
     223        u16                     bond_queue_mapping;
     224        u16                     _pad;
     225        unsigned char           data[20];
    224226};
    225227
     
    227229{
    228230        struct qdisc_skb_cb *qcb;
    229         BUILD_BUG_ON(sizeof(skb->cb) < sizeof(unsigned int) + sz);
     231
     232        BUILD_BUG_ON(sizeof(skb->cb) < offsetof(struct qdisc_skb_cb, data) + sz);
    230233        BUILD_BUG_ON(sizeof(qcb->data) < sz);
    231234}
  • src/linux/universal/linux-3.2/kernel/relay.c

    r18520 r19484  
    12361236                .pages = pages,
    12371237                .nr_pages = 0,
     1238                .nr_pages_max = PIPE_DEF_BUFFERS,
    12381239                .partial = partial,
    12391240                .flags = flags,
     
    13031304
    13041305out:
    1305         splice_shrink_spd(pipe, &spd);
    1306         return ret;
     1306        splice_shrink_spd(&spd);
     1307        return ret;
    13071308}
    13081309
  • src/linux/universal/linux-3.2/kernel/trace/trace.c

    r19018 r19484  
    25422542                                !cpumask_test_cpu(cpu, tracing_cpumask_new)) {
    25432543                        atomic_inc(&global_trace.data[cpu]->disabled);
     2544                        ring_buffer_record_disable_cpu(global_trace.buffer, cpu);
    25442545                }
    25452546                if (!cpumask_test_cpu(cpu, tracing_cpumask) &&
    25462547                                cpumask_test_cpu(cpu, tracing_cpumask_new)) {
    25472548                        atomic_dec(&global_trace.data[cpu]->disabled);
     2549                        ring_buffer_record_enable_cpu(global_trace.buffer, cpu);
    25482550                }
    25492551        }
     
    34573459                .partial        = partial_def,
    34583460                .nr_pages       = 0, /* This gets updated below. */
     3461                .nr_pages_max   = PIPE_DEF_BUFFERS,
    34593462                .flags          = flags,
    34603463                .ops            = &tracing_pipe_buf_ops,
     
    35283531        ret = splice_to_pipe(pipe, &spd);
    35293532out:
    3530         splice_shrink_spd(pipe, &spd);
     3533        splice_shrink_spd(&spd);
    35313534        return ret;
    35323535
     
    40184021                .pages          = pages_def,
    40194022                .partial        = partial_def,
     4023                .nr_pages_max   = PIPE_DEF_BUFFERS,
    40204024                .flags          = flags,
    40214025                .ops            = &buffer_pipe_buf_ops,
     
    41054109
    41064110        ret = splice_to_pipe(pipe, &spd);
    4107         splice_shrink_spd(pipe, &spd);
     4111        splice_shrink_spd(&spd);
    41084112out:
    41094113        return ret;
  • src/linux/universal/linux-3.2/mm/madvise.c

    r18171 r19484  
    1414#include <linux/sched.h>
    1515#include <linux/ksm.h>
     16#include <linux/file.h>
    1617
    1718/*
     
    198199        loff_t offset, endoff;
    199200        int error;
     201        struct file *f;
    200202
    201203        *prev = NULL;   /* tell sys_madvise we drop mmap_sem */
     
    204206                return -EINVAL;
    205207
    206         if (!vma->vm_file || !vma->vm_file->f_mapping
    207                 || !vma->vm_file->f_mapping->host) {
     208        f = vma->vm_file;
     209
     210        if (!f || !f->f_mapping || !f->f_mapping->host) {
    208211                        return -EINVAL;
    209212        }
     
    219222                        + ((loff_t)vma->vm_pgoff << PAGE_SHIFT);
    220223
    221         /* vmtruncate_range needs to take i_mutex */
     224        /*
     225         * vmtruncate_range may need to take i_mutex.  We need to
     226         * explicitly grab a reference because the vma (and hence the
     227         * vma's reference to the file) can go away as soon as we drop
     228         * mmap_sem.
     229         */
     230        get_file(f);
    222231        up_read(&current->mm->mmap_sem);
    223232        error = vmtruncate_range(mapping->host, offset, endoff);
     233        fput(f);
    224234        down_read(&current->mm->mmap_sem);
    225235        return error;
  • src/linux/universal/linux-3.2/mm/shmem.c

    r18324 r19484  
    13601360                .pages = pages,
    13611361                .partial = partial,
     1362                .nr_pages_max = PIPE_DEF_BUFFERS,
    13621363                .flags = flags,
    13631364                .ops = &page_cache_pipe_buf_ops,
     
    14481449                error = splice_to_pipe(pipe, &spd);
    14491450
    1450         splice_shrink_spd(pipe, &spd);
     1451        splice_shrink_spd(&spd);
    14511452
    14521453        if (error > 0) {
  • src/linux/universal/linux-3.2/net/bridge/br_if.c

    r18171 r19484  
    243243
    244244        dev_net_set(dev, net);
     245        dev->rtnl_link_ops = &br_link_ops;
    245246
    246247        res = register_netdev(dev);
  • src/linux/universal/linux-3.2/net/bridge/br_netlink.c

    r18171 r19484  
    212212}
    213213
    214 static struct rtnl_link_ops br_link_ops __read_mostly = {
     214struct rtnl_link_ops br_link_ops __read_mostly = {
    215215        .kind           = "bridge",
    216216        .priv_size      = sizeof(struct net_bridge),
  • src/linux/universal/linux-3.2/net/bridge/br_private.h

    r19243 r19484  
    552552
    553553/* br_netlink.c */
     554extern struct rtnl_link_ops br_link_ops;
    554555extern int br_netlink_init(void);
    555556extern void br_netlink_fini(void);
  • src/linux/universal/linux-3.2/net/core/ethtool.c

    r19325 r19484  
    16731673        case ETHTOOL_GTXCSUM:
    16741674        case ETHTOOL_GSG:
     1675        case ETHTOOL_GSSET_INFO:
    16751676        case ETHTOOL_GSTRINGS:
    16761677        case ETHTOOL_GTSO:
  • src/linux/universal/linux-3.2/net/core/netpoll.c

    r18597 r19484  
    352352void netpoll_send_udp(struct netpoll *np, const char *msg, int len)
    353353{
    354         int total_len, eth_len, ip_len, udp_len;
     354        int total_len, ip_len, udp_len;
    355355        struct sk_buff *skb;
    356356        struct udphdr *udph;
     
    359359
    360360        udp_len = len + sizeof(*udph);
    361         ip_len = eth_len = udp_len + sizeof(*iph);
    362         total_len = eth_len + ETH_HLEN + NET_IP_ALIGN;
    363 
    364         skb = find_skb(np, total_len, total_len - len);
     361        ip_len = udp_len + sizeof(*iph);
     362        total_len = ip_len + LL_RESERVED_SPACE(np->dev);
     363
     364        skb = find_skb(np, total_len + np->dev->needed_tailroom,
     365                       total_len - len);
    365366        if (!skb)
    366367                return;
    367368
    368369        skb_copy_to_linear_data(skb, msg, len);
    369         skb->len += len;
     370        skb_put(skb, len);
    370371
    371372        skb_push(skb, sizeof(*udph));
  • src/linux/universal/linux-3.2/net/core/skbuff.c

    r19243 r19484  
    17741774                .pages = pages,
    17751775                .partial = partial,
     1776                .nr_pages_max = MAX_SKB_FRAGS,
    17761777                .flags = flags,
    17771778                .ops = &sock_pipe_buf_ops,
     
    18201821        }
    18211822
    1822         splice_shrink_spd(pipe, &spd);
     1823        splice_shrink_spd(&spd);
    18231824        return ret;
    18241825}
  • src/linux/universal/linux-3.2/net/core/sock.c

    r18171 r19484  
    14981498        long timeo;
    14991499        int err;
     1500        int npages = (data_len + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
     1501
     1502        err = -EMSGSIZE;
     1503        if (npages > MAX_SKB_FRAGS)
     1504                goto failure;
    15001505
    15011506        gfp_mask = sk->sk_allocation;
     
    15161521                        skb = alloc_skb(header_len, gfp_mask);
    15171522                        if (skb) {
    1518                                 int npages;
    15191523                                int i;
    15201524
     
    15231527                                        break;
    15241528
    1525                                 npages = (data_len + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
    15261529                                skb->truesize += data_len;
    15271530                                skb_shinfo(skb)->nr_frags = npages;
  • src/linux/universal/linux-3.2/net/ipv6/route.c

    r18879 r19484  
    28822882        net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
    28832883
    2884 #ifdef CONFIG_PROC_FS
    2885         proc_net_fops_create(net, "ipv6_route", 0, &ipv6_route_proc_fops);
    2886         proc_net_fops_create(net, "rt6_stats", S_IRUGO, &rt6_stats_seq_fops);
    2887 #endif
    28882884        net->ipv6.ip6_rt_gc_expire = 30*HZ;
    28892885
     
    29062902static void __net_exit ip6_route_net_exit(struct net *net)
    29072903{
    2908 #ifdef CONFIG_PROC_FS
    2909         proc_net_remove(net, "ipv6_route");
    2910         proc_net_remove(net, "rt6_stats");
    2911 #endif
    29122904        kfree(net->ipv6.ip6_null_entry);
    29132905#ifdef CONFIG_IPV6_MULTIPLE_TABLES
     
    29182910}
    29192911
     2912static int __net_init ip6_route_net_init_late(struct net *net)
     2913{
     2914#ifdef CONFIG_PROC_FS
     2915        proc_net_fops_create(net, "ipv6_route", 0, &ipv6_route_proc_fops);
     2916        proc_net_fops_create(net, "rt6_stats", S_IRUGO, &rt6_stats_seq_fops);
     2917#endif
     2918        return 0;
     2919}
     2920
     2921static void __net_exit ip6_route_net_exit_late(struct net *net)
     2922{
     2923#ifdef CONFIG_PROC_FS
     2924        proc_net_remove(net, "ipv6_route");
     2925        proc_net_remove(net, "rt6_stats");
     2926#endif
     2927}
     2928
    29202929static struct pernet_operations ip6_route_net_ops = {
    29212930        .init = ip6_route_net_init,
    29222931        .exit = ip6_route_net_exit,
     2932};
     2933
     2934static struct pernet_operations ip6_route_net_late_ops = {
     2935        .init = ip6_route_net_init_late,
     2936        .exit = ip6_route_net_exit_late,
    29232937};
    29242938
     
    29722986                goto xfrm6_init;
    29732987
     2988        ret = register_pernet_subsys(&ip6_route_net_late_ops);
     2989        if (ret)
     2990                goto fib6_rules_init;
     2991
    29742992        ret = -ENOBUFS;
    29752993        if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL, NULL) ||
    29762994            __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL, NULL) ||
    29772995            __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL, NULL))
    2978                 goto fib6_rules_init;
     2996                goto out_register_late_subsys;
    29792997
    29802998        ret = register_netdevice_notifier(&ip6_route_dev_notifier);
    29812999        if (ret)
    2982                 goto fib6_rules_init;
     3000                goto out_register_late_subsys;
    29833001
    29843002out:
    29853003        return ret;
    29863004
     3005out_register_late_subsys:
     3006        unregister_pernet_subsys(&ip6_route_net_late_ops);
    29873007fib6_rules_init:
    29883008        fib6_rules_cleanup();
     
    30033023{
    30043024        unregister_netdevice_notifier(&ip6_route_dev_notifier);
     3025        unregister_pernet_subsys(&ip6_route_net_late_ops);
    30053026        fib6_rules_cleanup();
    30063027        xfrm6_fini();
  • src/linux/universal/linux-3.2/net/l2tp/l2tp_eth.c

    r18171 r19484  
    168168                        unregister_netdev(dev);
    169169                        spriv->dev = NULL;
     170                        module_put(THIS_MODULE);
    170171                }
    171172        }
     
    255256                goto out_del_dev;
    256257
     258        __module_get(THIS_MODULE);
    257259        /* Must be done after register_netdev() */
    258260        strlcpy(session->ifname, dev->name, IFNAMSIZ);
  • src/linux/universal/linux-3.2/net/l2tp/l2tp_ip.c

    r19357 r19484  
    516516                if (IS_ERR(rt))
    517517                        goto no_route;
    518                 if (connected)
     518                if (connected) {
    519519                        sk_setup_caps(sk, &rt->dst);
    520                 else
    521                         dst_release(&rt->dst); /* safe since we hold rcu_read_lock */
     520                } else {
     521                        skb_dst_set(skb, &rt->dst);
     522                        goto xmit;
     523                }
    522524        }
    523525
     
    527529        skb_dst_set_noref(skb, &rt->dst);
    528530
     531xmit:
    529532        /* Queue the packet to IP for output */
    530533        rc = ip_queue_xmit(skb, &inet->cork.fl);
  • src/linux/universal/linux-3.2/net/mac80211/rx.c

    r18520 r19484  
    23902390         * ones. For all other modes we will return them to the sender,
    23912391         * setting the 0x80 bit in the action category, as required by
    2392          * 802.11-2007 7.3.1.11.
     2392         * 802.11-2012 9.24.4.
    23932393         * Newer versions of hostapd shall also use the management frame
    23942394         * registration mechanisms, but older ones still use cooked
     
    23982398            (sdata->vif.type == NL80211_IFTYPE_AP ||
    23992399             sdata->vif.type == NL80211_IFTYPE_AP_VLAN))
     2400                return RX_DROP_MONITOR;
     2401
     2402        if (is_multicast_ether_addr(mgmt->da))
    24002403                return RX_DROP_MONITOR;
    24012404
  • src/linux/universal/linux-3.2/net/nfc/nci/ntf.c

    r18171 r19484  
    8787        data += 2;
    8888
    89         nfca_poll->nfcid1_len = *data++;
     89        nfca_poll->nfcid1_len = min_t(__u8, *data++, sizeof(nfca_poll->nfcid1));
    9090
    9191        nfc_dbg("sens_res 0x%x, nfcid1_len %d",
     
    112112        switch (ntf->rf_interface_type) {
    113113        case NCI_RF_INTERFACE_ISO_DEP:
    114                 nfca_poll_iso_dep->rats_res_len = *data++;
     114                nfca_poll_iso_dep->rats_res_len = min_t(__u8, *data++, 20);
    115115                if (nfca_poll_iso_dep->rats_res_len > 0) {
    116116                        memcpy(nfca_poll_iso_dep->rats_res,
  • src/linux/universal/linux-3.2/net/nfc/rawsock.c

    r18171 r19484  
    5353        struct sock *sk = sock->sk;
    5454
    55         nfc_dbg("sock=%p", sock);
     55        nfc_dbg("sock=%p sk=%p", sock, sk);
     56
     57        if (!sk)
     58                return 0;
    5659
    5760        sock_orphan(sk);
  • src/linux/universal/linux-3.2/sound/pci/hda/patch_sigmatel.c

    r19278 r19484  
    44584458        for (i = 0; i < spec->num_pwrs; i++)  {
    44594459                hda_nid_t nid = spec->pwr_nids[i];
    4460                 int pinctl, def_conf;
     4460                unsigned int pinctl, def_conf;
    44614461
    44624462                /* power on when no jack detection is available */
     
    44854485                /* skip any ports that don't have jacks since presence
    44864486                 * detection is useless */
    4487                 if (def_conf != AC_JACK_PORT_NONE &&
     4487                if (def_conf != AC_JACK_PORT_COMPLEX ||
    44884488                    !is_jack_detectable(codec, nid)) {
    44894489                        stac_toggle_power_map(codec, nid, 1);
  • src/linux/universal/linux-3.2/sound/soc/codecs/tlv320aic3x.c

    r18171 r19484  
    964964
    965965found:
    966         data = snd_soc_read(codec, AIC3X_PLL_PROGA_REG);
    967         snd_soc_write(codec, AIC3X_PLL_PROGA_REG,
    968                       data | (pll_p << PLLP_SHIFT));
     966        snd_soc_update_bits(codec, AIC3X_PLL_PROGA_REG, PLLP_MASK, pll_p);
    969967        snd_soc_write(codec, AIC3X_OVRF_STATUS_AND_PLLR_REG,
    970968                      pll_r << PLLR_SHIFT);
  • src/linux/universal/linux-3.2/sound/soc/codecs/tlv320aic3x.h

    r18171 r19484  
    167167/* PLL registers bitfields */
    168168#define PLLP_SHIFT              0
     169#define PLLP_MASK               7
    169170#define PLLQ_SHIFT              3
    170171#define PLLR_SHIFT              0
Note: See TracChangeset for help on using the changeset viewer.