Changeset 31923


Ignore:
Timestamp:
Apr 30, 2017, 6:34:02 PM (4 weeks ago)
Author:
brainslayer
Message:

kernel update

Location:
src/linux/universal
Files:
87 edited

Legend:

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

    r31890 r31923  
    11VERSION = 3
    22PATCHLEVEL = 18
    3 SUBLEVEL = 50
     3SUBLEVEL = 51
    44EXTRAVERSION =
    55NAME = Diseased Newt
  • src/linux/universal/linux-3.18/arch/arm/kernel/head-nommu.S

    r25370 r31923  
    7878        bl      __setup_mpu
    7979#endif
    80         ldr     r13, =__mmap_switched           @ address to jump to after
    81                                                 @ initialising sctlr
    8280        adr     lr, BSYM(1f)                    @ return (PIC) address
    8381 ARM(   add     pc, r10, #PROCINFO_INITFUNC     )
    8482 THUMB( add     r12, r10, #PROCINFO_INITFUNC    )
    8583 THUMB( ret     r12                             )
    86  1:     b       __after_proc_init
     841:      bl      __after_proc_init
     85        b       __mmap_switched
    8786ENDPROC(stext)
    8887
     
    107106        beq     __error_p                       @ yes, error 'p'
    108107
    109         adr     r4, __secondary_data
    110         ldmia   r4, {r7, r12}
     108        ldr     r7, __secondary_data
    111109
    112110#ifdef CONFIG_ARM_MPU
     
    116114#endif
    117115
    118         adr     lr, BSYM(__after_proc_init)     @ return address
    119         mov     r13, r12                        @ __secondary_switched address
     116        adr     lr, BSYM(1f)                    @ return (PIC) address
    120117 ARM(   add     pc, r10, #PROCINFO_INITFUNC     )
    121118 THUMB( add     r12, r10, #PROCINFO_INITFUNC    )
    122119 THUMB( ret     r12                             )
    123 ENDPROC(secondary_startup)
    124 
    125 ENTRY(__secondary_switched)
     1201:      bl      __after_proc_init
    126121        ldr     sp, [r7, #8]                    @ set up the stack pointer
    127122        mov     fp, #0
    128123        b       secondary_start_kernel
    129 ENDPROC(__secondary_switched)
     124ENDPROC(secondary_startup)
    130125
    131126        .type   __secondary_data, %object
    132127__secondary_data:
    133128        .long   secondary_data
    134         .long   __secondary_switched
    135129#endif /* CONFIG_SMP */
    136130
     
    165159        mcr     p15, 0, r0, c1, c0, 0           @ write control reg
    166160#endif /* CONFIG_CPU_CP15 */
    167         ret     r13
     161        ret     lr
    168162ENDPROC(__after_proc_init)
    169163        .ltorg
  • src/linux/universal/linux-3.18/arch/arm/kvm/mmu.c

    r31885 r31923  
    257257                if (!pgd_none(*pgd))
    258258                        unmap_puds(kvm, pgd, addr, next);
     259                /*
     260                 * If we are dealing with a large range in
     261                 * stage2 table, release the kvm->mmu_lock
     262                 * to prevent starvation and lockup detector
     263                 * warnings.
     264                 */
     265                if (kvm && (next != end))
     266                        cond_resched_lock(&kvm->mmu_lock);
    259267        } while (pgd++, addr = next, addr != end);
    260268}
     
    694702static void unmap_stage2_range(struct kvm *kvm, phys_addr_t start, u64 size)
    695703{
     704        assert_spin_locked(&kvm->mmu_lock);
    696705        unmap_range(kvm, kvm->arch.pgd, start, size);
    697706}
     
    778787                return;
    779788
     789        spin_lock(&kvm->mmu_lock);
    780790        unmap_stage2_range(kvm, 0, KVM_PHYS_SIZE);
     791        spin_unlock(&kvm->mmu_lock);
     792
    781793        kvm_free_hwpgd(kvm_get_hwpgd(kvm));
    782794        if (KVM_PREALLOC_LEVEL > 0)
  • src/linux/universal/linux-3.18/arch/arm/mm/cache-l2x0.c

    r25500 r31923  
    135135        l2c_write_sec(0, base, L2X0_CTRL);
    136136        dsb(st);
    137 }
    138 
    139 #ifdef CONFIG_CACHE_PL310
    140 static inline void cache_wait(void __iomem *reg, unsigned long mask)
    141 {
    142         /* cache operations by line are atomic on PL310 */
    143 }
    144 #else
    145 #define cache_wait      l2c_wait_mask
    146 #endif
    147 
    148 static inline void cache_sync(void)
    149 {
    150         void __iomem *base = l2x0_base;
    151 
    152         writel_relaxed(0, base + sync_reg_offset);
    153         cache_wait(base + L2X0_CACHE_SYNC, 1);
    154 }
    155 
    156 #if defined(CONFIG_PL310_ERRATA_588369) || defined(CONFIG_PL310_ERRATA_727915)
    157 static inline void debug_writel(unsigned long val)
    158 {
    159         l2c_set_debug(l2x0_base, val);
    160 }
    161 #else
    162 /* Optimised out for non-errata case */
    163 static inline void debug_writel(unsigned long val)
    164 {
    165 }
    166 #endif
    167 
    168 static void l2x0_cache_sync(void)
    169 {
    170         unsigned long flags;
    171 
    172         raw_spin_lock_irqsave(&l2x0_lock, flags);
    173         cache_sync();
    174         raw_spin_unlock_irqrestore(&l2x0_lock, flags);
    175 }
    176 
    177 static void __l2x0_flush_all(void)
    178 {
    179         debug_writel(0x03);
    180         __l2c_op_way(l2x0_base + L2X0_CLEAN_INV_WAY);
    181         cache_sync();
    182         debug_writel(0x00);
    183 }
    184 
    185 static void l2x0_flush_all(void)
    186 {
    187         unsigned long flags;
    188 
    189         /* clean all ways */
    190         raw_spin_lock_irqsave(&l2x0_lock, flags);
    191         __l2x0_flush_all();
    192         raw_spin_unlock_irqrestore(&l2x0_lock, flags);
    193 }
    194 
    195 static void l2x0_disable(void)
    196 {
    197         unsigned long flags;
    198 
    199         raw_spin_lock_irqsave(&l2x0_lock, flags);
    200         __l2x0_flush_all();
    201         l2c_write_sec(0, l2x0_base, L2X0_CTRL);
    202         dsb(st);
    203         raw_spin_unlock_irqrestore(&l2x0_lock, flags);
    204137}
    205138
     
    12581191                        unsigned long offset)
    12591192{
     1193        void __iomem *base = l2x0_base;
    12601194        unsigned long flags;
    12611195
    12621196        raw_spin_lock_irqsave(&l2x0_lock, flags);
    1263         writel_relaxed(start, l2x0_base + AURORA_RANGE_BASE_ADDR_REG);
    1264         writel_relaxed(end, l2x0_base + offset);
     1197        writel_relaxed(start, base + AURORA_RANGE_BASE_ADDR_REG);
     1198        writel_relaxed(end, base + offset);
    12651199        raw_spin_unlock_irqrestore(&l2x0_lock, flags);
    12661200
    1267         cache_sync();
     1201        writel_relaxed(0, base + AURORA_SYNC_REG);
    12681202}
    12691203
     
    13251259}
    13261260
     1261static void aurora_flush_all(void)
     1262{
     1263        void __iomem *base = l2x0_base;
     1264        unsigned long flags;
     1265
     1266        /* clean all ways */
     1267        raw_spin_lock_irqsave(&l2x0_lock, flags);
     1268        __l2c_op_way(base + L2X0_CLEAN_INV_WAY);
     1269        raw_spin_unlock_irqrestore(&l2x0_lock, flags);
     1270
     1271        writel_relaxed(0, base + AURORA_SYNC_REG);
     1272}
     1273
     1274static void aurora_cache_sync(void)
     1275{
     1276        writel_relaxed(0, l2x0_base + AURORA_SYNC_REG);
     1277}
     1278
     1279static void aurora_disable(void)
     1280{
     1281        void __iomem *base = l2x0_base;
     1282        unsigned long flags;
     1283
     1284        raw_spin_lock_irqsave(&l2x0_lock, flags);
     1285        __l2c_op_way(base + L2X0_CLEAN_INV_WAY);
     1286        writel_relaxed(0, base + AURORA_SYNC_REG);
     1287        l2c_write_sec(0, base, L2X0_CTRL);
     1288        dsb(st);
     1289        raw_spin_unlock_irqrestore(&l2x0_lock, flags);
     1290}
     1291
    13271292static void aurora_save(void __iomem *base)
    13281293{
     
    13991364                .clean_range = aurora_clean_range,
    14001365                .flush_range = aurora_flush_range,
    1401                 .flush_all   = l2x0_flush_all,
    1402                 .disable     = l2x0_disable,
    1403                 .sync        = l2x0_cache_sync,
     1366                .flush_all   = aurora_flush_all,
     1367                .disable     = aurora_disable,
     1368                .sync        = aurora_cache_sync,
    14041369                .resume      = aurora_resume,
    14051370        },
  • src/linux/universal/linux-3.18/arch/arm64/kernel/entry.S

    r27511 r31923  
    552552        mov     x1, #BAD_SYNC
    553553        mrs     x2, esr_el1
    554         adr     lr, ret_to_user
    555         b       bad_mode
     554        bl      bad_el0_sync
     555        b       ret_to_user
    556556ENDPROC(el0_sync)
    557557
  • src/linux/universal/linux-3.18/arch/arm64/kernel/traps.c

    r25370 r31923  
    309309
    310310/*
    311  * bad_mode handles the impossible case in the exception vector.
     311 * bad_mode handles the impossible case in the exception vector. This is always
     312 * fatal.
    312313 */
    313314asmlinkage void bad_mode(struct pt_regs *regs, int reason, unsigned int esr)
     315{
     316        console_verbose();
     317
     318        pr_crit("Bad mode in %s handler detected, code 0x%08x\n",
     319                handler[reason], esr);
     320
     321        die("Oops - bad mode", regs, 0);
     322        local_irq_disable();
     323        panic("bad mode");
     324}
     325
     326/*
     327 * bad_el0_sync handles unexpected, but potentially recoverable synchronous
     328 * exceptions taken from EL0. Unlike bad_mode, this returns.
     329 */
     330asmlinkage void bad_el0_sync(struct pt_regs *regs, int reason, unsigned int esr)
    314331{
    315332        siginfo_t info;
     
    317334        console_verbose();
    318335
    319         pr_crit("Bad mode in %s handler detected, code 0x%08x\n",
    320                 handler[reason], esr);
     336        pr_crit("Bad EL0 synchronous exception detected on CPU%d, code 0x%08x\n",
     337                smp_processor_id(), esr);
    321338        __show_regs(regs);
    322339
     
    326343        info.si_addr  = pc;
    327344
    328         arm64_notify_die("Oops - bad mode", regs, &info, 0);
     345        current->thread.fault_address = 0;
     346        current->thread.fault_code = 0;
     347
     348        force_sig_info(info.si_signo, &info, current);
    329349}
    330350
  • src/linux/universal/linux-3.18/arch/mips/include/asm/compiler.h

    r30422 r31923  
    1616#define GCC_REG_ACCUM "accum"
    1717#endif
     18
     19#ifdef CONFIG_CPU_MIPSR6
     20#define MIPS_ISA_LEVEL "mips64r6"
     21#define MIPS_ISA_ARCH_LEVEL MIPS_ISA_LEVEL
     22#define MIPS_ISA_LEVEL_RAW mips64r6
     23#define MIPS_ISA_ARCH_LEVEL_RAW MIPS_ISA_LEVEL_RAW
     24#else
     25
     26/* MIPS64 is a superset of MIPS32 */
     27#define MIPS_ISA_LEVEL "mips64r2"
     28#define MIPS_ISA_ARCH_LEVEL "arch=r4000"
     29#define MIPS_ISA_LEVEL_RAW mips64r2
     30#define MIPS_ISA_ARCH_LEVEL_RAW MIPS_ISA_LEVEL_RAW
     31#endif /* CONFIG_CPU_MIPSR6 */
     32
    1833#endif /* _ASM_COMPILER_H */
    1934
  • src/linux/universal/linux-3.18/arch/mips/jz4740/board-qi_lb60.c

    r25370 r31923  
    2727#include <linux/power/gpio-charger.h>
    2828
     29#include <asm/mach-jz4740/gpio.h>
    2930#include <asm/mach-jz4740/jz4740_fb.h>
    3031#include <asm/mach-jz4740/jz4740_mmc.h>
  • src/linux/universal/linux-3.18/arch/mips/jz4740/gpio.c

    r25370 r31923  
    2828
    2929#include <asm/mach-jz4740/base.h>
     30#include <asm/mach-jz4740/gpio.h>
    3031
    3132#include "irq.h"
  • src/linux/universal/linux-3.18/arch/mips/pci/ops-pmcmsp.c

    r25370 r31923  
    193193}
    194194#endif /* CONFIG_PROC_FS && PCI_COUNTERS */
    195 
    196 static DEFINE_SPINLOCK(bpci_lock);
    197195
    198196/*****************************************************************************
     
    369367        unsigned char bus_num = bus->number;
    370368        unsigned char dev_fn = (unsigned char)devfn;
    371         unsigned long flags;
    372369        unsigned long intr;
    373370        unsigned long value;
     
    402399
    403400#if defined(CONFIG_PMC_MSP7120_GW) || defined(CONFIG_PMC_MSP7120_EVAL)
    404         local_irq_save(flags);
    405401        vpe_status = dvpe();
    406 #else
    407         spin_lock_irqsave(&bpci_lock, flags);
    408402#endif
    409403
     
    458452#if defined(CONFIG_PMC_MSP7120_GW) || defined(CONFIG_PMC_MSP7120_EVAL)
    459453                evpe(vpe_status);
    460                 local_irq_restore(flags);
    461 #else
    462                 spin_unlock_irqrestore(&bpci_lock, flags);
    463454#endif
    464455
     
    468459#if defined(CONFIG_PMC_MSP7120_GW) || defined(CONFIG_PMC_MSP7120_EVAL)
    469460        evpe(vpe_status);
    470         local_irq_restore(flags);
    471 #else
    472         spin_unlock_irqrestore(&bpci_lock, flags);
    473461#endif
    474462
  • src/linux/universal/linux-3.18/arch/powerpc/kernel/entry_64.S

    r25370 r31923  
    678678        addi    r8,r1,INT_FRAME_SIZE    /* Get the kprobed function entry */
    679679
    680         lwz     r3,GPR1(r1)
     680        ld      r3,GPR1(r1)
    681681        subi    r3,r3,INT_FRAME_SIZE    /* dst: Allocate a trampoline exception frame */
    682682        mr      r4,r1                   /* src:  current exception frame */
     
    692692        bdnz    2b
    693693
    694         /* Do real store operation to complete stwu */
    695         lwz     r5,GPR1(r1)
     694        /* Do real store operation to complete stdu */
     695        ld      r5,GPR1(r1)
    696696        std     r8,0(r5)
    697697
  • src/linux/universal/linux-3.18/arch/s390/include/asm/pgtable.h

    r27334 r31923  
    864864        pgste_t pgste;
    865865
     866        if (pte_present(entry))
     867                pte_val(entry) &= ~_PAGE_UNUSED;
    866868        if (mm_has_pgste(mm)) {
    867869                pgste = pgste_get_lock(ptep);
  • src/linux/universal/linux-3.18/arch/x86/configs/tiny.config

    r25370 r31923  
    11CONFIG_NOHIGHMEM=y
     2# CONFIG_HIGHMEM4G is not set
     3# CONFIG_HIGHMEM64G is not set
  • src/linux/universal/linux-3.18/arch/x86/kernel/cpu/mcheck/mce_amd.c

    r25370 r31923  
    5252        "insn_fetch",
    5353        "combined_unit",
    54         "",
     54        "decode_unit",
    5555        "northbridge",
    5656        "execution_unit",
  • src/linux/universal/linux-3.18/drivers/acpi/power.c

    r25370 r31923  
    202202
    203203        /* The state of the list is 'on' IFF all resources are 'on'. */
     204        cur_state = 0;
    204205        list_for_each_entry(entry, list, node) {
    205206                struct acpi_power_resource *resource = entry->resource;
  • src/linux/universal/linux-3.18/drivers/clk/at91/clk-usb.c

    r26966 r31923  
    6060                                              unsigned long rate,
    6161                                              unsigned long *best_parent_rate,
    62                                               struct clk_hw **best_parent_hw)
     62                                              struct clk **best_parent_hw)
    6363{
    6464        struct clk *parent = NULL;
     
    9292                                best_diff = tmp_diff;
    9393                                *best_parent_rate = tmp_parent_rate;
    94                                 *best_parent_hw = __clk_get_hw(parent);
     94                                *best_parent_hw = parent;
    9595                        }
    9696
  • src/linux/universal/linux-3.18/drivers/input/mouse/elantech.c

    r30256 r31923  
    11161116 * Avatar AVIU-145A2       0x361f00        ?               clickpad
    11171117 * Fujitsu LIFEBOOK E544   0x470f00        d0, 12, 09      2 hw buttons
     1118 * Fujitsu LIFEBOOK E547   0x470f00        50, 12, 09      2 hw buttons
    11181119 * Fujitsu LIFEBOOK E554   0x570f01        40, 14, 0c      2 hw buttons
    11191120 * Fujitsu H730            0x570f00        c0, 14, 0c      3 hw buttons (**)
     
    14971498        },
    14981499        {
     1500                /* Fujitsu LIFEBOOK E547 does not work with crc_enabled == 0 */
     1501                .matches = {
     1502                        DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
     1503                        DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E547"),
     1504                },
     1505        },
     1506        {
    14991507                /* Fujitsu LIFEBOOK E554  does not work with crc_enabled == 0 */
    15001508                .matches = {
  • src/linux/universal/linux-3.18/drivers/iommu/intel-iommu.c

    r31885 r31923  
    17601760static void domain_exit(struct dmar_domain *domain)
    17611761{
    1762         struct dmar_drhd_unit *drhd;
    17631762        struct page *freelist = NULL;
    17641763        int i;
  • src/linux/universal/linux-3.18/drivers/md/dm-bufio.c

    r25773 r31923  
    350350         */
    351351
     352        noio_flag = 0;
    352353        if (gfp_mask & __GFP_NORETRY)
    353354                noio_flag = memalloc_noio_save();
  • src/linux/universal/linux-3.18/drivers/media/tuners/tuner-xc2028.c

    r25370 r31923  
    14041404         */
    14051405        kfree(priv->ctrl.fname);
     1406        priv->ctrl.fname = NULL;
    14061407        memcpy(&priv->ctrl, p, sizeof(priv->ctrl));
    14071408        if (p->fname) {
    14081409                priv->ctrl.fname = kstrdup(p->fname, GFP_KERNEL);
    14091410                if (priv->ctrl.fname == NULL)
    1410                         rc = -ENOMEM;
     1411                        return -ENOMEM;
    14111412        }
    14121413
  • src/linux/universal/linux-3.18/drivers/misc/ioc4.c

    r25370 r31923  
    145145        union ioc4_int_out int_out;
    146146        union ioc4_gpcr gpcr;
    147         unsigned int state, last_state = 1;
     147        unsigned int state, last_state;
    148148        uint64_t start, end, period;
    149         unsigned int count = 0;
     149        unsigned int count;
    150150
    151151        /* Enable output */
     
    168168
    169169        /* Check square wave period averaged over some number of cycles */
    170         do {
    171                 int_out.raw = readl(&idd->idd_misc_regs->int_out.raw);
    172                 state = int_out.fields.int_out;
    173                 if (!last_state && state) {
    174                         count++;
    175                         if (count == IOC4_CALIBRATE_END) {
    176                                 end = ktime_get_ns();
    177                                 break;
    178                         } else if (count == IOC4_CALIBRATE_DISCARD)
    179                                 start = ktime_get_ns();
    180                 }
    181                 last_state = state;
    182         } while (1);
     170        start = ktime_get_ns();
     171        state = 1; /* make sure the first read isn't a rising edge */
     172        for (count = 0; count <= IOC4_CALIBRATE_END; count++) {
     173                do { /* wait for a rising edge */
     174                        last_state = state;
     175                        int_out.raw = readl(&idd->idd_misc_regs->int_out.raw);
     176                        state = int_out.fields.int_out;
     177                } while (last_state || !state);
     178
     179                /* discard the first few cycles */
     180                if (count == IOC4_CALIBRATE_DISCARD)
     181                        start = ktime_get_ns();
     182        }
     183        end = ktime_get_ns();
    183184
    184185        /* Calculation rearranged to preserve intermediate precision.
  • src/linux/universal/linux-3.18/drivers/mmc/host/sdhci-esdhc-imx.c

    r25370 r31923  
    825825        switch (uhs) {
    826826        case MMC_TIMING_UHS_SDR50:
     827        case MMC_TIMING_UHS_DDR50:
    827828                pinctrl = imx_data->pins_100mhz;
    828829                break;
  • src/linux/universal/linux-3.18/drivers/mmc/host/sunxi-mmc.c

    r26966 r31923  
    295295{
    296296        struct sunxi_idma_des *pdes = (struct sunxi_idma_des *)host->sg_cpu;
    297         struct sunxi_idma_des *pdes_pa = (struct sunxi_idma_des *)host->sg_dma;
     297        dma_addr_t next_desc = host->sg_dma;
    298298        int i, max_len = (1 << host->idma_des_size_bits);
    299299
     
    307307                        pdes[i].buf_size = data->sg[i].length;
    308308
     309                next_desc += sizeof(struct sunxi_idma_des);
    309310                pdes[i].buf_addr_ptr1 = sg_dma_address(&data->sg[i]);
    310                 pdes[i].buf_addr_ptr2 = (u32)&pdes_pa[i + 1];
     311                pdes[i].buf_addr_ptr2 = (u32)next_desc;
    311312        }
    312313
  • src/linux/universal/linux-3.18/drivers/mtd/ubi/upd.c

    r29271 r31923  
    149149        }
    150150
     151        err = ubi_wl_flush(ubi, UBI_ALL, UBI_ALL);
     152        if (err)
     153                return err;
     154
    151155        if (bytes == 0) {
    152                 err = ubi_wl_flush(ubi, UBI_ALL, UBI_ALL);
    153                 if (err)
    154                         return err;
    155 
    156156                err = clear_update_marker(ubi, vol, 0);
    157157                if (err)
  • src/linux/universal/linux-3.18/drivers/net/ethernet/dec/tulip/tulip_core.c

    r25370 r31923  
    9999static int csr0 = 0x00200000 | 0x4000;
    100100#else
    101 #warning Processor architecture undefined!
    102 static int csr0 = 0x00A00000 | 0x4800;
     101static int csr0;
    103102#endif
    104103
     
    19831982#endif
    19841983
     1984        if (!csr0) {
     1985                pr_warn("tulip: unknown CPU architecture, using default csr0\n");
     1986                /* default to 8 longword cache line alignment */
     1987                csr0 = 0x00A00000 | 0x4800;
     1988        }
     1989
    19851990        /* copy module parms into globals */
    19861991        tulip_rx_copybreak = rx_copybreak;
  • src/linux/universal/linux-3.18/drivers/net/ethernet/dec/tulip/winbond-840.c

    r25370 r31923  
    908908        i |= 0x4800;
    909909#else
    910 #warning Processor architecture undefined
     910        dev_warn(&dev->dev, "unknown CPU architecture, using default csr0 setting\n");
    911911        i |= 0x4800;
    912912#endif
  • src/linux/universal/linux-3.18/drivers/net/ethernet/neterion/vxge/vxge-main.c

    r25370 r31923  
    22242224}
    22252225
    2226 #ifdef CONFIG_PCI_MSI
    2227 
    22282226static irqreturn_t vxge_tx_msix_handle(int irq, void *dev_id)
    22292227{
     
    24432441                pci_disable_msix(vdev->pdev);
    24442442}
    2445 #endif
    24462443
    24472444static void vxge_rem_isr(struct vxgedev *vdev)
    24482445{
    2449 #ifdef CONFIG_PCI_MSI
    2450         if (vdev->config.intr_type == MSI_X) {
     2446        if (IS_ENABLED(CONFIG_PCI_MSI) &&
     2447            vdev->config.intr_type == MSI_X) {
    24512448                vxge_rem_msix_isr(vdev);
    2452         } else
    2453 #endif
    2454         if (vdev->config.intr_type == INTA) {
     2449        } else if (vdev->config.intr_type == INTA) {
    24552450                        synchronize_irq(vdev->pdev->irq);
    24562451                        free_irq(vdev->pdev->irq, vdev);
     
    24612456{
    24622457        int ret = 0;
    2463 #ifdef CONFIG_PCI_MSI
    24642458        int vp_idx = 0, intr_idx = 0, intr_cnt = 0, msix_idx = 0, irq_req = 0;
    24652459        int pci_fun = PCI_FUNC(vdev->pdev->devfn);
    24662460
    2467         if (vdev->config.intr_type == MSI_X)
     2461        if (IS_ENABLED(CONFIG_PCI_MSI) && vdev->config.intr_type == MSI_X)
    24682462                ret = vxge_enable_msix(vdev);
    24692463
     
    24762470        }
    24772471
    2478         if (vdev->config.intr_type == MSI_X) {
     2472        if (IS_ENABLED(CONFIG_PCI_MSI) && vdev->config.intr_type == MSI_X) {
    24792473                for (intr_idx = 0;
    24802474                     intr_idx < (vdev->no_of_vpath *
     
    25772571                vdev->vxge_entries[intr_cnt].arg = &vdev->vpaths[0];
    25782572        }
     2573
    25792574INTA_MODE:
    2580 #endif
    2581 
    25822575        if (vdev->config.intr_type == INTA) {
    25832576                snprintf(vdev->desc[0], VXGE_INTR_STRLEN,
     
    38903883                max_mac_vpath = VXGE_MAX_MAC_ADDR_COUNT;
    38913884
    3892 #ifndef CONFIG_PCI_MSI
    3893         vxge_debug_init(VXGE_ERR,
    3894                 "%s: This Kernel does not support "
    3895                 "MSI-X. Defaulting to INTA", VXGE_DRIVER_NAME);
    3896         *intr_type = INTA;
    3897 #endif
     3885        if (!IS_ENABLED(CONFIG_PCI_MSI)) {
     3886                vxge_debug_init(VXGE_ERR,
     3887                        "%s: This Kernel does not support "
     3888                        "MSI-X. Defaulting to INTA", VXGE_DRIVER_NAME);
     3889                *intr_type = INTA;
     3890        }
    38983891
    38993892        /* Configure whether MSI-X or IRQL. */
  • src/linux/universal/linux-3.18/drivers/net/ethernet/ti/cpmac.c

    r31869 r31923  
    548548static int cpmac_start_xmit(struct sk_buff *skb, struct net_device *dev)
    549549{
    550         int queue, len;
     550        int queue;
     551        unsigned int len;
    551552        struct cpmac_desc *desc;
    552553        struct cpmac_priv *priv = netdev_priv(dev);
     
    558559                return NETDEV_TX_OK;
    559560
    560         len = max(skb->len, ETH_ZLEN);
     561        len = max_t(unsigned int, skb->len, ETH_ZLEN);
    561562        queue = skb_get_queue_mapping(skb);
    562563        netif_stop_subqueue(dev, queue);
  • src/linux/universal/linux-3.18/drivers/net/wireless/brcm80211/brcmfmac/fwsignal.c

    r25370 r31923  
    636636}
    637637
    638 static int brcmf_fws_hanger_poppkt(struct brcmf_fws_hanger *h,
     638static inline int brcmf_fws_hanger_poppkt(struct brcmf_fws_hanger *h,
    639639                                          u32 slot_id, struct sk_buff **pktout,
    640640                                          bool remove_item)
  • src/linux/universal/linux-3.18/drivers/net/wireless/hostap/hostap_hw.c

    r25370 r31923  
    837837
    838838        res = hfa384x_setup_bap(dev, BAP0, rid, 0);
    839         if (!res)
    840                 res = hfa384x_from_bap(dev, BAP0, &rec, sizeof(rec));
     839        if (res)
     840                goto unlock;
     841
     842        res = hfa384x_from_bap(dev, BAP0, &rec, sizeof(rec));
     843        if (res)
     844                goto unlock;
    841845
    842846        if (le16_to_cpu(rec.len) == 0) {
    843847                /* RID not available */
    844848                res = -ENODATA;
     849                goto unlock;
    845850        }
    846851
    847852        rlen = (le16_to_cpu(rec.len) - 1) * 2;
    848         if (!res && exact_len && rlen != len) {
     853        if (exact_len && rlen != len) {
    849854                printk(KERN_DEBUG "%s: hfa384x_get_rid - RID len mismatch: "
    850855                       "rid=0x%04x, len=%d (expected %d)\n",
     
    853858        }
    854859
    855         if (!res)
    856                 res = hfa384x_from_bap(dev, BAP0, buf, len);
    857 
     860        res = hfa384x_from_bap(dev, BAP0, buf, len);
     861
     862unlock:
    858863        spin_unlock_bh(&local->baplock);
    859864        mutex_unlock(&local->rid_bap_mtx);
  • src/linux/universal/linux-3.18/drivers/scsi/aic94xx/aic94xx_sds.c

    r25370 r31923  
    984984        int err, i;
    985985        u32 offs, size;
    986         struct asd_ll_el *el;
     986        struct asd_ll_el *el = NULL;
    987987        struct asd_ctrla_phy_settings *ps;
    988988        struct asd_ctrla_phy_settings dflt_ps;
     
    10051005                size = sizeof(struct asd_ctrla_phy_settings);
    10061006                ps = &dflt_ps;
     1007                goto out_process;
    10071008        }
    10081009
     
    10291030                goto out2;
    10301031        }
    1031 
     1032out_process:
    10321033        err = asd_process_ctrla_phy_settings(asd_ha, ps);
    10331034        if (err) {
  • src/linux/universal/linux-3.18/drivers/staging/android/ion/ion.c

    r28057 r31923  
    390390}
    391391
    392 static int ion_handle_put(struct ion_handle *handle)
     392static int ion_handle_put_nolock(struct ion_handle *handle)
     393{
     394        int ret;
     395
     396        ret = kref_put(&handle->ref, ion_handle_destroy);
     397
     398        return ret;
     399}
     400
     401int ion_handle_put(struct ion_handle *handle)
    393402{
    394403        struct ion_client *client = handle->client;
     
    396405
    397406        mutex_lock(&client->lock);
    398         ret = kref_put(&handle->ref, ion_handle_destroy);
     407        ret = ion_handle_put_nolock(handle);
    399408        mutex_unlock(&client->lock);
    400409
     
    420429}
    421430
    422 static struct ion_handle *ion_handle_get_by_id(struct ion_client *client,
     431static struct ion_handle *ion_handle_get_by_id_nolock(struct ion_client *client,
    423432                                                int id)
    424433{
    425434        struct ion_handle *handle;
    426435
    427         mutex_lock(&client->lock);
    428436        handle = idr_find(&client->idr, id);
    429437        if (handle)
    430438                ion_handle_get(handle);
     439
     440        return handle ? handle : ERR_PTR(-EINVAL);
     441}
     442
     443struct ion_handle *ion_handle_get_by_id(struct ion_client *client,
     444                                                int id)
     445{
     446        struct ion_handle *handle;
     447
     448        mutex_lock(&client->lock);
     449        handle = ion_handle_get_by_id_nolock(client, id);
    431450        mutex_unlock(&client->lock);
    432451
    433         return handle ? handle : ERR_PTR(-EINVAL);
     452        return handle;
    434453}
    435454
     
    535554EXPORT_SYMBOL(ion_alloc);
    536555
    537 void ion_free(struct ion_client *client, struct ion_handle *handle)
     556static void ion_free_nolock(struct ion_client *client, struct ion_handle *handle)
    538557{
    539558        bool valid_handle;
     
    541560        BUG_ON(client != handle->client);
    542561
    543         mutex_lock(&client->lock);
    544562        valid_handle = ion_handle_validate(client, handle);
    545563
    546564        if (!valid_handle) {
    547565                WARN(1, "%s: invalid handle passed to free.\n", __func__);
    548                 mutex_unlock(&client->lock);
    549566                return;
    550567        }
     568        ion_handle_put_nolock(handle);
     569}
     570
     571void ion_free(struct ion_client *client, struct ion_handle *handle)
     572{
     573        BUG_ON(client != handle->client);
     574
     575        mutex_lock(&client->lock);
     576        ion_free_nolock(client, handle);
    551577        mutex_unlock(&client->lock);
    552         ion_handle_put(handle);
    553578}
    554579EXPORT_SYMBOL(ion_free);
     
    12791304                struct ion_handle *handle;
    12801305
    1281                 handle = ion_handle_get_by_id(client, data.handle.handle);
    1282                 if (IS_ERR(handle))
     1306                mutex_lock(&client->lock);
     1307                handle = ion_handle_get_by_id_nolock(client, data.handle.handle);
     1308                if (IS_ERR(handle)) {
     1309                        mutex_unlock(&client->lock);
    12831310                        return PTR_ERR(handle);
    1284                 ion_free(client, handle);
    1285                 ion_handle_put(handle);
     1311                }
     1312                ion_free_nolock(client, handle);
     1313                ion_handle_put_nolock(handle);
     1314                mutex_unlock(&client->lock);
    12861315                break;
    12871316        }
  • src/linux/universal/linux-3.18/drivers/tty/nozomi.c

    r25370 r31923  
    825825        int i, ret;
    826826
    827         read_mem32((u32 *) &size, addr, 4);
     827        size = __le32_to_cpu(readl(addr));
    828828        /*  DBG1( "%d bytes port: %d", size, index); */
    829829
  • src/linux/universal/linux-3.18/drivers/usb/gadget/legacy/inode.c

    r30256 r31923  
    655655                if (!priv->iv) {
    656656                        kfree(priv);
     657                        value = -ENOMEM;
    657658                        goto fail;
    658659                }
  • src/linux/universal/linux-3.18/drivers/vfio/pci/vfio_pci.c

    r29271 r31923  
    490490        } else if (cmd == VFIO_DEVICE_SET_IRQS) {
    491491                struct vfio_irq_set hdr;
     492                size_t size;
    492493                u8 *data = NULL;
    493                 int ret = 0;
     494                int max, ret = 0;
    494495
    495496                minsz = offsetofend(struct vfio_irq_set, count);
     
    499500
    500501                if (hdr.argsz < minsz || hdr.index >= VFIO_PCI_NUM_IRQS ||
     502                    hdr.count >= (U32_MAX - hdr.start) ||
    501503                    hdr.flags & ~(VFIO_IRQ_SET_DATA_TYPE_MASK |
    502504                                  VFIO_IRQ_SET_ACTION_TYPE_MASK))
    503505                        return -EINVAL;
    504506
    505                 if (!(hdr.flags & VFIO_IRQ_SET_DATA_NONE)) {
    506                         size_t size;
    507                         int max = vfio_pci_get_irq_count(vdev, hdr.index);
    508 
    509                         if (hdr.flags & VFIO_IRQ_SET_DATA_BOOL)
    510                                 size = sizeof(uint8_t);
    511                         else if (hdr.flags & VFIO_IRQ_SET_DATA_EVENTFD)
    512                                 size = sizeof(int32_t);
    513                         else
    514                                 return -EINVAL;
    515 
    516                         if (hdr.argsz - minsz < hdr.count * size ||
    517                             hdr.start >= max || hdr.start + hdr.count > max)
     507                max = vfio_pci_get_irq_count(vdev, hdr.index);
     508                if (hdr.start >= max || hdr.start + hdr.count > max)
     509                        return -EINVAL;
     510
     511                switch (hdr.flags & VFIO_IRQ_SET_DATA_TYPE_MASK) {
     512                case VFIO_IRQ_SET_DATA_NONE:
     513                        size = 0;
     514                        break;
     515                case VFIO_IRQ_SET_DATA_BOOL:
     516                        size = sizeof(uint8_t);
     517                        break;
     518                case VFIO_IRQ_SET_DATA_EVENTFD:
     519                        size = sizeof(int32_t);
     520                        break;
     521                default:
     522                        return -EINVAL;
     523                }
     524
     525                if (size) {
     526                        if (hdr.argsz - minsz < hdr.count * size)
    518527                                return -EINVAL;
    519528
  • src/linux/universal/linux-3.18/drivers/vfio/pci/vfio_pci_intrs.c

    r25370 r31923  
    467467                return -EINVAL;
    468468
    469         vdev->ctx = kzalloc(nvec * sizeof(struct vfio_pci_irq_ctx), GFP_KERNEL);
     469        vdev->ctx = kcalloc(nvec, sizeof(struct vfio_pci_irq_ctx), GFP_KERNEL);
    470470        if (!vdev->ctx)
    471471                return -ENOMEM;
  • src/linux/universal/linux-3.18/fs/btrfs/extent_io.c

    r28057 r31923  
    21642164                next = next_state(state);
    21652165
    2166                 failrec = (struct io_failure_record *)state->private;
     2166                failrec = (struct io_failure_record *)(unsigned long)state->private;
    21672167                free_extent_state(state);
    21682168                kfree(failrec);
  • src/linux/universal/linux-3.18/fs/cifs/cifsglob.h

    r31168 r31923  
    892892#ifdef CONFIG_CIFS_SMB2
    893893        bool print:1;           /* set if connection to printer share */
    894         bool bad_network_name:1; /* set if ret status STATUS_BAD_NETWORK_NAME */
    895894        __le32 capabilities;
    896895        __u32 share_flags;
  • src/linux/universal/linux-3.18/fs/cifs/netmisc.c

    r25370 r31923  
    927927        /* Subtract the NTFS time offset, then convert to 1s intervals. */
    928928        s64 t = le64_to_cpu(ntutc) - NTFS_TIME_OFFSET;
     929        u64 abs_t;
    929930
    930931        /*
     
    934935         */
    935936        if (t < 0) {
    936                 t = -t;
    937                 ts.tv_nsec = (long)(do_div(t, 10000000) * 100);
     937                abs_t = -t;
     938                ts.tv_nsec = (long)(do_div(abs_t, 10000000) * 100);
    938939                ts.tv_nsec = -ts.tv_nsec;
    939                 ts.tv_sec = -t;
     940                ts.tv_sec = -abs_t;
    940941        } else {
    941                 ts.tv_nsec = (long)do_div(t, 10000000) * 100;
    942                 ts.tv_sec = t;
     942                abs_t = t;
     943                ts.tv_nsec = (long)do_div(abs_t, 10000000) * 100;
     944                ts.tv_sec = abs_t;
    943945        }
    944946
  • src/linux/universal/linux-3.18/fs/cifs/smb1ops.c

    r25370 r31923  
    10131013{
    10141014        return !cfile->srch_inf.endOfSearch && !cfile->invalidHandle;
     1015}
     1016
     1017static bool
     1018cifs_can_echo(struct TCP_Server_Info *server)
     1019{
     1020        if (server->tcpStatus == CifsGood)
     1021                return true;
     1022
     1023        return false;
    10151024}
    10161025
     
    10491058        .qfs_tcon = cifs_qfs_tcon,
    10501059        .is_path_accessible = cifs_is_path_accessible,
     1060        .can_echo = cifs_can_echo,
    10511061        .query_path_info = cifs_query_path_info,
    10521062        .query_file_info = cifs_query_file_info,
  • src/linux/universal/linux-3.18/fs/cifs/smb2pdu.c

    r31885 r31923  
    855855                return -EIO;
    856856
    857         if (tcon && tcon->bad_network_name)
    858                 return -ENOENT;
    859 
    860857        unc_path = kmalloc(MAX_SHARENAME_LENGTH * 2, GFP_KERNEL);
    861858        if (unc_path == NULL)
     
    951948        if (rsp->hdr.Status == STATUS_BAD_NETWORK_NAME) {
    952949                cifs_dbg(VFS, "BAD_NETWORK_NAME: %s\n", tree);
    953                 if (tcon)
    954                         tcon->bad_network_name = true;
    955950        }
    956951        goto tcon_exit;
  • src/linux/universal/linux-3.18/fs/gfs2/dir.c

    r25370 r31923  
    765765
    766766        error = get_leaf_nr(dip, index, &leaf_no);
    767         if (!error)
     767        if (!IS_ERR_VALUE(error))
    768768                error = get_leaf(dip, leaf_no, bh_out);
    769769
     
    981981        index = name->hash >> (32 - dip->i_depth);
    982982        error = get_leaf_nr(dip, index, &leaf_no);
    983         if (error)
     983        if (IS_ERR_VALUE(error))
    984984                return error;
    985985
  • src/linux/universal/linux-3.18/fs/nfs/nfs4proc.c

    r30256 r31923  
    30583058                         bool auth_probe)
    30593059{
    3060         int status;
    3061 
    3062         switch (auth_probe) {
    3063         case false:
     3060        int status = 0;
     3061
     3062        if (!auth_probe)
    30643063                status = nfs4_lookup_root(server, fhandle, info);
    3065                 if (status != -NFS4ERR_WRONGSEC)
    3066                         break;
    3067         default:
     3064
     3065        if (auth_probe || status == NFS4ERR_WRONGSEC)
    30683066                status = nfs4_do_find_root_sec(server, fhandle, info);
    3069         }
    30703067
    30713068        if (status == 0)
  • src/linux/universal/linux-3.18/fs/nfsd/nfs4state.c

    r28964 r31923  
    37583758{
    37593759        __be32 status;
    3760         unsigned char old_deny_bmap;
     3760        unsigned char old_deny_bmap = stp->st_deny_bmap;
    37613761
    37623762        if (!test_access(open->op_share_access, stp))
     
    37673767        status = nfs4_file_check_deny(fp, open->op_share_deny);
    37683768        if (status == nfs_ok) {
    3769                 old_deny_bmap = stp->st_deny_bmap;
    37703769                set_deny(open->op_share_deny, stp);
    37713770                fp->fi_share_deny |=
  • src/linux/universal/linux-3.18/include/linux/ftrace_event.h

    r25370 r31923  
    585585extern void ftrace_profile_free_filter(struct perf_event *event);
    586586extern void *perf_trace_buf_prepare(int size, unsigned short type,
    587                                     struct pt_regs *regs, int *rctxp);
     587                                    struct pt_regs **regs, int *rctxp);
    588588
    589589static inline void
  • src/linux/universal/linux-3.18/include/linux/perf_event.h

    r25370 r31923  
    661661extern struct static_key perf_swevent_enabled[PERF_COUNT_SW_MAX];
    662662
     663extern void ___perf_sw_event(u32, u64, struct pt_regs *, u64);
    663664extern void __perf_sw_event(u32, u64, struct pt_regs *, u64);
    664665
     
    685686perf_sw_event(u32 event_id, u64 nr, struct pt_regs *regs, u64 addr)
    686687{
    687         struct pt_regs hot_regs;
    688 
     688        if (static_key_false(&perf_swevent_enabled[event_id]))
     689                __perf_sw_event(event_id, nr, regs, addr);
     690}
     691
     692DECLARE_PER_CPU(struct pt_regs, __perf_regs[4]);
     693
     694/*
     695 * 'Special' version for the scheduler, it hard assumes no recursion,
     696 * which is guaranteed by us not actually scheduling inside other swevents
     697 * because those disable preemption.
     698 */
     699static __always_inline void
     700perf_sw_event_sched(u32 event_id, u64 nr, u64 addr)
     701{
    689702        if (static_key_false(&perf_swevent_enabled[event_id])) {
    690                 if (!regs) {
    691                         perf_fetch_caller_regs(&hot_regs);
    692                         regs = &hot_regs;
    693                 }
    694                 __perf_sw_event(event_id, nr, regs, addr);
     703                struct pt_regs *regs = this_cpu_ptr(&__perf_regs[0]);
     704
     705                perf_fetch_caller_regs(regs);
     706                ___perf_sw_event(event_id, nr, regs, addr);
    695707        }
    696708}
     
    708720                                             struct task_struct *next)
    709721{
    710         perf_sw_event(PERF_COUNT_SW_CONTEXT_SWITCHES, 1, NULL, 0);
     722        perf_sw_event_sched(PERF_COUNT_SW_CONTEXT_SWITCHES, 1, 0);
    711723
    712724        if (static_key_false(&perf_sched_events.key))
     
    819831perf_sw_event(u32 event_id, u64 nr, struct pt_regs *regs, u64 addr)     { }
    820832static inline void
     833perf_sw_event_sched(u32 event_id, u64 nr, u64 addr)                     { }
     834static inline void
    821835perf_bp_event(struct perf_event *event, void *data)                     { }
    822836
  • src/linux/universal/linux-3.18/include/trace/ftrace.h

    r25370 r31923  
    766766        struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\
    767767        struct ftrace_raw_##call *entry;                                \
    768         struct pt_regs __regs;                                          \
     768        struct pt_regs *__regs;                                         \
    769769        u64 __addr = 0, __count = 1;                                    \
    770770        struct task_struct *__task = NULL;                              \
     
    785785        __entry_size -= sizeof(u32);                                    \
    786786                                                                        \
    787         perf_fetch_caller_regs(&__regs);                                \
    788787        entry = perf_trace_buf_prepare(__entry_size,                    \
    789788                        event_call->event.type, &__regs, &rctx);        \
     
    791790                return;                                                 \
    792791                                                                        \
     792        perf_fetch_caller_regs(__regs);                                 \
     793                                                                        \
    793794        tstruct                                                         \
    794795                                                                        \
     
    796797                                                                        \
    797798        perf_trace_buf_submit(entry, __entry_size, rctx, __addr,        \
    798                 __count, &__regs, head, __task);                        \
     799                __count, __regs, head, __task);                         \
    799800}
    800801
  • src/linux/universal/linux-3.18/kernel/configs/tiny.config

    r25370 r31923  
     1# CONFIG_CC_OPTIMIZE_FOR_PERFORMANCE is not set
    12CONFIG_CC_OPTIMIZE_FOR_SIZE=y
     3# CONFIG_KERNEL_GZIP is not set
     4# CONFIG_KERNEL_BZIP2 is not set
     5# CONFIG_KERNEL_LZMA is not set
    26CONFIG_KERNEL_XZ=y
     7# CONFIG_KERNEL_LZO is not set
     8# CONFIG_KERNEL_LZ4 is not set
    39CONFIG_OPTIMIZE_INLINING=y
     10# CONFIG_SLAB is not set
     11# CONFIG_SLUB is not set
    412CONFIG_SLOB=y
  • src/linux/universal/linux-3.18/kernel/events/core.c

    r31885 r31923  
    59065906}
    59075907
     5908DEFINE_PER_CPU(struct pt_regs, __perf_regs[4]);
     5909
    59085910int perf_swevent_get_recursion_context(void)
    59095911{
     
    59215923}
    59225924
     5925void ___perf_sw_event(u32 event_id, u64 nr, struct pt_regs *regs, u64 addr)
     5926{
     5927        struct perf_sample_data data;
     5928
     5929        if (WARN_ON_ONCE(!regs))
     5930                return;
     5931
     5932        perf_sample_data_init(&data, addr, 0);
     5933        do_perf_sw_event(PERF_TYPE_SOFTWARE, event_id, nr, &data, regs);
     5934}
     5935
    59235936void __perf_sw_event(u32 event_id, u64 nr, struct pt_regs *regs, u64 addr)
    59245937{
    5925         struct perf_sample_data data;
    59265938        int rctx;
    59275939
    59285940        preempt_disable_notrace();
    59295941        rctx = perf_swevent_get_recursion_context();
    5930         if (rctx < 0)
    5931                 return;
    5932 
    5933         perf_sample_data_init(&data, addr, 0);
    5934 
    5935         do_perf_sw_event(PERF_TYPE_SOFTWARE, event_id, nr, &data, regs);
     5942        if (unlikely(rctx < 0))
     5943                goto fail;
     5944
     5945        ___perf_sw_event(event_id, nr, regs, addr);
    59365946
    59375947        perf_swevent_put_recursion_context(rctx);
     5948fail:
    59385949        preempt_enable_notrace();
    59395950}
  • src/linux/universal/linux-3.18/kernel/sched/core.c

    r30910 r31923  
    10841084                        p->sched_class->migrate_task_rq(p, new_cpu);
    10851085                p->se.nr_migrations++;
    1086                 perf_sw_event(PERF_COUNT_SW_CPU_MIGRATIONS, 1, NULL, 0);
     1086                perf_sw_event_sched(PERF_COUNT_SW_CPU_MIGRATIONS, 1, 0);
    10871087        }
    10881088
  • src/linux/universal/linux-3.18/kernel/trace/ring_buffer.c

    r31885 r31923  
    34523452{
    34533453        struct ring_buffer_per_cpu *cpu_buffer;
     3454        struct buffer_page *reader;
     3455        struct buffer_page *head_page;
     3456        struct buffer_page *commit_page;
     3457        unsigned commit;
    34543458
    34553459        cpu_buffer = iter->cpu_buffer;
    34563460
    3457         return iter->head_page == cpu_buffer->commit_page &&
    3458                 iter->head == rb_commit_index(cpu_buffer);
     3461        /* Remember, trace recording is off when iterator is in use */
     3462        reader = cpu_buffer->reader_page;
     3463        head_page = cpu_buffer->head_page;
     3464        commit_page = cpu_buffer->commit_page;
     3465        commit = rb_page_commit(commit_page);
     3466
     3467        return ((iter->head_page == commit_page && iter->head == commit) ||
     3468                (iter->head_page == reader && commit_page == head_page &&
     3469                 head_page->read == commit &&
     3470                 iter->head == rb_page_commit(cpu_buffer->reader_page)));
    34593471}
    34603472EXPORT_SYMBOL_GPL(ring_buffer_iter_empty);
  • src/linux/universal/linux-3.18/kernel/trace/trace.c

    r29492 r31923  
    58105810
    58115811 out_reg:
     5812        ret = alloc_snapshot(&global_trace);
     5813        if (ret < 0)
     5814                goto out;
     5815
    58125816        ret = register_ftrace_function_probe(glob, ops, count);
    58135817
    5814         if (ret >= 0)
    5815                 alloc_snapshot(&global_trace);
    5816 
     5818 out:
    58175819        return ret < 0 ? ret : 0;
    58185820}
  • src/linux/universal/linux-3.18/kernel/trace/trace_event_perf.c

    r25370 r31923  
    262262
    263263void *perf_trace_buf_prepare(int size, unsigned short type,
    264                              struct pt_regs *regs, int *rctxp)
     264                             struct pt_regs **regs, int *rctxp)
    265265{
    266266        struct trace_entry *entry;
     
    281281                return NULL;
    282282
     283        if (regs)
     284                *regs = this_cpu_ptr(&__perf_regs[*rctxp]);
    283285        raw_data = this_cpu_ptr(perf_trace_buf[*rctxp]);
    284286
  • src/linux/universal/linux-3.18/kernel/trace/trace_kprobe.c

    r25370 r31923  
    11591159        size -= sizeof(u32);
    11601160
    1161         entry = perf_trace_buf_prepare(size, call->event.type, regs, &rctx);
     1161        entry = perf_trace_buf_prepare(size, call->event.type, NULL, &rctx);
    11621162        if (!entry)
    11631163                return;
     
    11901190        size -= sizeof(u32);
    11911191
    1192         entry = perf_trace_buf_prepare(size, call->event.type, regs, &rctx);
     1192        entry = perf_trace_buf_prepare(size, call->event.type, NULL, &rctx);
    11931193        if (!entry)
    11941194                return;
  • src/linux/universal/linux-3.18/kernel/trace/trace_syscalls.c

    r25370 r31923  
    587587
    588588        rec = (struct syscall_trace_enter *)perf_trace_buf_prepare(size,
    589                                 sys_data->enter_event->event.type, regs, &rctx);
     589                                sys_data->enter_event->event.type, NULL, &rctx);
    590590        if (!rec)
    591591                return;
     
    660660
    661661        rec = (struct syscall_trace_exit *)perf_trace_buf_prepare(size,
    662                                 sys_data->exit_event->event.type, regs, &rctx);
     662                                sys_data->exit_event->event.type, NULL, &rctx);
    663663        if (!rec)
    664664                return;
  • src/linux/universal/linux-3.18/kernel/trace/trace_uprobe.c

    r25370 r31923  
    11161116                goto out;
    11171117
    1118         entry = perf_trace_buf_prepare(size, call->event.type, regs, &rctx);
     1118        entry = perf_trace_buf_prepare(size, call->event.type, NULL, &rctx);
    11191119        if (!entry)
    11201120                goto out;
  • src/linux/universal/linux-3.18/mm/page_alloc.c

    r29492 r31923  
    53385338        memset(arch_zone_highest_possible_pfn, 0,
    53395339                                sizeof(arch_zone_highest_possible_pfn));
    5340         arch_zone_lowest_possible_pfn[0] = find_min_pfn_with_active_regions();
    5341         arch_zone_highest_possible_pfn[0] = max_zone_pfn[0];
    5342         for (i = 1; i < MAX_NR_ZONES; i++) {
     5340
     5341        start_pfn = find_min_pfn_with_active_regions();
     5342
     5343        for (i = 0; i < MAX_NR_ZONES; i++) {
    53435344                if (i == ZONE_MOVABLE)
    53445345                        continue;
    5345                 arch_zone_lowest_possible_pfn[i] =
    5346                         arch_zone_highest_possible_pfn[i-1];
    5347                 arch_zone_highest_possible_pfn[i] =
    5348                         max(max_zone_pfn[i], arch_zone_lowest_possible_pfn[i]);
     5346
     5347                end_pfn = max(max_zone_pfn[i], start_pfn);
     5348                arch_zone_lowest_possible_pfn[i] = start_pfn;
     5349                arch_zone_highest_possible_pfn[i] = end_pfn;
     5350
     5351                start_pfn = end_pfn;
    53495352        }
    53505353        arch_zone_lowest_possible_pfn[ZONE_MOVABLE] = 0;
  • src/linux/universal/linux-3.18/net/ipv4/ping.c

    r31869 r31923  
    155155{
    156156        struct inet_sock *isk = inet_sk(sk);
     157
    157158        pr_debug("ping_unhash(isk=%p,isk->num=%u)\n", isk, isk->inet_num);
     159        write_lock_bh(&ping_table.lock);
    158160        if (sk_hashed(sk)) {
    159                 write_lock_bh(&ping_table.lock);
    160161                hlist_nulls_del(&sk->sk_nulls_node);
    161162                sk_nulls_node_init(&sk->sk_nulls_node);
     
    164165                isk->inet_sport = 0;
    165166                sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
    166                 write_unlock_bh(&ping_table.lock);
    167         }
     167        }
     168        write_unlock_bh(&ping_table.lock);
    168169}
    169170EXPORT_SYMBOL_GPL(ping_unhash);
  • src/linux/universal/linux-3.18/security/keys/gc.c

    r28516 r31923  
    4747 */
    4848struct key_type key_type_dead = {
    49         .name = "dead",
     49        .name = ".dead",
    5050};
    5151
  • src/linux/universal/linux-3.18/security/keys/keyctl.c

    r28964 r31923  
    278278 * keyring, creating it if necessary.  A named session keyring must have Search
    279279 * permission for it to be joined.  Session keyrings without this permit will
    280  * be skipped over.
     280 * be skipped over.  It is not permitted for userspace to create or join
     281 * keyrings whose name begin with a dot.
    281282 *
    282283 * If successful, the ID of the joined session keyring will be returned.
     
    295296                        goto error;
    296297                }
     298
     299                ret = -EPERM;
     300                if (name[0] == '.')
     301                        goto error_name;
    297302        }
    298303
    299304        /* join the session */
    300305        ret = join_session_keyring(name);
     306error_name:
    301307        kfree(name);
    302 
    303308error:
    304309        return ret;
     
    12541259 * return the old setting.
    12551260 *
    1256  * If a process keyring is specified then this will be created if it doesn't
    1257  * yet exist.  The old setting will be returned if successful.
     1261 * If a thread or process keyring is specified then it will be created if it
     1262 * doesn't yet exist.  The old setting will be returned if successful.
    12581263 */
    12591264long keyctl_set_reqkey_keyring(int reqkey_defl)
     
    12801285        case KEY_REQKEY_DEFL_PROCESS_KEYRING:
    12811286                ret = install_process_keyring_to_cred(new);
    1282                 if (ret < 0) {
    1283                         if (ret != -EEXIST)
    1284                                 goto error;
    1285                         ret = 0;
    1286                 }
     1287                if (ret < 0)
     1288                        goto error;
    12871289                goto set;
    12881290
  • src/linux/universal/linux-3.18/security/keys/process_keys.c

    r28964 r31923  
    126126
    127127/*
    128  * Install a fresh thread keyring directly to new credentials.  This keyring is
    129  * allowed to overrun the quota.
     128 * Install a thread keyring to the given credentials struct if it didn't have
     129 * one already.  This is allowed to overrun the quota.
     130 *
     131 * Return: 0 if a thread keyring is now present; -errno on failure.
    130132 */
    131133int install_thread_keyring_to_cred(struct cred *new)
    132134{
    133135        struct key *keyring;
     136
     137        if (new->thread_keyring)
     138                return 0;
    134139
    135140        keyring = keyring_alloc("_tid", new->uid, new->gid, new,
     
    144149
    145150/*
    146  * Install a fresh thread keyring, discarding the old one.
     151 * Install a thread keyring to the current task if it didn't have one already.
     152 *
     153 * Return: 0 if a thread keyring is now present; -errno on failure.
    147154 */
    148155static int install_thread_keyring(void)
     
    154161        if (!new)
    155162                return -ENOMEM;
    156 
    157         BUG_ON(new->thread_keyring);
    158163
    159164        ret = install_thread_keyring_to_cred(new);
     
    167172
    168173/*
    169  * Install a process keyring directly to a credentials struct.
    170  *
    171  * Returns -EEXIST if there was already a process keyring, 0 if one installed,
    172  * and other value on any other error
     174 * Install a process keyring to the given credentials struct if it didn't have
     175 * one already.  This is allowed to overrun the quota.
     176 *
     177 * Return: 0 if a process keyring is now present; -errno on failure.
    173178 */
    174179int install_process_keyring_to_cred(struct cred *new)
     
    177182
    178183        if (new->process_keyring)
    179                 return -EEXIST;
     184                return 0;
    180185
    181186        keyring = keyring_alloc("_pid", new->uid, new->gid, new,
     
    190195
    191196/*
    192  * Make sure a process keyring is installed for the current process.  The
    193  * existing process keyring is not replaced.
    194  *
    195  * Returns 0 if there is a process keyring by the end of this function, some
    196  * error otherwise.
     197 * Install a process keyring to the current task if it didn't have one already.
     198 *
     199 * Return: 0 if a process keyring is now present; -errno on failure.
    197200 */
    198201static int install_process_keyring(void)
     
    208211        if (ret < 0) {
    209212                abort_creds(new);
    210                 return ret != -EEXIST ? ret : 0;
     213                return ret;
    211214        }
    212215
     
    215218
    216219/*
    217  * Install a session keyring directly to a credentials struct.
     220 * Install the given keyring as the session keyring of the given credentials
     221 * struct, replacing the existing one if any.  If the given keyring is NULL,
     222 * then install a new anonymous session keyring.
     223 *
     224 * Return: 0 on success; -errno on failure.
    218225 */
    219226int install_session_keyring_to_cred(struct cred *cred, struct key *keyring)
     
    250257
    251258/*
    252  * Install a session keyring, discarding the old one.  If a keyring is not
    253  * supplied, an empty one is invented.
     259 * Install the given keyring as the session keyring of the current task,
     260 * replacing the existing one if any.  If the given keyring is NULL, then
     261 * install a new anonymous session keyring.
     262 *
     263 * Return: 0 on success; -errno on failure.
    254264 */
    255265static int install_session_keyring(struct key *keyring)
  • src/linux/universal/linux-4.4/Documentation/sysctl/fs.txt

    r29846 r31923  
    266266==============================================================
    267267
     268mount-max:
     269
     270This denotes the maximum number of mounts that may exist
     271in a mount namespace.
     272
     273==============================================================
     274
    268275
    2692762. /proc/sys/fs/binfmt_misc
  • src/linux/universal/linux-4.4/Makefile

    r31916 r31923  
    11VERSION = 4
    22PATCHLEVEL = 4
    3 SUBLEVEL = 64
     3SUBLEVEL = 65
    44EXTRAVERSION =
    55NAME = Blurry Fish Butt
  • src/linux/universal/linux-4.4/drivers/media/tuners/tuner-xc2028.c

    r28606 r31923  
    14041404         */
    14051405        kfree(priv->ctrl.fname);
     1406        priv->ctrl.fname = NULL;
    14061407        memcpy(&priv->ctrl, p, sizeof(priv->ctrl));
    14071408        if (p->fname) {
    14081409                priv->ctrl.fname = kstrdup(p->fname, GFP_KERNEL);
    14091410                if (priv->ctrl.fname == NULL)
    1410                         rc = -ENOMEM;
     1411                        return -ENOMEM;
    14111412        }
    14121413
  • src/linux/universal/linux-4.4/drivers/net/wireless/hostap/hostap_hw.c

    r28606 r31923  
    837837
    838838        res = hfa384x_setup_bap(dev, BAP0, rid, 0);
    839         if (!res)
    840                 res = hfa384x_from_bap(dev, BAP0, &rec, sizeof(rec));
     839        if (res)
     840                goto unlock;
     841
     842        res = hfa384x_from_bap(dev, BAP0, &rec, sizeof(rec));
     843        if (res)
     844                goto unlock;
    841845
    842846        if (le16_to_cpu(rec.len) == 0) {
    843847                /* RID not available */
    844848                res = -ENODATA;
     849                goto unlock;
    845850        }
    846851
    847852        rlen = (le16_to_cpu(rec.len) - 1) * 2;
    848         if (!res && exact_len && rlen != len) {
     853        if (exact_len && rlen != len) {
    849854                printk(KERN_DEBUG "%s: hfa384x_get_rid - RID len mismatch: "
    850855                       "rid=0x%04x, len=%d (expected %d)\n",
     
    853858        }
    854859
    855         if (!res)
    856                 res = hfa384x_from_bap(dev, BAP0, buf, len);
    857 
     860        res = hfa384x_from_bap(dev, BAP0, buf, len);
     861
     862unlock:
    858863        spin_unlock_bh(&local->baplock);
    859864        mutex_unlock(&local->rid_bap_mtx);
  • src/linux/universal/linux-4.4/drivers/staging/android/ion/ion.c

    r29492 r31923  
    388388}
    389389
    390 static int ion_handle_put(struct ion_handle *handle)
     390static int ion_handle_put_nolock(struct ion_handle *handle)
     391{
     392        int ret;
     393
     394        ret = kref_put(&handle->ref, ion_handle_destroy);
     395
     396        return ret;
     397}
     398
     399int ion_handle_put(struct ion_handle *handle)
    391400{
    392401        struct ion_client *client = handle->client;
     
    394403
    395404        mutex_lock(&client->lock);
    396         ret = kref_put(&handle->ref, ion_handle_destroy);
     405        ret = ion_handle_put_nolock(handle);
    397406        mutex_unlock(&client->lock);
    398407
     
    418427}
    419428
    420 static struct ion_handle *ion_handle_get_by_id(struct ion_client *client,
     429static struct ion_handle *ion_handle_get_by_id_nolock(struct ion_client *client,
    421430                                                int id)
    422431{
    423432        struct ion_handle *handle;
    424433
    425         mutex_lock(&client->lock);
    426434        handle = idr_find(&client->idr, id);
    427435        if (handle)
    428436                ion_handle_get(handle);
     437
     438        return handle ? handle : ERR_PTR(-EINVAL);
     439}
     440
     441struct ion_handle *ion_handle_get_by_id(struct ion_client *client,
     442                                                int id)
     443{
     444        struct ion_handle *handle;
     445
     446        mutex_lock(&client->lock);
     447        handle = ion_handle_get_by_id_nolock(client, id);
    429448        mutex_unlock(&client->lock);
    430449
    431         return handle ? handle : ERR_PTR(-EINVAL);
     450        return handle;
    432451}
    433452
     
    533552EXPORT_SYMBOL(ion_alloc);
    534553
    535 void ion_free(struct ion_client *client, struct ion_handle *handle)
     554static void ion_free_nolock(struct ion_client *client, struct ion_handle *handle)
    536555{
    537556        bool valid_handle;
     
    539558        BUG_ON(client != handle->client);
    540559
    541         mutex_lock(&client->lock);
    542560        valid_handle = ion_handle_validate(client, handle);
    543561
    544562        if (!valid_handle) {
    545563                WARN(1, "%s: invalid handle passed to free.\n", __func__);
    546                 mutex_unlock(&client->lock);
    547564                return;
    548565        }
     566        ion_handle_put_nolock(handle);
     567}
     568
     569void ion_free(struct ion_client *client, struct ion_handle *handle)
     570{
     571        BUG_ON(client != handle->client);
     572
     573        mutex_lock(&client->lock);
     574        ion_free_nolock(client, handle);
    549575        mutex_unlock(&client->lock);
    550         ion_handle_put(handle);
    551576}
    552577EXPORT_SYMBOL(ion_free);
     
    12841309                struct ion_handle *handle;
    12851310
    1286                 handle = ion_handle_get_by_id(client, data.handle.handle);
    1287                 if (IS_ERR(handle))
     1311                mutex_lock(&client->lock);
     1312                handle = ion_handle_get_by_id_nolock(client, data.handle.handle);
     1313                if (IS_ERR(handle)) {
     1314                        mutex_unlock(&client->lock);
    12881315                        return PTR_ERR(handle);
    1289                 ion_free(client, handle);
    1290                 ion_handle_put(handle);
     1316                }
     1317                ion_free_nolock(client, handle);
     1318                ion_handle_put_nolock(handle);
     1319                mutex_unlock(&client->lock);
    12911320                break;
    12921321        }
  • src/linux/universal/linux-4.4/drivers/tty/nozomi.c

    r28606 r31923  
    825825        int i, ret;
    826826
    827         read_mem32((u32 *) &size, addr, 4);
     827        size = __le32_to_cpu(readl(addr));
    828828        /*  DBG1( "%d bytes port: %d", size, index); */
    829829
  • src/linux/universal/linux-4.4/drivers/vfio/pci/vfio_pci.c

    r29235 r31923  
    563563        } else if (cmd == VFIO_DEVICE_SET_IRQS) {
    564564                struct vfio_irq_set hdr;
     565                size_t size;
    565566                u8 *data = NULL;
    566                 int ret = 0;
     567                int max, ret = 0;
    567568
    568569                minsz = offsetofend(struct vfio_irq_set, count);
     
    572573
    573574                if (hdr.argsz < minsz || hdr.index >= VFIO_PCI_NUM_IRQS ||
     575                    hdr.count >= (U32_MAX - hdr.start) ||
    574576                    hdr.flags & ~(VFIO_IRQ_SET_DATA_TYPE_MASK |
    575577                                  VFIO_IRQ_SET_ACTION_TYPE_MASK))
    576578                        return -EINVAL;
    577579
    578                 if (!(hdr.flags & VFIO_IRQ_SET_DATA_NONE)) {
    579                         size_t size;
    580                         int max = vfio_pci_get_irq_count(vdev, hdr.index);
    581 
    582                         if (hdr.flags & VFIO_IRQ_SET_DATA_BOOL)
    583                                 size = sizeof(uint8_t);
    584                         else if (hdr.flags & VFIO_IRQ_SET_DATA_EVENTFD)
    585                                 size = sizeof(int32_t);
    586                         else
    587                                 return -EINVAL;
    588 
    589                         if (hdr.argsz - minsz < hdr.count * size ||
    590                             hdr.start >= max || hdr.start + hdr.count > max)
     580                max = vfio_pci_get_irq_count(vdev, hdr.index);
     581                if (hdr.start >= max || hdr.start + hdr.count > max)
     582                        return -EINVAL;
     583
     584                switch (hdr.flags & VFIO_IRQ_SET_DATA_TYPE_MASK) {
     585                case VFIO_IRQ_SET_DATA_NONE:
     586                        size = 0;
     587                        break;
     588                case VFIO_IRQ_SET_DATA_BOOL:
     589                        size = sizeof(uint8_t);
     590                        break;
     591                case VFIO_IRQ_SET_DATA_EVENTFD:
     592                        size = sizeof(int32_t);
     593                        break;
     594                default:
     595                        return -EINVAL;
     596                }
     597
     598                if (size) {
     599                        if (hdr.argsz - minsz < hdr.count * size)
    591600                                return -EINVAL;
    592601
  • src/linux/universal/linux-4.4/drivers/vfio/pci/vfio_pci_intrs.c

    r30589 r31923  
    256256                return -EINVAL;
    257257
    258         vdev->ctx = kzalloc(nvec * sizeof(struct vfio_pci_irq_ctx), GFP_KERNEL);
     258        vdev->ctx = kcalloc(nvec, sizeof(struct vfio_pci_irq_ctx), GFP_KERNEL);
    259259        if (!vdev->ctx)
    260260                return -ENOMEM;
  • src/linux/universal/linux-4.4/fs/gfs2/dir.c

    r28606 r31923  
    761761
    762762        error = get_leaf_nr(dip, index, &leaf_no);
    763         if (!error)
     763        if (!IS_ERR_VALUE(error))
    764764                error = get_leaf(dip, leaf_no, bh_out);
    765765
     
    977977        index = name->hash >> (32 - dip->i_depth);
    978978        error = get_leaf_nr(dip, index, &leaf_no);
    979         if (error)
     979        if (IS_ERR_VALUE(error))
    980980                return error;
    981981
  • src/linux/universal/linux-4.4/fs/mount.h

    r31662 r31923  
    1414        wait_queue_head_t poll;
    1515        u64 event;
     16        unsigned int            mounts; /* # of mounts in the namespace */
     17        unsigned int            pending_mounts;
    1618};
    1719
  • src/linux/universal/linux-4.4/fs/namespace.c

    r31662 r31923  
    2727#include "pnode.h"
    2828#include "internal.h"
     29
     30/* Maximum number of mounts in a mount namespace */
     31unsigned int sysctl_mount_max __read_mostly = 100000;
    2932
    3033static unsigned int m_hash_mask __read_mostly;
     
    926929        list_splice(&head, n->list.prev);
    927930
     931        n->mounts += n->pending_mounts;
     932        n->pending_mounts = 0;
     933
    928934        __attach_mnt(mnt, parent);
    929935        touch_mnt_namespace(n);
     
    14461452
    14471453        while (!list_empty(&tmp_list)) {
     1454                struct mnt_namespace *ns;
    14481455                bool disconnect;
    14491456                p = list_first_entry(&tmp_list, struct mount, mnt_list);
    14501457                list_del_init(&p->mnt_expire);
    14511458                list_del_init(&p->mnt_list);
    1452                 __touch_mnt_namespace(p->mnt_ns);
     1459                ns = p->mnt_ns;
     1460                if (ns) {
     1461                        ns->mounts--;
     1462                        __touch_mnt_namespace(ns);
     1463                }
    14531464                p->mnt_ns = NULL;
    14541465                if (how & UMOUNT_SYNC)
     
    18511862}
    18521863
     1864int count_mounts(struct mnt_namespace *ns, struct mount *mnt)
     1865{
     1866        unsigned int max = READ_ONCE(sysctl_mount_max);
     1867        unsigned int mounts = 0, old, pending, sum;
     1868        struct mount *p;
     1869
     1870        for (p = mnt; p; p = next_mnt(p, mnt))
     1871                mounts++;
     1872
     1873        old = ns->mounts;
     1874        pending = ns->pending_mounts;
     1875        sum = old + pending;
     1876        if ((old > sum) ||
     1877            (pending > sum) ||
     1878            (max < sum) ||
     1879            (mounts > (max - sum)))
     1880                return -ENOSPC;
     1881
     1882        ns->pending_mounts = pending + mounts;
     1883        return 0;
     1884}
     1885
    18531886/*
    18541887 *  @source_mnt : mount tree to be attached
     
    19201953{
    19211954        HLIST_HEAD(tree_list);
     1955        struct mnt_namespace *ns = dest_mnt->mnt_ns;
    19221956        struct mountpoint *smp;
    19231957        struct mount *child, *p;
     
    19311965        if (IS_ERR(smp))
    19321966                return PTR_ERR(smp);
     1967
     1968        /* Is there space to add these mounts to the mount namespace? */
     1969        if (!parent_path) {
     1970                err = count_mounts(ns, source_mnt);
     1971                if (err)
     1972                        goto out;
     1973        }
    19331974
    19341975        if (IS_MNT_SHARED(dest_mnt)) {
     
    19712012        while (!hlist_empty(&tree_list)) {
    19722013                child = hlist_entry(tree_list.first, struct mount, mnt_hash);
     2014                child->mnt_parent->mnt_ns->pending_mounts = 0;
    19732015                umount_tree(child, UMOUNT_SYNC);
    19742016        }
     
    19762018        cleanup_group_ids(source_mnt, NULL);
    19772019 out:
     2020        ns->pending_mounts = 0;
     2021
    19782022        read_seqlock_excl(&mount_lock);
    19792023        put_mountpoint(smp);
     
    28052849        new_ns->event = 0;
    28062850        new_ns->user_ns = get_user_ns(user_ns);
     2851        new_ns->mounts = 0;
     2852        new_ns->pending_mounts = 0;
    28072853        return new_ns;
    28082854}
     
    28542900        while (p) {
    28552901                q->mnt_ns = new_ns;
     2902                new_ns->mounts++;
    28562903                if (new_fs) {
    28572904                        if (&p->mnt == new_fs->root.mnt) {
     
    28922939                mnt->mnt_ns = new_ns;
    28932940                new_ns->root = mnt;
     2941                new_ns->mounts++;
    28942942                list_add(&mnt->mnt_list, &new_ns->list);
    28952943        } else {
  • src/linux/universal/linux-4.4/fs/pnode.c

    r31662 r31923  
    260260        }
    261261        hlist_add_head(&child->mnt_hash, list);
    262         return 0;
     262        return count_mounts(m->mnt_ns, child);
    263263}
    264264
  • src/linux/universal/linux-4.4/fs/pnode.h

    r31662 r31923  
    5555bool is_path_reachable(struct mount *, struct dentry *,
    5656                         const struct path *root);
     57int count_mounts(struct mnt_namespace *ns, struct mount *mnt);
    5758#endif /* _LINUX_PNODE_H */
  • src/linux/universal/linux-4.4/include/linux/mount.h

    r28606 r31923  
    9696extern dev_t name_to_dev_t(const char *name);
    9797
     98extern unsigned int sysctl_mount_max;
     99
    98100#endif /* _LINUX_MOUNT_H */
  • src/linux/universal/linux-4.4/kernel/events/core.c

    r31778 r31923  
    82518251}
    82528252
     8253/*
     8254 * Variation on perf_event_ctx_lock_nested(), except we take two context
     8255 * mutexes.
     8256 */
     8257static struct perf_event_context *
     8258__perf_event_ctx_lock_double(struct perf_event *group_leader,
     8259                             struct perf_event_context *ctx)
     8260{
     8261        struct perf_event_context *gctx;
     8262
     8263again:
     8264        rcu_read_lock();
     8265        gctx = READ_ONCE(group_leader->ctx);
     8266        if (!atomic_inc_not_zero(&gctx->refcount)) {
     8267                rcu_read_unlock();
     8268                goto again;
     8269        }
     8270        rcu_read_unlock();
     8271
     8272        mutex_lock_double(&gctx->mutex, &ctx->mutex);
     8273
     8274        if (group_leader->ctx != gctx) {
     8275                mutex_unlock(&ctx->mutex);
     8276                mutex_unlock(&gctx->mutex);
     8277                put_ctx(gctx);
     8278                goto again;
     8279        }
     8280
     8281        return gctx;
     8282}
     8283
    82538284/**
    82548285 * sys_perf_event_open - open a performance event, associate it to a task/cpu
     
    84878518
    84888519        if (move_group) {
    8489                 gctx = group_leader->ctx;
    8490                 mutex_lock_double(&gctx->mutex, &ctx->mutex);
     8520                gctx = __perf_event_ctx_lock_double(group_leader, ctx);
     8521
     8522                /*
     8523                 * Check if we raced against another sys_perf_event_open() call
     8524                 * moving the software group underneath us.
     8525                 */
     8526                if (!(group_leader->group_flags & PERF_GROUP_SOFTWARE)) {
     8527                        /*
     8528                         * If someone moved the group out from under us, check
     8529                         * if this new event wound up on the same ctx, if so
     8530                         * its the regular !move_group case, otherwise fail.
     8531                         */
     8532                        if (gctx != ctx) {
     8533                                err = -EINVAL;
     8534                                goto err_locked;
     8535                        } else {
     8536                                perf_event_ctx_unlock(group_leader, gctx);
     8537                                move_group = 0;
     8538                        }
     8539                }
    84918540        } else {
    84928541                mutex_lock(&ctx->mutex);
     
    85838632
    85848633        if (move_group)
    8585                 mutex_unlock(&gctx->mutex);
     8634                perf_event_ctx_unlock(group_leader, gctx);
    85868635        mutex_unlock(&ctx->mutex);
    85878636
     
    86118660err_locked:
    86128661        if (move_group)
    8613                 mutex_unlock(&gctx->mutex);
     8662                perf_event_ctx_unlock(group_leader, gctx);
    86148663        mutex_unlock(&ctx->mutex);
    86158664/* err_file: */
  • src/linux/universal/linux-4.4/kernel/sysctl.c

    r31220 r31923  
    6666#include <linux/kexec.h>
    6767#include <linux/bpf.h>
     68#include <linux/mount.h>
    6869
    6970#include <asm/uaccess.h>
     
    17491750                .mode           = 0644,
    17501751                .proc_handler   = proc_doulongvec_minmax,
     1752        },
     1753        {
     1754                .procname       = "mount-max",
     1755                .data           = &sysctl_mount_max,
     1756                .maxlen         = sizeof(unsigned int),
     1757                .mode           = 0644,
     1758                .proc_handler   = proc_dointvec_minmax,
     1759                .extra1         = &one,
    17511760        },
    17521761        { }
  • src/linux/universal/linux-4.4/net/ipv4/ping.c

    r31421 r31923  
    155155{
    156156        struct inet_sock *isk = inet_sk(sk);
     157
    157158        pr_debug("ping_unhash(isk=%p,isk->num=%u)\n", isk, isk->inet_num);
     159        write_lock_bh(&ping_table.lock);
    158160        if (sk_hashed(sk)) {
    159                 write_lock_bh(&ping_table.lock);
    160161                hlist_nulls_del(&sk->sk_nulls_node);
    161162                sk_nulls_node_init(&sk->sk_nulls_node);
     
    164165                isk->inet_sport = 0;
    165166                sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
    166                 write_unlock_bh(&ping_table.lock);
    167         }
     167        }
     168        write_unlock_bh(&ping_table.lock);
    168169}
    169170EXPORT_SYMBOL_GPL(ping_unhash);
  • src/linux/universal/linux-4.4/net/netfilter/nfnetlink.c

    r28606 r31923  
    327327                err = 0;
    328328
    329                 if (nlmsg_len(nlh) < sizeof(struct nfgenmsg) ||
    330                     skb->len < nlh->nlmsg_len) {
    331                         err = -EINVAL;
    332                         goto ack;
     329                if (nlh->nlmsg_len < NLMSG_HDRLEN ||
     330                    skb->len < nlh->nlmsg_len ||
     331                    nlmsg_len(nlh) < sizeof(struct nfgenmsg)) {
     332                        nfnl_err_reset(&err_list);
     333                        status |= NFNL_BATCH_FAILURE;
     334                        goto done;
    333335                }
    334336
  • src/linux/universal/linux-4.4/net/tipc/bearer.c

    r28606 r31923  
    382382        if (!dev)
    383383                return -ENODEV;
     384        if (tipc_mtu_bad(dev, 0)) {
     385                dev_put(dev);
     386                return -EINVAL;
     387        }
    384388
    385389        /* Associate TIPC bearer with L2 bearer */
     
    571575                return NOTIFY_DONE;
    572576
    573         b_ptr->mtu = dev->mtu;
    574 
    575577        switch (evt) {
    576578        case NETDEV_CHANGE:
     
    578580                        break;
    579581        case NETDEV_GOING_DOWN:
     582                tipc_reset_bearer(net, b_ptr);
     583                break;
    580584        case NETDEV_CHANGEMTU:
     585                if (tipc_mtu_bad(dev, 0)) {
     586                        bearer_disable(net, b_ptr);
     587                        break;
     588                }
     589                b_ptr->mtu = dev->mtu;
    581590                tipc_reset_bearer(net, b_ptr);
    582591                break;
  • src/linux/universal/linux-4.4/net/tipc/bearer.h

    r28606 r31923  
    4040#include "netlink.h"
    4141#include "core.h"
     42#include "msg.h"
    4243#include <net/genetlink.h>
    4344
     
    6162#define TIPC_MEDIA_TYPE_IB      2
    6263#define TIPC_MEDIA_TYPE_UDP     3
     64
     65/* minimum bearer MTU */
     66#define TIPC_MIN_BEARER_MTU     (MAX_H_SIZE + INT_H_SIZE)
    6367
    6468/**
     
    227231                         struct sk_buff_head *xmitq);
    228232
     233/* check if device MTU is too low for tipc headers */
     234static inline bool tipc_mtu_bad(struct net_device *dev, unsigned int reserve)
     235{
     236        if (dev->mtu >= TIPC_MIN_BEARER_MTU + reserve)
     237                return false;
     238        netdev_warn(dev, "MTU too low for tipc bearer\n");
     239        return true;
     240}
     241
    229242#endif  /* _TIPC_BEARER_H */
  • src/linux/universal/linux-4.4/net/tipc/core.c

    r28606 r31923  
    7070                goto out_nametbl;
    7171
     72        INIT_LIST_HEAD(&tn->dist_queue);
    7273        err = tipc_topsrv_start(net);
    7374        if (err)
  • src/linux/universal/linux-4.4/net/tipc/core.h

    r28606 r31923  
    104104        struct name_table *nametbl;
    105105
     106        /* Name dist queue */
     107        struct list_head dist_queue;
     108
    106109        /* Topology subscription server */
    107110        struct tipc_server *topsrv;
  • src/linux/universal/linux-4.4/net/tipc/name_distr.c

    r30691 r31923  
    4141int sysctl_tipc_named_timeout __read_mostly = 2000;
    4242
    43 /**
    44  * struct tipc_dist_queue - queue holding deferred name table updates
    45  */
    46 static struct list_head tipc_dist_queue = LIST_HEAD_INIT(tipc_dist_queue);
    47 
    4843struct distr_queue_item {
    4944        struct distr_item i;
     
    6863/**
    6964 * named_prepare_buf - allocate & initialize a publication message
     65 *
     66 * The buffer returned is of size INT_H_SIZE + payload size
    7067 */
    7168static struct sk_buff *named_prepare_buf(struct net *net, u32 type, u32 size,
     
    172169        struct sk_buff *skb = NULL;
    173170        struct distr_item *item = NULL;
    174         uint msg_dsz = (tipc_node_get_mtu(net, dnode, 0) / ITEM_SIZE) *
    175                         ITEM_SIZE;
    176         uint msg_rem = msg_dsz;
     171        u32 msg_dsz = ((tipc_node_get_mtu(net, dnode, 0) - INT_H_SIZE) /
     172                        ITEM_SIZE) * ITEM_SIZE;
     173        u32 msg_rem = msg_dsz;
    177174
    178175        list_for_each_entry(publ, pls, local_list) {
     
    341338 *
    342339 */
    343 static void tipc_named_add_backlog(struct distr_item *i, u32 type, u32 node)
     340static void tipc_named_add_backlog(struct net *net, struct distr_item *i,
     341                                   u32 type, u32 node)
    344342{
    345343        struct distr_queue_item *e;
     344        struct tipc_net *tn = net_generic(net, tipc_net_id);
    346345        unsigned long now = get_jiffies_64();
    347346
     
    353352        e->expires = now + msecs_to_jiffies(sysctl_tipc_named_timeout);
    354353        memcpy(e, i, sizeof(*i));
    355         list_add_tail(&e->next, &tipc_dist_queue);
     354        list_add_tail(&e->next, &tn->dist_queue);
    356355}
    357356
     
    363362{
    364363        struct distr_queue_item *e, *tmp;
     364        struct tipc_net *tn = net_generic(net, tipc_net_id);
    365365        char addr[16];
    366366        unsigned long now = get_jiffies_64();
    367367
    368         list_for_each_entry_safe(e, tmp, &tipc_dist_queue, next) {
     368        list_for_each_entry_safe(e, tmp, &tn->dist_queue, next) {
    369369                if (time_after(e->expires, now)) {
    370370                        if (!tipc_update_nametbl(net, &e->i, e->node, e->dtype))
     
    406406                while (count--) {
    407407                        if (!tipc_update_nametbl(net, item, node, mtype))
    408                                 tipc_named_add_backlog(item, mtype, node);
     408                                tipc_named_add_backlog(net, item, mtype, node);
    409409                        item++;
    410410                }
  • src/linux/universal/linux-4.4/net/tipc/node.c

    r31916 r31923  
    729729                        break;
    730730                case SELF_LOST_CONTACT_EVT:
    731                         state = SELF_DOWN_PEER_LEAVING;
     731                        state = SELF_DOWN_PEER_DOWN;
    732732                        break;
    733733                case SELF_ESTABL_CONTACT_EVT:
     
    748748                        break;
    749749                case PEER_LOST_CONTACT_EVT:
    750                         state = SELF_LEAVING_PEER_DOWN;
     750                        state = SELF_DOWN_PEER_DOWN;
    751751                        break;
    752752                case SELF_LOST_CONTACT_EVT:
  • src/linux/universal/linux-4.4/net/tipc/socket.c

    r30708 r31923  
    778778 * @skb: pointer to message buffer.
    779779 */
    780 static void tipc_sk_proto_rcv(struct tipc_sock *tsk, struct sk_buff *skb)
     780static void tipc_sk_proto_rcv(struct tipc_sock *tsk, struct sk_buff *skb,
     781                              struct sk_buff_head *xmitq)
    781782{
    782783        struct sock *sk = &tsk->sk;
     784        u32 onode = tsk_own_node(tsk);
    783785        struct tipc_msg *hdr = buf_msg(skb);
    784786        int mtyp = msg_type(hdr);
     
    793795        if (mtyp == CONN_PROBE) {
    794796                msg_set_type(hdr, CONN_PROBE_REPLY);
    795                 tipc_sk_respond(sk, skb, TIPC_OK);
     797                if (tipc_msg_reverse(onode, &skb, TIPC_OK))
     798                        __skb_queue_tail(xmitq, skb);
    796799                return;
    797800        } else if (mtyp == CONN_ACK) {
     
    16481651 * Returns true if message was added to socket receive queue, otherwise false
    16491652 */
    1650 static bool filter_rcv(struct sock *sk, struct sk_buff *skb)
     1653static bool filter_rcv(struct sock *sk, struct sk_buff *skb,
     1654                       struct sk_buff_head *xmitq)
    16511655{
    16521656        struct socket *sock = sk->sk_socket;
     
    16581662
    16591663        if (unlikely(msg_user(hdr) == CONN_MANAGER)) {
    1660                 tipc_sk_proto_rcv(tsk, skb);
     1664                tipc_sk_proto_rcv(tsk, skb, xmitq);
    16611665                return false;
    16621666        }
     
    17011705
    17021706reject:
    1703         tipc_sk_respond(sk, skb, err);
     1707        if (tipc_msg_reverse(tsk_own_node(tsk), &skb, err))
     1708                __skb_queue_tail(xmitq, skb);
    17041709        return false;
    17051710}
     
    17171722{
    17181723        unsigned int truesize = skb->truesize;
    1719 
    1720         if (likely(filter_rcv(sk, skb)))
     1724        struct sk_buff_head xmitq;
     1725        u32 dnode, selector;
     1726
     1727        __skb_queue_head_init(&xmitq);
     1728
     1729        if (likely(filter_rcv(sk, skb, &xmitq))) {
    17211730                atomic_add(truesize, &tipc_sk(sk)->dupl_rcvcnt);
     1731                return 0;
     1732        }
     1733
     1734        if (skb_queue_empty(&xmitq))
     1735                return 0;
     1736
     1737        /* Send response/rejected message */
     1738        skb = __skb_dequeue(&xmitq);
     1739        dnode = msg_destnode(buf_msg(skb));
     1740        selector = msg_origport(buf_msg(skb));
     1741        tipc_node_xmit_skb(sock_net(sk), skb, dnode, selector);
    17221742        return 0;
    17231743}
     
    17331753 */
    17341754static void tipc_sk_enqueue(struct sk_buff_head *inputq, struct sock *sk,
    1735                             u32 dport)
    1736 {
     1755                            u32 dport, struct sk_buff_head *xmitq)
     1756{
     1757        unsigned long time_limit = jiffies + 2;
     1758        struct sk_buff *skb;
    17371759        unsigned int lim;
    17381760        atomic_t *dcnt;
    1739         struct sk_buff *skb;
    1740         unsigned long time_limit = jiffies + 2;
     1761        u32 onode;
    17411762
    17421763        while (skb_queue_len(inputq)) {
     
    17501771                /* Add message directly to receive queue if possible */
    17511772                if (!sock_owned_by_user(sk)) {
    1752                         filter_rcv(sk, skb);
     1773                        filter_rcv(sk, skb, xmitq);
    17531774                        continue;
    17541775                }
     
    17561777                /* Try backlog, compensating for double-counted bytes */
    17571778                dcnt = &tipc_sk(sk)->dupl_rcvcnt;
    1758                 if (sk->sk_backlog.len)
     1779                if (!sk->sk_backlog.len)
    17591780                        atomic_set(dcnt, 0);
    17601781                lim = rcvbuf_limit(sk, skb) + atomic_read(dcnt);
     
    17631784
    17641785                /* Overload => reject message back to sender */
    1765                 tipc_sk_respond(sk, skb, TIPC_ERR_OVERLOAD);
     1786                onode = tipc_own_addr(sock_net(sk));
     1787                if (tipc_msg_reverse(onode, &skb, TIPC_ERR_OVERLOAD))
     1788                        __skb_queue_tail(xmitq, skb);
    17661789                break;
    17671790        }
     
    17761799void tipc_sk_rcv(struct net *net, struct sk_buff_head *inputq)
    17771800{
     1801        struct sk_buff_head xmitq;
    17781802        u32 dnode, dport = 0;
    17791803        int err;
     
    17821806        struct sk_buff *skb;
    17831807
     1808        __skb_queue_head_init(&xmitq);
    17841809        while (skb_queue_len(inputq)) {
    17851810                dport = tipc_skb_peek_port(inputq, dport);
     
    17891814                        sk = &tsk->sk;
    17901815                        if (likely(spin_trylock_bh(&sk->sk_lock.slock))) {
    1791                                 tipc_sk_enqueue(inputq, sk, dport);
     1816                                tipc_sk_enqueue(inputq, sk, dport, &xmitq);
    17921817                                spin_unlock_bh(&sk->sk_lock.slock);
     1818                        }
     1819                        /* Send pending response/rejected messages, if any */
     1820                        while ((skb = __skb_dequeue(&xmitq))) {
     1821                                dnode = msg_destnode(buf_msg(skb));
     1822                                tipc_node_xmit_skb(net, skb, dnode, dport);
    17931823                        }
    17941824                        sock_put(sk);
  • src/linux/universal/linux-4.4/net/tipc/udp_media.c

    r30691 r31923  
    5353#define UDP_PORT_DEFAULT        6118
    5454
    55 #define UDP_MIN_HEADROOM        28
     55#define UDP_MIN_HEADROOM        48
    5656
    5757static const struct nla_policy tipc_nl_udp_policy[TIPC_NLA_UDP_MAX + 1] = {
     
    377377                udp_conf.use_udp_checksums = false;
    378378                ub->ifindex = dev->ifindex;
     379                if (tipc_mtu_bad(dev, sizeof(struct iphdr) +
     380                                      sizeof(struct udphdr))) {
     381                        err = -EINVAL;
     382                        goto err;
     383                }
    379384                b->mtu = dev->mtu - sizeof(struct iphdr)
    380385                        - sizeof(struct udphdr);
Note: See TracChangeset for help on using the changeset viewer.