Changeset 31884


Ignore:
Timestamp:
Apr 18, 2017, 8:47:31 AM (10 days ago)
Author:
brainslayer
Message:

update kernels

Location:
src/linux/universal
Files:
58 edited

Legend:

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

    r31869 r31884  
    22PATCHLEVEL = 18
    33SUBLEVEL = 49
    4 EXTRAVERSION = -rc1
     4EXTRAVERSION =
    55NAME = Diseased Newt
    66
  • src/linux/universal/linux-3.18/drivers/input/serio/gscps2.c

    r25370 r31884  
    4141MODULE_DESCRIPTION("HP GSC PS2 port driver");
    4242MODULE_LICENSE("GPL");
    43 MODULE_DEVICE_TABLE(parisc, gscps2_device_tbl);
    4443
    4544#define PFX "gscps2.c: "
     
    440439        { 0, }  /* 0 terminated list */
    441440};
     441MODULE_DEVICE_TABLE(parisc, gscps2_device_tbl);
    442442
    443443static struct parisc_driver parisc_ps2_driver = {
  • src/linux/universal/linux-4.4/Makefile

    r31859 r31884  
    11VERSION = 4
    22PATCHLEVEL = 4
    3 SUBLEVEL = 61
     3SUBLEVEL = 62
    44EXTRAVERSION =
    55NAME = Blurry Fish Butt
  • src/linux/universal/linux-4.4/arch/mips/Kconfig

    r31859 r31884  
    1010        select HAVE_GENERIC_DMA_COHERENT
    1111        select HAVE_IDE
     12        select HAVE_IRQ_EXIT_ON_IRQ_STACK
    1213        select HAVE_OPROFILE
    1314        select HAVE_PERF_EVENTS
  • src/linux/universal/linux-4.4/arch/mips/include/asm/irq.h

    r28606 r31884  
    1717
    1818#include <irq.h>
     19
     20#define IRQ_STACK_SIZE                  THREAD_SIZE
     21
     22extern void *irq_stack[NR_CPUS];
     23
     24static inline bool on_irq_stack(int cpu, unsigned long sp)
     25{
     26        unsigned long low = (unsigned long)irq_stack[cpu];
     27        unsigned long high = low + IRQ_STACK_SIZE;
     28
     29        return (low <= sp && sp <= high);
     30}
    1931
    2032#ifdef CONFIG_I8259
  • src/linux/universal/linux-4.4/arch/mips/include/asm/stackframe.h

    r28606 r31884  
    217217                LONG_S  $28, PT_R28(sp)
    218218                LONG_S  $31, PT_R31(sp)
     219
     220                /* Set thread_info if we're coming from user mode */
     221                mfc0    k0, CP0_STATUS
     222                sll     k0, 3           /* extract cu0 bit */
     223                bltz    k0, 9f
     224
    219225                ori     $28, sp, _THREAD_MASK
    220226                xori    $28, _THREAD_MASK
     
    223229                pref    0, 0($28)       /* Prefetch the current pointer */
    224230#endif
     2319:
    225232                .set    pop
    226233                .endm
  • src/linux/universal/linux-4.4/arch/mips/kernel/asm-offsets.c

    r28606 r31884  
    102102        DEFINE(_THREAD_SIZE, THREAD_SIZE);
    103103        DEFINE(_THREAD_MASK, THREAD_MASK);
     104        DEFINE(_IRQ_STACK_SIZE, IRQ_STACK_SIZE);
    104105        BLANK();
    105106}
  • src/linux/universal/linux-4.4/arch/mips/kernel/genex.S

    r28606 r31884  
    208208        LONG_L  s0, TI_REGS($28)
    209209        LONG_S  sp, TI_REGS($28)
    210         PTR_LA  ra, ret_from_irq
    211         PTR_LA  v0, plat_irq_dispatch
    212         jr      v0
     210
     211        /*
     212         * SAVE_ALL ensures we are using a valid kernel stack for the thread.
     213         * Check if we are already using the IRQ stack.
     214         */
     215        move    s1, sp # Preserve the sp
     216
     217        /* Get IRQ stack for this CPU */
     218        ASM_CPUID_MFC0  k0, ASM_SMP_CPUID_REG
     219#if defined(CONFIG_32BIT) || defined(KBUILD_64BIT_SYM32)
     220        lui     k1, %hi(irq_stack)
     221#else
     222        lui     k1, %highest(irq_stack)
     223        daddiu  k1, %higher(irq_stack)
     224        dsll    k1, 16
     225        daddiu  k1, %hi(irq_stack)
     226        dsll    k1, 16
     227#endif
     228        LONG_SRL        k0, SMP_CPUID_PTRSHIFT
     229        LONG_ADDU       k1, k0
     230        LONG_L  t0, %lo(irq_stack)(k1)
     231
     232        # Check if already on IRQ stack
     233        PTR_LI  t1, ~(_THREAD_SIZE-1)
     234        and     t1, t1, sp
     235        beq     t0, t1, 2f
     236
     237        /* Switch to IRQ stack */
     238        li      t1, _IRQ_STACK_SIZE
     239        PTR_ADD sp, t0, t1
     240
     2412:
     242        jal     plat_irq_dispatch
     243
     244        /* Restore sp */
     245        move    sp, s1
     246
     247        j       ret_from_irq
    213248#ifdef CONFIG_CPU_MICROMIPS
    214249        nop
     
    283318        LONG_L  s0, TI_REGS($28)
    284319        LONG_S  sp, TI_REGS($28)
    285         PTR_LA  ra, ret_from_irq
    286         jr      v0
     320
     321        /*
     322         * SAVE_ALL ensures we are using a valid kernel stack for the thread.
     323         * Check if we are already using the IRQ stack.
     324         */
     325        move    s1, sp # Preserve the sp
     326
     327        /* Get IRQ stack for this CPU */
     328        ASM_CPUID_MFC0  k0, ASM_SMP_CPUID_REG
     329#if defined(CONFIG_32BIT) || defined(KBUILD_64BIT_SYM32)
     330        lui     k1, %hi(irq_stack)
     331#else
     332        lui     k1, %highest(irq_stack)
     333        daddiu  k1, %higher(irq_stack)
     334        dsll    k1, 16
     335        daddiu  k1, %hi(irq_stack)
     336        dsll    k1, 16
     337#endif
     338        LONG_SRL        k0, SMP_CPUID_PTRSHIFT
     339        LONG_ADDU       k1, k0
     340        LONG_L  t0, %lo(irq_stack)(k1)
     341
     342        # Check if already on IRQ stack
     343        PTR_LI  t1, ~(_THREAD_SIZE-1)
     344        and     t1, t1, sp
     345        beq     t0, t1, 2f
     346
     347        /* Switch to IRQ stack */
     348        li      t1, _IRQ_STACK_SIZE
     349        PTR_ADD sp, t0, t1
     350
     3512:
     352        jalr    v0
     353
     354        /* Restore sp */
     355        move    sp, s1
     356
     357        j       ret_from_irq
    287358        END(except_vec_vi_handler)
    288359
  • src/linux/universal/linux-4.4/arch/mips/kernel/irq.c

    r28606 r31884  
    2525#include <linux/atomic.h>
    2626#include <asm/uaccess.h>
     27
     28void *irq_stack[NR_CPUS];
    2729
    2830/*
     
    5658
    5759        arch_init_irq();
     60
     61        for_each_possible_cpu(i) {
     62                int irq_pages = IRQ_STACK_SIZE / PAGE_SIZE;
     63                void *s = (void *)__get_free_pages(GFP_KERNEL, irq_pages);
     64
     65                irq_stack[i] = s;
     66                pr_debug("CPU%d IRQ stack at 0x%p - 0x%p\n", i,
     67                        irq_stack[i], irq_stack[i] + IRQ_STACK_SIZE);
     68        }
    5869}
    5970
  • src/linux/universal/linux-4.4/arch/mips/kernel/process.c

    r31632 r31884  
    3333#include <asm/dsp.h>
    3434#include <asm/fpu.h>
     35#include <asm/irq.h>
    3536#include <asm/msa.h>
    3637#include <asm/pgtable.h>
     
    553554                           unsigned long pc, unsigned long *ra)
    554555{
    555         unsigned long stack_page = (unsigned long)task_stack_page(task);
     556        unsigned long stack_page = 0;
     557        int cpu;
     558
     559        for_each_possible_cpu(cpu) {
     560                if (on_irq_stack(cpu, *sp)) {
     561                        stack_page = (unsigned long)irq_stack[cpu];
     562                        break;
     563                }
     564        }
     565
     566        if (!stack_page)
     567                stack_page = (unsigned long)task_stack_page(task);
     568
    556569        return unwind_stack_by_address(stack_page, sp, pc, ra);
    557570}
  • src/linux/universal/linux-4.4/block/blk-mq.c

    r31506 r31884  
    14711471
    14721472        tags->rqs = kzalloc_node(set->queue_depth * sizeof(struct request *),
    1473                                  GFP_KERNEL | __GFP_NOWARN | __GFP_NORETRY,
     1473                                 GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY,
    14741474                                 set->numa_node);
    14751475        if (!tags->rqs) {
     
    14971497                do {
    14981498                        page = alloc_pages_node(set->numa_node,
    1499                                 GFP_KERNEL | __GFP_NOWARN | __GFP_NORETRY | __GFP_ZERO,
     1499                                GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY | __GFP_ZERO,
    15001500                                this_order);
    15011501                        if (page)
     
    15181518                 * to additional allocations like via ops->init_request().
    15191519                 */
    1520                 kmemleak_alloc(p, order_to_size(this_order), 1, GFP_KERNEL);
     1520                kmemleak_alloc(p, order_to_size(this_order), 1, GFP_NOIO);
    15211521                entries_per_page = order_to_size(this_order) / rq_size;
    15221522                to_do = min(entries_per_page, set->queue_depth - i);
  • src/linux/universal/linux-4.4/drivers/crypto/caam/ctrl.c

    r29088 r31884  
    279279                        ret = run_descriptor_deco0(ctrldev, desc, &status);
    280280
    281                         if (ret || status) {
     281                        if (ret ||
     282                            (status && status != JRSTA_SSRC_JUMP_HALT_CC)) {
    282283                                dev_err(ctrldev,
    283284                                        "Failed to deinstantiate RNG4 SH%d\n",
  • src/linux/universal/linux-4.4/drivers/gpu/drm/i915/i915_drv.h

    r30821 r31884  
    11601160
    11611161        /* manual wa residency calculations */
    1162         struct intel_rps_ei up_ei, down_ei;
     1162        struct intel_rps_ei ei;
    11631163
    11641164        /*
  • src/linux/universal/linux-4.4/drivers/gpu/drm/i915/i915_irq.c

    r29197 r31884  
    995995}
    996996
    997 static bool vlv_c0_above(struct drm_i915_private *dev_priv,
    998                          const struct intel_rps_ei *old,
    999                          const struct intel_rps_ei *now,
    1000                          int threshold)
    1001 {
    1002         u64 time, c0;
    1003         unsigned int mul = 100;
    1004 
    1005         if (old->cz_clock == 0)
    1006                 return false;
    1007 
    1008         if (I915_READ(VLV_COUNTER_CONTROL) & VLV_COUNT_RANGE_HIGH)
    1009                 mul <<= 8;
    1010 
    1011         time = now->cz_clock - old->cz_clock;
    1012         time *= threshold * dev_priv->czclk_freq;
    1013 
    1014         /* Workload can be split between render + media, e.g. SwapBuffers
    1015          * being blitted in X after being rendered in mesa. To account for
    1016          * this we need to combine both engines into our activity counter.
    1017          */
    1018         c0 = now->render_c0 - old->render_c0;
    1019         c0 += now->media_c0 - old->media_c0;
    1020         c0 *= mul * VLV_CZ_CLOCK_TO_MILLI_SEC;
    1021 
    1022         return c0 >= time;
    1023 }
    1024 
    1025997void gen6_rps_reset_ei(struct drm_i915_private *dev_priv)
    1026998{
    1027         vlv_c0_read(dev_priv, &dev_priv->rps.down_ei);
    1028         dev_priv->rps.up_ei = dev_priv->rps.down_ei;
     999        memset(&dev_priv->rps.ei, 0, sizeof(dev_priv->rps.ei));
    10291000}
    10301001
    10311002static u32 vlv_wa_c0_ei(struct drm_i915_private *dev_priv, u32 pm_iir)
    10321003{
     1004        const struct intel_rps_ei *prev = &dev_priv->rps.ei;
    10331005        struct intel_rps_ei now;
    10341006        u32 events = 0;
    10351007
    1036         if ((pm_iir & (GEN6_PM_RP_DOWN_EI_EXPIRED | GEN6_PM_RP_UP_EI_EXPIRED)) == 0)
     1008        if ((pm_iir & GEN6_PM_RP_UP_EI_EXPIRED) == 0)
    10371009                return 0;
    10381010
     
    10411013                return 0;
    10421014
    1043         if (pm_iir & GEN6_PM_RP_DOWN_EI_EXPIRED) {
    1044                 if (!vlv_c0_above(dev_priv,
    1045                                   &dev_priv->rps.down_ei, &now,
    1046                                   dev_priv->rps.down_threshold))
    1047                         events |= GEN6_PM_RP_DOWN_THRESHOLD;
    1048                 dev_priv->rps.down_ei = now;
    1049         }
    1050 
    1051         if (pm_iir & GEN6_PM_RP_UP_EI_EXPIRED) {
    1052                 if (vlv_c0_above(dev_priv,
    1053                                  &dev_priv->rps.up_ei, &now,
    1054                                  dev_priv->rps.up_threshold))
    1055                         events |= GEN6_PM_RP_UP_THRESHOLD;
    1056                 dev_priv->rps.up_ei = now;
    1057         }
    1058 
     1015        if (prev->cz_clock) {
     1016                u64 time, c0;
     1017                unsigned int mul;
     1018
     1019                mul = VLV_CZ_CLOCK_TO_MILLI_SEC * 100; /* scale to threshold% */
     1020                if (I915_READ(VLV_COUNTER_CONTROL) & VLV_COUNT_RANGE_HIGH)
     1021                        mul <<= 8;
     1022
     1023                time = now.cz_clock - prev->cz_clock;
     1024                time *= dev_priv->czclk_freq;
     1025
     1026                /* Workload can be split between render + media,
     1027                 * e.g. SwapBuffers being blitted in X after being rendered in
     1028                 * mesa. To account for this we need to combine both engines
     1029                 * into our activity counter.
     1030                 */
     1031                c0 = now.render_c0 - prev->render_c0;
     1032                c0 += now.media_c0 - prev->media_c0;
     1033                c0 *= mul;
     1034
     1035                if (c0 > time * dev_priv->rps.up_threshold)
     1036                        events = GEN6_PM_RP_UP_THRESHOLD;
     1037                else if (c0 < time * dev_priv->rps.down_threshold)
     1038                        events = GEN6_PM_RP_DOWN_THRESHOLD;
     1039        }
     1040
     1041        dev_priv->rps.ei = now;
    10591042        return events;
    10601043}
     
    43914374        if (IS_VALLEYVIEW(dev_priv) && !IS_CHERRYVIEW(dev_priv))
    43924375                /* WaGsvRC0ResidencyMethod:vlv */
    4393                 dev_priv->pm_rps_events = GEN6_PM_RP_DOWN_EI_EXPIRED | GEN6_PM_RP_UP_EI_EXPIRED;
     4376                dev_priv->pm_rps_events = GEN6_PM_RP_UP_EI_EXPIRED;
    43944377        else
    43954378                dev_priv->pm_rps_events = GEN6_PM_RPS_EVENTS;
  • src/linux/universal/linux-4.4/drivers/gpu/drm/i915/intel_pm.c

    r31662 r31884  
    43774377        }
    43784378
     4379        /* When byt can survive without system hang with dynamic
     4380         * sw freq adjustments, this restriction can be lifted.
     4381         */
     4382        if (IS_VALLEYVIEW(dev_priv))
     4383                goto skip_hw_write;
     4384
    43794385        I915_WRITE(GEN6_RP_UP_EI,
    43804386                GT_INTERVAL_FROM_US(dev_priv, ei_up));
     
    43954401                    GEN6_RP_DOWN_IDLE_AVG);
    43964402
     4403skip_hw_write:
    43974404        dev_priv->rps.power = new_power;
    43984405        dev_priv->rps.up_threshold = threshold_up;
     
    44054412        u32 mask = 0;
    44064413
     4414        /* We use UP_EI_EXPIRED interupts for both up/down in manual mode */
    44074415        if (val > dev_priv->rps.min_freq_softlimit)
    4408                 mask |= GEN6_PM_RP_DOWN_EI_EXPIRED | GEN6_PM_RP_DOWN_THRESHOLD | GEN6_PM_RP_DOWN_TIMEOUT;
     4416                mask |= GEN6_PM_RP_UP_EI_EXPIRED | GEN6_PM_RP_DOWN_THRESHOLD | GEN6_PM_RP_DOWN_TIMEOUT;
    44094417        if (val < dev_priv->rps.max_freq_softlimit)
    44104418                mask |= GEN6_PM_RP_UP_EI_EXPIRED | GEN6_PM_RP_UP_THRESHOLD;
     
    45104518        mutex_lock(&dev_priv->rps.hw_lock);
    45114519        if (dev_priv->rps.enabled) {
    4512                 if (dev_priv->pm_rps_events & (GEN6_PM_RP_DOWN_EI_EXPIRED | GEN6_PM_RP_UP_EI_EXPIRED))
     4520                if (dev_priv->pm_rps_events & GEN6_PM_RP_UP_EI_EXPIRED)
    45134521                        gen6_rps_reset_ei(dev_priv);
    45144522                I915_WRITE(GEN6_PMINTRMSK,
  • src/linux/universal/linux-4.4/drivers/mtd/bcm47xxpart.c

    r28606 r31884  
    226226                        last_trx_part = curr_part - 1;
    227227
    228                         /*
    229                          * We have whole TRX scanned, skip to the next part. Use
    230                          * roundown (not roundup), as the loop will increase
    231                          * offset in next step.
    232                          */
    233                         offset = rounddown(offset + trx->length, blocksize);
     228                        /* Jump to the end of TRX */
     229                        offset = roundup(offset + trx->length, blocksize);
     230                        /* Next loop iteration will increase the offset */
     231                        offset -= blocksize;
    234232                        continue;
    235233                }
  • src/linux/universal/linux-4.4/drivers/net/ethernet/ibm/ibmveth.c

    r28606 r31884  
    5959static const char ibmveth_driver_name[] = "ibmveth";
    6060static const char ibmveth_driver_string[] = "IBM Power Virtual Ethernet Driver";
    61 #define ibmveth_driver_version "1.05"
     61#define ibmveth_driver_version "1.06"
    6262
    6363MODULE_AUTHOR("Santiago Leon <santil@linux.vnet.ibm.com>");
     
    138138}
    139139
     140static inline int ibmveth_rxq_large_packet(struct ibmveth_adapter *adapter)
     141{
     142        return ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_LRG_PKT;
     143}
     144
    140145static inline int ibmveth_rxq_frame_length(struct ibmveth_adapter *adapter)
    141146{
     
    11731178}
    11741179
     1180static void ibmveth_rx_mss_helper(struct sk_buff *skb, u16 mss, int lrg_pkt)
     1181{
     1182        int offset = 0;
     1183
     1184        /* only TCP packets will be aggregated */
     1185        if (skb->protocol == htons(ETH_P_IP)) {
     1186                struct iphdr *iph = (struct iphdr *)skb->data;
     1187
     1188                if (iph->protocol == IPPROTO_TCP) {
     1189                        offset = iph->ihl * 4;
     1190                        skb_shinfo(skb)->gso_type = SKB_GSO_TCPV4;
     1191                } else {
     1192                        return;
     1193                }
     1194        } else if (skb->protocol == htons(ETH_P_IPV6)) {
     1195                struct ipv6hdr *iph6 = (struct ipv6hdr *)skb->data;
     1196
     1197                if (iph6->nexthdr == IPPROTO_TCP) {
     1198                        offset = sizeof(struct ipv6hdr);
     1199                        skb_shinfo(skb)->gso_type = SKB_GSO_TCPV6;
     1200                } else {
     1201                        return;
     1202                }
     1203        } else {
     1204                return;
     1205        }
     1206        /* if mss is not set through Large Packet bit/mss in rx buffer,
     1207         * expect that the mss will be written to the tcp header checksum.
     1208         */
     1209        if (lrg_pkt) {
     1210                skb_shinfo(skb)->gso_size = mss;
     1211        } else if (offset) {
     1212                struct tcphdr *tcph = (struct tcphdr *)(skb->data + offset);
     1213
     1214                skb_shinfo(skb)->gso_size = ntohs(tcph->check);
     1215                tcph->check = 0;
     1216        }
     1217}
     1218
    11751219static int ibmveth_poll(struct napi_struct *napi, int budget)
    11761220{
     
    11811225        unsigned long lpar_rc;
    11821226        struct iphdr *iph;
     1227        u16 mss = 0;
    11831228
    11841229restart_poll:
     
    11981243                        int offset = ibmveth_rxq_frame_offset(adapter);
    11991244                        int csum_good = ibmveth_rxq_csum_good(adapter);
     1245                        int lrg_pkt = ibmveth_rxq_large_packet(adapter);
    12001246
    12011247                        skb = ibmveth_rxq_get_buffer(adapter);
     1248
     1249                        /* if the large packet bit is set in the rx queue
     1250                         * descriptor, the mss will be written by PHYP eight
     1251                         * bytes from the start of the rx buffer, which is
     1252                         * skb->data at this stage
     1253                         */
     1254                        if (lrg_pkt) {
     1255                                __be64 *rxmss = (__be64 *)(skb->data + 8);
     1256
     1257                                mss = (u16)be64_to_cpu(*rxmss);
     1258                        }
    12021259
    12031260                        new_skb = NULL;
     
    12341291                                                iph->check = 0;
    12351292                                                iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);
    1236                                                 adapter->rx_large_packets++;
    12371293                                        }
    12381294                                }
     1295                        }
     1296
     1297                        if (length > netdev->mtu + ETH_HLEN) {
     1298                                ibmveth_rx_mss_helper(skb, mss, lrg_pkt);
     1299                                adapter->rx_large_packets++;
    12391300                        }
    12401301
  • src/linux/universal/linux-4.4/drivers/net/ethernet/ibm/ibmveth.h

    r28606 r31884  
    210210#define IBMVETH_RXQ_TOGGLE_SHIFT        31
    211211#define IBMVETH_RXQ_VALID               0x40000000
     212#define IBMVETH_RXQ_LRG_PKT             0x04000000
    212213#define IBMVETH_RXQ_NO_CSUM             0x02000000
    213214#define IBMVETH_RXQ_CSUM_GOOD           0x01000000
  • src/linux/universal/linux-4.4/drivers/net/ethernet/mellanox/mlx4/cq.c

    r28606 r31884  
    102102        struct mlx4_cq *cq;
    103103
     104        rcu_read_lock();
    104105        cq = radix_tree_lookup(&mlx4_priv(dev)->cq_table.tree,
    105106                               cqn & (dev->caps.num_cqs - 1));
     107        rcu_read_unlock();
     108
    106109        if (!cq) {
    107110                mlx4_dbg(dev, "Completion event for bogus CQ %08x\n", cqn);
     
    109112        }
    110113
     114        /* Acessing the CQ outside of rcu_read_lock is safe, because
     115         * the CQ is freed only after interrupt handling is completed.
     116         */
    111117        ++cq->arm_sn;
    112118
     
    119125        struct mlx4_cq *cq;
    120126
    121         spin_lock(&cq_table->lock);
    122 
     127        rcu_read_lock();
    123128        cq = radix_tree_lookup(&cq_table->tree, cqn & (dev->caps.num_cqs - 1));
    124         if (cq)
    125                 atomic_inc(&cq->refcount);
    126 
    127         spin_unlock(&cq_table->lock);
     129        rcu_read_unlock();
    128130
    129131        if (!cq) {
    130                 mlx4_warn(dev, "Async event for bogus CQ %08x\n", cqn);
     132                mlx4_dbg(dev, "Async event for bogus CQ %08x\n", cqn);
    131133                return;
    132134        }
    133135
     136        /* Acessing the CQ outside of rcu_read_lock is safe, because
     137         * the CQ is freed only after interrupt handling is completed.
     138         */
    134139        cq->event(cq, event_type);
    135 
    136         if (atomic_dec_and_test(&cq->refcount))
    137                 complete(&cq->free);
    138140}
    139141
     
    302304                return err;
    303305
    304         spin_lock_irq(&cq_table->lock);
     306        spin_lock(&cq_table->lock);
    305307        err = radix_tree_insert(&cq_table->tree, cq->cqn, cq);
    306         spin_unlock_irq(&cq_table->lock);
     308        spin_unlock(&cq_table->lock);
    307309        if (err)
    308310                goto err_icm;
     
    348350
    349351err_radix:
    350         spin_lock_irq(&cq_table->lock);
     352        spin_lock(&cq_table->lock);
    351353        radix_tree_delete(&cq_table->tree, cq->cqn);
    352         spin_unlock_irq(&cq_table->lock);
     354        spin_unlock(&cq_table->lock);
    353355
    354356err_icm:
     
    368370        if (err)
    369371                mlx4_warn(dev, "HW2SW_CQ failed (%d) for CQN %06x\n", err, cq->cqn);
     372
     373        spin_lock(&cq_table->lock);
     374        radix_tree_delete(&cq_table->tree, cq->cqn);
     375        spin_unlock(&cq_table->lock);
    370376
    371377        synchronize_irq(priv->eq_table.eq[MLX4_CQ_TO_EQ_VECTOR(cq->vector)].irq);
     
    374380                synchronize_irq(priv->eq_table.eq[MLX4_EQ_ASYNC].irq);
    375381
    376         spin_lock_irq(&cq_table->lock);
    377         radix_tree_delete(&cq_table->tree, cq->cqn);
    378         spin_unlock_irq(&cq_table->lock);
    379 
    380382        if (atomic_dec_and_test(&cq->refcount))
    381383                complete(&cq->free);
  • src/linux/universal/linux-4.4/drivers/net/ethernet/mellanox/mlx4/en_rx.c

    r31421 r31884  
    440440
    441441                ring->stride = stride;
    442                 if (ring->stride <= TXBB_SIZE)
     442                if (ring->stride <= TXBB_SIZE) {
     443                        /* Stamp first unused send wqe */
     444                        __be32 *ptr = (__be32 *)ring->buf;
     445                        __be32 stamp = cpu_to_be32(1 << STAMP_SHIFT);
     446                        *ptr = stamp;
     447                        /* Move pointer to start of rx section */
    443448                        ring->buf += TXBB_SIZE;
     449                }
    444450
    445451                ring->log_stride = ffs(ring->stride) - 1;
  • src/linux/universal/linux-4.4/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c

    r29492 r31884  
    29562956                qp->srq = srq;
    29572957        }
     2958
     2959        /* Save param3 for dynamic changes from VST back to VGT */
     2960        qp->param3 = qpc->param3;
    29582961        put_res(dev, slave, rcqn, RES_CQ);
    29592962        put_res(dev, slave, mtt_base, RES_MTT);
     
    37483751        struct res_qp *qp;
    37493752        u8 orig_sched_queue;
    3750         __be32  orig_param3 = qpc->param3;
    37513753        u8 orig_vlan_control = qpc->pri_path.vlan_control;
    37523754        u8 orig_fvl_rx = qpc->pri_path.fvl_rx;
     
    37903792        if (!err) {
    37913793                qp->sched_queue = orig_sched_queue;
    3792                 qp->param3      = orig_param3;
    37933794                qp->vlan_control = orig_vlan_control;
    37943795                qp->fvl_rx      =  orig_fvl_rx;
  • src/linux/universal/linux-4.4/drivers/usb/core/hub.c

    r31794 r31884  
    26162616                        return ret;
    26172617
    2618                 /* The port state is unknown until the reset completes. */
    2619                 if (!(portstatus & USB_PORT_STAT_RESET))
     2618                /*
     2619                 * The port state is unknown until the reset completes.
     2620                 *
     2621                 * On top of that, some chips may require additional time
     2622                 * to re-establish a connection after the reset is complete,
     2623                 * so also wait for the connection to be re-established.
     2624                 */
     2625                if (!(portstatus & USB_PORT_STAT_RESET) &&
     2626                    (portstatus & USB_PORT_STAT_CONNECTION))
    26202627                        break;
    26212628
  • src/linux/universal/linux-4.4/drivers/usb/dwc3/gadget.c

    r31278 r31884  
    249249{
    250250        struct dwc3                     *dwc = dep->dwc;
     251        unsigned int                    unmap_after_complete = false;
    251252        int                             i;
    252253
     
    273274                req->request.status = status;
    274275
    275         if (dwc->ep0_bounced && dep->number <= 1)
     276        /*
     277         * NOTICE we don't want to unmap before calling ->complete() if we're
     278         * dealing with a bounced ep0 request. If we unmap it here, we would end
     279         * up overwritting the contents of req->buf and this could confuse the
     280         * gadget driver.
     281         */
     282        if (dwc->ep0_bounced && dep->number <= 1) {
    276283                dwc->ep0_bounced = false;
    277 
    278         usb_gadget_unmap_request(&dwc->gadget, &req->request,
    279                         req->direction);
     284                unmap_after_complete = true;
     285        } else {
     286                usb_gadget_unmap_request(&dwc->gadget,
     287                                &req->request, req->direction);
     288        }
    280289
    281290        dev_dbg(dwc->dev, "request %p from %s completed %d/%d ===> %d\n",
     
    287296        usb_gadget_giveback_request(&dep->endpoint, &req->request);
    288297        spin_lock(&dwc->lock);
     298
     299        if (unmap_after_complete)
     300                usb_gadget_unmap_request(&dwc->gadget,
     301                                &req->request, req->direction);
    289302}
    290303
  • src/linux/universal/linux-4.4/net/packet/af_packet.c

    r31732 r31884  
    41624162                        goto out;
    41634163                if (po->tp_version >= TPACKET_V3 &&
    4164                     (int)(req->tp_block_size -
    4165                           BLK_PLUS_PRIV(req_u->req3.tp_sizeof_priv)) <= 0)
     4164                    req->tp_block_size <=
     4165                          BLK_PLUS_PRIV((u64)req_u->req3.tp_sizeof_priv))
    41664166                        goto out;
    41674167                if (unlikely(req->tp_frame_size < po->tp_hdrlen +
  • src/linux/universal/linux-4.9/Makefile

    r31859 r31884  
    11VERSION = 4
    22PATCHLEVEL = 9
    3 SUBLEVEL = 22
     3SUBLEVEL = 23
    44EXTRAVERSION =
    55NAME = Roaring Lionus
  • src/linux/universal/linux-4.9/arch/mips/Kconfig

    r31859 r31884  
    1010        select HAVE_GENERIC_DMA_COHERENT
    1111        select HAVE_IDE
     12        select HAVE_IRQ_EXIT_ON_IRQ_STACK
    1213        select HAVE_OPROFILE
    1314        select HAVE_PERF_EVENTS
  • src/linux/universal/linux-4.9/arch/mips/include/asm/irq.h

    r31574 r31884  
    1717
    1818#include <irq.h>
     19
     20#define IRQ_STACK_SIZE                  THREAD_SIZE
     21
     22extern void *irq_stack[NR_CPUS];
     23
     24static inline bool on_irq_stack(int cpu, unsigned long sp)
     25{
     26        unsigned long low = (unsigned long)irq_stack[cpu];
     27        unsigned long high = low + IRQ_STACK_SIZE;
     28
     29        return (low <= sp && sp <= high);
     30}
    1931
    2032#ifdef CONFIG_I8259
  • src/linux/universal/linux-4.9/arch/mips/include/asm/stackframe.h

    r31574 r31884  
    217217                LONG_S  $28, PT_R28(sp)
    218218                LONG_S  $31, PT_R31(sp)
     219
     220                /* Set thread_info if we're coming from user mode */
     221                mfc0    k0, CP0_STATUS
     222                sll     k0, 3           /* extract cu0 bit */
     223                bltz    k0, 9f
     224
    219225                ori     $28, sp, _THREAD_MASK
    220226                xori    $28, _THREAD_MASK
     
    223229                pref    0, 0($28)       /* Prefetch the current pointer */
    224230#endif
     2319:
    225232                .set    pop
    226233                .endm
  • src/linux/universal/linux-4.9/arch/mips/kernel/asm-offsets.c

    r31574 r31884  
    103103        DEFINE(_THREAD_SIZE, THREAD_SIZE);
    104104        DEFINE(_THREAD_MASK, THREAD_MASK);
     105        DEFINE(_IRQ_STACK_SIZE, IRQ_STACK_SIZE);
    105106        BLANK();
    106107}
  • src/linux/universal/linux-4.9/arch/mips/kernel/genex.S

    r31859 r31884  
    207207        LONG_L  s0, TI_REGS($28)
    208208        LONG_S  sp, TI_REGS($28)
    209         PTR_LA  ra, ret_from_irq
    210         PTR_LA  v0, plat_irq_dispatch
    211         jr      v0
     209
     210        /*
     211         * SAVE_ALL ensures we are using a valid kernel stack for the thread.
     212         * Check if we are already using the IRQ stack.
     213         */
     214        move    s1, sp # Preserve the sp
     215
     216        /* Get IRQ stack for this CPU */
     217        ASM_CPUID_MFC0  k0, ASM_SMP_CPUID_REG
     218#if defined(CONFIG_32BIT) || defined(KBUILD_64BIT_SYM32)
     219        lui     k1, %hi(irq_stack)
     220#else
     221        lui     k1, %highest(irq_stack)
     222        daddiu  k1, %higher(irq_stack)
     223        dsll    k1, 16
     224        daddiu  k1, %hi(irq_stack)
     225        dsll    k1, 16
     226#endif
     227        LONG_SRL        k0, SMP_CPUID_PTRSHIFT
     228        LONG_ADDU       k1, k0
     229        LONG_L  t0, %lo(irq_stack)(k1)
     230
     231        # Check if already on IRQ stack
     232        PTR_LI  t1, ~(_THREAD_SIZE-1)
     233        and     t1, t1, sp
     234        beq     t0, t1, 2f
     235
     236        /* Switch to IRQ stack */
     237        li      t1, _IRQ_STACK_SIZE
     238        PTR_ADD sp, t0, t1
     239
     2402:
     241        jal     plat_irq_dispatch
     242
     243        /* Restore sp */
     244        move    sp, s1
     245
     246        j       ret_from_irq
    212247#ifdef CONFIG_CPU_MICROMIPS
    213248        nop
     
    282317        LONG_L  s0, TI_REGS($28)
    283318        LONG_S  sp, TI_REGS($28)
    284         PTR_LA  ra, ret_from_irq
    285         jr      v0
     319
     320        /*
     321         * SAVE_ALL ensures we are using a valid kernel stack for the thread.
     322         * Check if we are already using the IRQ stack.
     323         */
     324        move    s1, sp # Preserve the sp
     325
     326        /* Get IRQ stack for this CPU */
     327        ASM_CPUID_MFC0  k0, ASM_SMP_CPUID_REG
     328#if defined(CONFIG_32BIT) || defined(KBUILD_64BIT_SYM32)
     329        lui     k1, %hi(irq_stack)
     330#else
     331        lui     k1, %highest(irq_stack)
     332        daddiu  k1, %higher(irq_stack)
     333        dsll    k1, 16
     334        daddiu  k1, %hi(irq_stack)
     335        dsll    k1, 16
     336#endif
     337        LONG_SRL        k0, SMP_CPUID_PTRSHIFT
     338        LONG_ADDU       k1, k0
     339        LONG_L  t0, %lo(irq_stack)(k1)
     340
     341        # Check if already on IRQ stack
     342        PTR_LI  t1, ~(_THREAD_SIZE-1)
     343        and     t1, t1, sp
     344        beq     t0, t1, 2f
     345
     346        /* Switch to IRQ stack */
     347        li      t1, _IRQ_STACK_SIZE
     348        PTR_ADD sp, t0, t1
     349
     3502:
     351        jalr    v0
     352
     353        /* Restore sp */
     354        move    sp, s1
     355
     356        j       ret_from_irq
    286357        END(except_vec_vi_handler)
    287358
  • src/linux/universal/linux-4.9/arch/mips/kernel/irq.c

    r31574 r31884  
    2525#include <linux/atomic.h>
    2626#include <asm/uaccess.h>
     27
     28void *irq_stack[NR_CPUS];
    2729
    2830/*
     
    5961
    6062        arch_init_irq();
     63
     64        for_each_possible_cpu(i) {
     65                int irq_pages = IRQ_STACK_SIZE / PAGE_SIZE;
     66                void *s = (void *)__get_free_pages(GFP_KERNEL, irq_pages);
     67
     68                irq_stack[i] = s;
     69                pr_debug("CPU%d IRQ stack at 0x%p - 0x%p\n", i,
     70                        irq_stack[i], irq_stack[i] + IRQ_STACK_SIZE);
     71        }
    6172}
    6273
  • src/linux/universal/linux-4.9/arch/mips/kernel/process.c

    r31632 r31884  
    3434#include <asm/dsp.h>
    3535#include <asm/fpu.h>
     36#include <asm/irq.h>
    3637#include <asm/msa.h>
    3738#include <asm/pgtable.h>
     
    557558                           unsigned long pc, unsigned long *ra)
    558559{
    559         unsigned long stack_page = (unsigned long)task_stack_page(task);
     560        unsigned long stack_page = 0;
     561        int cpu;
     562
     563        for_each_possible_cpu(cpu) {
     564                if (on_irq_stack(cpu, *sp)) {
     565                        stack_page = (unsigned long)irq_stack[cpu];
     566                        break;
     567                }
     568        }
     569
     570        if (!stack_page)
     571                stack_page = (unsigned long)task_stack_page(task);
     572
    560573        return unwind_stack_by_address(stack_page, sp, pc, ra);
    561574}
  • src/linux/universal/linux-4.9/block/blk-mq.c

    r31794 r31884  
    14751475
    14761476        tags->rqs = kzalloc_node(set->queue_depth * sizeof(struct request *),
    1477                                  GFP_KERNEL | __GFP_NOWARN | __GFP_NORETRY,
     1477                                 GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY,
    14781478                                 set->numa_node);
    14791479        if (!tags->rqs) {
     
    15011501                do {
    15021502                        page = alloc_pages_node(set->numa_node,
    1503                                 GFP_KERNEL | __GFP_NOWARN | __GFP_NORETRY | __GFP_ZERO,
     1503                                GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY | __GFP_ZERO,
    15041504                                this_order);
    15051505                        if (page)
     
    15221522                 * to additional allocations like via ops->init_request().
    15231523                 */
    1524                 kmemleak_alloc(p, order_to_size(this_order), 1, GFP_KERNEL);
     1524                kmemleak_alloc(p, order_to_size(this_order), 1, GFP_NOIO);
    15251525                entries_per_page = order_to_size(this_order) / rq_size;
    15261526                to_do = min(entries_per_page, set->queue_depth - i);
  • src/linux/universal/linux-4.9/drivers/crypto/caam/caampkc.c

    r31574 r31884  
    507507
    508508        if (IS_ERR(ctx->dev)) {
    509                 dev_err(ctx->dev, "Job Ring Device allocation for transform failed\n");
     509                pr_err("Job Ring Device allocation for transform failed\n");
    510510                return PTR_ERR(ctx->dev);
    511511        }
  • src/linux/universal/linux-4.9/drivers/crypto/caam/ctrl.c

    r31574 r31884  
    283283                        ret = run_descriptor_deco0(ctrldev, desc, &status);
    284284
    285                         if (ret || status) {
     285                        if (ret ||
     286                            (status && status != JRSTA_SSRC_JUMP_HALT_CC)) {
    286287                                dev_err(ctrldev,
    287288                                        "Failed to deinstantiate RNG4 SH%d\n",
  • src/linux/universal/linux-4.9/drivers/dma-buf/dma-buf.c

    r31574 r31884  
    304304        .poll           = dma_buf_poll,
    305305        .unlocked_ioctl = dma_buf_ioctl,
     306#ifdef CONFIG_COMPAT
     307        .compat_ioctl   = dma_buf_ioctl,
     308#endif
    306309};
    307310
  • src/linux/universal/linux-4.9/drivers/gpu/drm/i915/i915_drv.c

    r31574 r31884  
    241241        case I915_PARAM_ALLOW_BATCHBUFFER:
    242242        case I915_PARAM_LAST_DISPATCH:
     243        case I915_PARAM_HAS_EXEC_CONSTANTS:
    243244                /* Reject all old ums/dri params. */
    244245                return -ENODEV;
     
    266267        case I915_PARAM_HAS_BSD2:
    267268                value = intel_engine_initialized(&dev_priv->engine[VCS2]);
    268                 break;
    269         case I915_PARAM_HAS_EXEC_CONSTANTS:
    270                 value = INTEL_GEN(dev_priv) >= 4;
    271269                break;
    272270        case I915_PARAM_HAS_LLC:
  • src/linux/universal/linux-4.9/drivers/gpu/drm/i915/i915_drv.h

    r31574 r31884  
    12261226
    12271227        /* manual wa residency calculations */
    1228         struct intel_rps_ei up_ei, down_ei;
     1228        struct intel_rps_ei ei;
    12291229
    12301230        /*
     
    17511751
    17521752        const struct intel_device_info info;
    1753 
    1754         int relative_constants_mode;
    17551753
    17561754        void __iomem *regs;
  • src/linux/universal/linux-4.9/drivers/gpu/drm/i915/i915_gem.c

    r31574 r31884  
    45884588        init_waitqueue_head(&dev_priv->gpu_error.reset_queue);
    45894589
    4590         dev_priv->relative_constants_mode = I915_EXEC_CONSTANTS_REL_GENERAL;
    4591 
    45924590        init_waitqueue_head(&dev_priv->pending_flip_queue);
    45934591
  • src/linux/universal/linux-4.9/drivers/gpu/drm/i915/i915_gem_execbuffer.c

    r31574 r31884  
    14551455               struct list_head *vmas)
    14561456{
    1457         struct drm_i915_private *dev_priv = params->request->i915;
    14581457        u64 exec_start, exec_len;
    1459         int instp_mode;
    1460         u32 instp_mask;
    14611458        int ret;
    14621459
     
    14691466                return ret;
    14701467
    1471         instp_mode = args->flags & I915_EXEC_CONSTANTS_MASK;
    1472         instp_mask = I915_EXEC_CONSTANTS_MASK;
    1473         switch (instp_mode) {
    1474         case I915_EXEC_CONSTANTS_REL_GENERAL:
    1475         case I915_EXEC_CONSTANTS_ABSOLUTE:
    1476         case I915_EXEC_CONSTANTS_REL_SURFACE:
    1477                 if (instp_mode != 0 && params->engine->id != RCS) {
    1478                         DRM_DEBUG("non-0 rel constants mode on non-RCS\n");
    1479                         return -EINVAL;
    1480                 }
    1481 
    1482                 if (instp_mode != dev_priv->relative_constants_mode) {
    1483                         if (INTEL_INFO(dev_priv)->gen < 4) {
    1484                                 DRM_DEBUG("no rel constants on pre-gen4\n");
    1485                                 return -EINVAL;
    1486                         }
    1487 
    1488                         if (INTEL_INFO(dev_priv)->gen > 5 &&
    1489                             instp_mode == I915_EXEC_CONSTANTS_REL_SURFACE) {
    1490                                 DRM_DEBUG("rel surface constants mode invalid on gen5+\n");
    1491                                 return -EINVAL;
    1492                         }
    1493 
    1494                         /* The HW changed the meaning on this bit on gen6 */
    1495                         if (INTEL_INFO(dev_priv)->gen >= 6)
    1496                                 instp_mask &= ~I915_EXEC_CONSTANTS_REL_SURFACE;
    1497                 }
    1498                 break;
    1499         default:
    1500                 DRM_DEBUG("execbuf with unknown constants: %d\n", instp_mode);
     1468        if (args->flags & I915_EXEC_CONSTANTS_MASK) {
     1469                DRM_DEBUG("I915_EXEC_CONSTANTS_* unsupported\n");
    15011470                return -EINVAL;
    1502         }
    1503 
    1504         if (params->engine->id == RCS &&
    1505             instp_mode != dev_priv->relative_constants_mode) {
    1506                 struct intel_ring *ring = params->request->ring;
    1507 
    1508                 ret = intel_ring_begin(params->request, 4);
    1509                 if (ret)
    1510                         return ret;
    1511 
    1512                 intel_ring_emit(ring, MI_NOOP);
    1513                 intel_ring_emit(ring, MI_LOAD_REGISTER_IMM(1));
    1514                 intel_ring_emit_reg(ring, INSTPM);
    1515                 intel_ring_emit(ring, instp_mask << 16 | instp_mode);
    1516                 intel_ring_advance(ring);
    1517 
    1518                 dev_priv->relative_constants_mode = instp_mode;
    15191471        }
    15201472
  • src/linux/universal/linux-4.9/drivers/gpu/drm/i915/i915_gem_shrinker.c

    r31574 r31884  
    234234                                I915_SHRINK_UNBOUND |
    235235                                I915_SHRINK_ACTIVE);
    236         rcu_barrier(); /* wait until our RCU delayed slab frees are completed */
     236        synchronize_rcu(); /* wait for our earlier RCU delayed slab frees */
    237237
    238238        return freed;
  • src/linux/universal/linux-4.9/drivers/gpu/drm/i915/i915_irq.c

    r31574 r31884  
    991991}
    992992
    993 static bool vlv_c0_above(struct drm_i915_private *dev_priv,
    994                          const struct intel_rps_ei *old,
    995                          const struct intel_rps_ei *now,
    996                          int threshold)
    997 {
    998         u64 time, c0;
    999         unsigned int mul = 100;
    1000 
    1001         if (old->cz_clock == 0)
    1002                 return false;
    1003 
    1004         if (I915_READ(VLV_COUNTER_CONTROL) & VLV_COUNT_RANGE_HIGH)
    1005                 mul <<= 8;
    1006 
    1007         time = now->cz_clock - old->cz_clock;
    1008         time *= threshold * dev_priv->czclk_freq;
    1009 
    1010         /* Workload can be split between render + media, e.g. SwapBuffers
    1011          * being blitted in X after being rendered in mesa. To account for
    1012          * this we need to combine both engines into our activity counter.
    1013          */
    1014         c0 = now->render_c0 - old->render_c0;
    1015         c0 += now->media_c0 - old->media_c0;
    1016         c0 *= mul * VLV_CZ_CLOCK_TO_MILLI_SEC;
    1017 
    1018         return c0 >= time;
    1019 }
    1020 
    1021993void gen6_rps_reset_ei(struct drm_i915_private *dev_priv)
    1022994{
    1023         vlv_c0_read(dev_priv, &dev_priv->rps.down_ei);
    1024         dev_priv->rps.up_ei = dev_priv->rps.down_ei;
     995        memset(&dev_priv->rps.ei, 0, sizeof(dev_priv->rps.ei));
    1025996}
    1026997
    1027998static u32 vlv_wa_c0_ei(struct drm_i915_private *dev_priv, u32 pm_iir)
    1028999{
     1000        const struct intel_rps_ei *prev = &dev_priv->rps.ei;
    10291001        struct intel_rps_ei now;
    10301002        u32 events = 0;
    10311003
    1032         if ((pm_iir & (GEN6_PM_RP_DOWN_EI_EXPIRED | GEN6_PM_RP_UP_EI_EXPIRED)) == 0)
     1004        if ((pm_iir & GEN6_PM_RP_UP_EI_EXPIRED) == 0)
    10331005                return 0;
    10341006
     
    10371009                return 0;
    10381010
    1039         if (pm_iir & GEN6_PM_RP_DOWN_EI_EXPIRED) {
    1040                 if (!vlv_c0_above(dev_priv,
    1041                                   &dev_priv->rps.down_ei, &now,
    1042                                   dev_priv->rps.down_threshold))
    1043                         events |= GEN6_PM_RP_DOWN_THRESHOLD;
    1044                 dev_priv->rps.down_ei = now;
    1045         }
    1046 
    1047         if (pm_iir & GEN6_PM_RP_UP_EI_EXPIRED) {
    1048                 if (vlv_c0_above(dev_priv,
    1049                                  &dev_priv->rps.up_ei, &now,
    1050                                  dev_priv->rps.up_threshold))
    1051                         events |= GEN6_PM_RP_UP_THRESHOLD;
    1052                 dev_priv->rps.up_ei = now;
    1053         }
    1054 
     1011        if (prev->cz_clock) {
     1012                u64 time, c0;
     1013                unsigned int mul;
     1014
     1015                mul = VLV_CZ_CLOCK_TO_MILLI_SEC * 100; /* scale to threshold% */
     1016                if (I915_READ(VLV_COUNTER_CONTROL) & VLV_COUNT_RANGE_HIGH)
     1017                        mul <<= 8;
     1018
     1019                time = now.cz_clock - prev->cz_clock;
     1020                time *= dev_priv->czclk_freq;
     1021
     1022                /* Workload can be split between render + media,
     1023                 * e.g. SwapBuffers being blitted in X after being rendered in
     1024                 * mesa. To account for this we need to combine both engines
     1025                 * into our activity counter.
     1026                 */
     1027                c0 = now.render_c0 - prev->render_c0;
     1028                c0 += now.media_c0 - prev->media_c0;
     1029                c0 *= mul;
     1030
     1031                if (c0 > time * dev_priv->rps.up_threshold)
     1032                        events = GEN6_PM_RP_UP_THRESHOLD;
     1033                else if (c0 < time * dev_priv->rps.down_threshold)
     1034                        events = GEN6_PM_RP_DOWN_THRESHOLD;
     1035        }
     1036
     1037        dev_priv->rps.ei = now;
    10551038        return events;
    10561039}
     
    44914474        if (IS_VALLEYVIEW(dev_priv))
    44924475                /* WaGsvRC0ResidencyMethod:vlv */
    4493                 dev_priv->pm_rps_events = GEN6_PM_RP_DOWN_EI_EXPIRED | GEN6_PM_RP_UP_EI_EXPIRED;
     4476                dev_priv->pm_rps_events = GEN6_PM_RP_UP_EI_EXPIRED;
    44944477        else
    44954478                dev_priv->pm_rps_events = GEN6_PM_RPS_EVENTS;
     
    45314514        if (!IS_GEN2(dev_priv))
    45324515                dev->vblank_disable_immediate = true;
     4516
     4517        /* Most platforms treat the display irq block as an always-on
     4518         * power domain. vlv/chv can disable it at runtime and need
     4519         * special care to avoid writing any of the display block registers
     4520         * outside of the power domain. We defer setting up the display irqs
     4521         * in this case to the runtime pm.
     4522         */
     4523        dev_priv->display_irqs_enabled = true;
     4524        if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv))
     4525                dev_priv->display_irqs_enabled = false;
    45334526
    45344527        dev->driver->get_vblank_timestamp = i915_get_vblank_timestamp;
  • src/linux/universal/linux-4.9/drivers/gpu/drm/i915/intel_display.c

    r31574 r31884  
    36973697        crtc->base.mode = crtc->base.state->mode;
    36983698
    3699         DRM_DEBUG_KMS("Updating pipe size %ix%i -> %ix%i\n",
    3700                       old_crtc_state->pipe_src_w, old_crtc_state->pipe_src_h,
    3701                       pipe_config->pipe_src_w, pipe_config->pipe_src_h);
    3702 
    37033699        /*
    37043700         * Update pipe size and adjust fitter if needed: the reason for this is
     
    48334829                &crtc->config->scaler_state;
    48344830
    4835         DRM_DEBUG_KMS("for crtc_state = %p\n", crtc->config);
    4836 
    48374831        if (crtc->config->pch_pfit.enabled) {
    48384832                int id;
    48394833
    4840                 if (WARN_ON(crtc->config->scaler_state.scaler_id < 0)) {
    4841                         DRM_ERROR("Requesting pfit without getting a scaler first\n");
     4834                if (WARN_ON(crtc->config->scaler_state.scaler_id < 0))
    48424835                        return;
    4843                 }
    48444836
    48454837                id = scaler_state->scaler_id;
     
    48484840                I915_WRITE(SKL_PS_WIN_POS(pipe, id), crtc->config->pch_pfit.pos);
    48494841                I915_WRITE(SKL_PS_WIN_SZ(pipe, id), crtc->config->pch_pfit.size);
    4850 
    4851                 DRM_DEBUG_KMS("for crtc_state = %p scaler_id = %d\n", crtc->config, id);
    48524842        }
    48534843}
  • src/linux/universal/linux-4.9/drivers/gpu/drm/i915/intel_hotplug.c

    r31574 r31884  
    220220                }
    221221        }
    222         if (dev_priv->display.hpd_irq_setup)
     222        if (dev_priv->display_irqs_enabled && dev_priv->display.hpd_irq_setup)
    223223                dev_priv->display.hpd_irq_setup(dev_priv);
    224224        spin_unlock_irq(&dev_priv->irq_lock);
     
    426426        }
    427427
    428         if (storm_detected)
     428        if (storm_detected && dev_priv->display_irqs_enabled)
    429429                dev_priv->display.hpd_irq_setup(dev_priv);
    430430        spin_unlock(&dev_priv->irq_lock);
     
    472472         * just to make the assert_spin_locked checks happy.
    473473         */
    474         spin_lock_irq(&dev_priv->irq_lock);
    475         if (dev_priv->display.hpd_irq_setup)
    476                 dev_priv->display.hpd_irq_setup(dev_priv);
    477         spin_unlock_irq(&dev_priv->irq_lock);
     474        if (dev_priv->display_irqs_enabled && dev_priv->display.hpd_irq_setup) {
     475                spin_lock_irq(&dev_priv->irq_lock);
     476                if (dev_priv->display_irqs_enabled)
     477                        dev_priv->display.hpd_irq_setup(dev_priv);
     478                spin_unlock_irq(&dev_priv->irq_lock);
     479        }
    478480}
    479481
  • src/linux/universal/linux-4.9/drivers/gpu/drm/i915/intel_lrc.c

    r31574 r31884  
    21532153void intel_lr_context_resume(struct drm_i915_private *dev_priv)
    21542154{
     2155        struct i915_gem_context *ctx = dev_priv->kernel_context;
    21552156        struct intel_engine_cs *engine;
    2156         struct i915_gem_context *ctx;
    2157 
    2158         /* Because we emit WA_TAIL_DWORDS there may be a disparity
    2159          * between our bookkeeping in ce->ring->head and ce->ring->tail and
    2160          * that stored in context. As we only write new commands from
    2161          * ce->ring->tail onwards, everything before that is junk. If the GPU
    2162          * starts reading from its RING_HEAD from the context, it may try to
    2163          * execute that junk and die.
    2164          *
    2165          * So to avoid that we reset the context images upon resume. For
    2166          * simplicity, we just zero everything out.
    2167          */
    2168         list_for_each_entry(ctx, &dev_priv->context_list, link) {
    2169                 for_each_engine(engine, dev_priv) {
    2170                         struct intel_context *ce = &ctx->engine[engine->id];
    2171                         u32 *reg;
    2172 
    2173                         if (!ce->state)
    2174                                 continue;
    2175 
    2176                         reg = i915_gem_object_pin_map(ce->state->obj,
    2177                                                       I915_MAP_WB);
    2178                         if (WARN_ON(IS_ERR(reg)))
    2179                                 continue;
    2180 
    2181                         reg += LRC_STATE_PN * PAGE_SIZE / sizeof(*reg);
    2182                         reg[CTX_RING_HEAD+1] = 0;
    2183                         reg[CTX_RING_TAIL+1] = 0;
    2184 
    2185                         ce->state->obj->dirty = true;
    2186                         i915_gem_object_unpin_map(ce->state->obj);
    2187 
    2188                         ce->ring->head = ce->ring->tail = 0;
    2189                         ce->ring->last_retired_head = -1;
    2190                         intel_ring_update_space(ce->ring);
    2191                 }
    2192         }
    2193 }
     2157
     2158        for_each_engine(engine, dev_priv) {
     2159                struct intel_context *ce = &ctx->engine[engine->id];
     2160                void *vaddr;
     2161                uint32_t *reg_state;
     2162
     2163                if (!ce->state)
     2164                        continue;
     2165
     2166                vaddr = i915_gem_object_pin_map(ce->state->obj, I915_MAP_WB);
     2167                if (WARN_ON(IS_ERR(vaddr)))
     2168                        continue;
     2169
     2170                reg_state = vaddr + LRC_STATE_PN * PAGE_SIZE;
     2171
     2172                reg_state[CTX_RING_HEAD+1] = 0;
     2173                reg_state[CTX_RING_TAIL+1] = 0;
     2174
     2175                ce->state->obj->dirty = true;
     2176                i915_gem_object_unpin_map(ce->state->obj);
     2177
     2178                ce->ring->head = 0;
     2179                ce->ring->tail = 0;
     2180        }
     2181}
  • src/linux/universal/linux-4.9/drivers/gpu/drm/i915/intel_pm.c

    r31574 r31884  
    49044904        }
    49054905
     4906        /* When byt can survive without system hang with dynamic
     4907         * sw freq adjustments, this restriction can be lifted.
     4908         */
     4909        if (IS_VALLEYVIEW(dev_priv))
     4910                goto skip_hw_write;
     4911
    49064912        I915_WRITE(GEN6_RP_UP_EI,
    49074913                   GT_INTERVAL_FROM_US(dev_priv, ei_up));
     
    49244930                   GEN6_RP_DOWN_IDLE_AVG);
    49254931
     4932skip_hw_write:
    49264933        dev_priv->rps.power = new_power;
    49274934        dev_priv->rps.up_threshold = threshold_up;
     
    49344941        u32 mask = 0;
    49354942
     4943        /* We use UP_EI_EXPIRED interupts for both up/down in manual mode */
    49364944        if (val > dev_priv->rps.min_freq_softlimit)
    4937                 mask |= GEN6_PM_RP_DOWN_EI_EXPIRED | GEN6_PM_RP_DOWN_THRESHOLD | GEN6_PM_RP_DOWN_TIMEOUT;
     4945                mask |= GEN6_PM_RP_UP_EI_EXPIRED | GEN6_PM_RP_DOWN_THRESHOLD | GEN6_PM_RP_DOWN_TIMEOUT;
    49384946        if (val < dev_priv->rps.max_freq_softlimit)
    49394947                mask |= GEN6_PM_RP_UP_EI_EXPIRED | GEN6_PM_RP_UP_THRESHOLD;
     
    50355043        mutex_lock(&dev_priv->rps.hw_lock);
    50365044        if (dev_priv->rps.enabled) {
    5037                 if (dev_priv->pm_rps_events & (GEN6_PM_RP_DOWN_EI_EXPIRED | GEN6_PM_RP_UP_EI_EXPIRED))
     5045                if (dev_priv->pm_rps_events & GEN6_PM_RP_UP_EI_EXPIRED)
    50385046                        gen6_rps_reset_ei(dev_priv);
    50395047                I915_WRITE(GEN6_PMINTRMSK,
     
    79617969 *
    79627970 * Keep resending the @request to @mbox until PCODE acknowledges it, PCODE
    7963  * reports an error or an overall timeout of @timeout_base_ms+10 ms expires.
     7971 * reports an error or an overall timeout of @timeout_base_ms+50 ms expires.
    79647972 * The request is acknowledged once the PCODE reply dword equals @reply after
    79657973 * applying @reply_mask. Polling is first attempted with preemption enabled
    7966  * for @timeout_base_ms and if this times out for another 10 ms with
     7974 * for @timeout_base_ms and if this times out for another 50 ms with
    79677975 * preemption disabled.
    79687976 *
     
    80008008         * (queued) request and @timeout_base_ms delay. As a workaround retry
    80018009         * the poll with preemption disabled to maximize the number of
    8002          * requests. Increase the timeout from @timeout_base_ms to 10ms to
     8010         * requests. Increase the timeout from @timeout_base_ms to 50ms to
    80038011         * account for interrupts that could reduce the number of these
    8004          * requests.
     8012         * requests, and for any quirks of the PCODE firmware that delays
     8013         * the request completion.
    80058014         */
    80068015        DRM_DEBUG_KMS("PCODE timeout, retrying with preemption disabled\n");
    80078016        WARN_ON_ONCE(timeout_base_ms > 3);
    80088017        preempt_disable();
    8009         ret = wait_for_atomic(COND, 10);
     8018        ret = wait_for_atomic(COND, 50);
    80108019        preempt_enable();
    80118020
  • src/linux/universal/linux-4.9/drivers/i2c/busses/i2c-bcm2835.c

    r31574 r31884  
    6565        struct i2c_adapter adapter;
    6666        struct completion completion;
     67        struct i2c_msg *curr_msg;
    6768        u32 msg_err;
    6869        u8 *msg_buf;
     
    127128        }
    128129
    129         if (val & BCM2835_I2C_S_RXD) {
    130                 bcm2835_drain_rxfifo(i2c_dev);
    131                 if (!(val & BCM2835_I2C_S_DONE))
    132                         return IRQ_HANDLED;
    133         }
    134 
    135130        if (val & BCM2835_I2C_S_DONE) {
    136                 if (i2c_dev->msg_buf_remaining)
     131                if (i2c_dev->curr_msg->flags & I2C_M_RD) {
     132                        bcm2835_drain_rxfifo(i2c_dev);
     133                        val = bcm2835_i2c_readl(i2c_dev, BCM2835_I2C_S);
     134                }
     135
     136                if ((val & BCM2835_I2C_S_RXD) || i2c_dev->msg_buf_remaining)
    137137                        i2c_dev->msg_err = BCM2835_I2C_S_LEN;
    138138                else
     
    142142        }
    143143
    144         if (val & BCM2835_I2C_S_TXD) {
     144        if (val & BCM2835_I2C_S_TXW) {
    145145                bcm2835_fill_txfifo(i2c_dev);
    146146                return IRQ_HANDLED;
    147147        }
    148148
     149        if (val & BCM2835_I2C_S_RXR) {
     150                bcm2835_drain_rxfifo(i2c_dev);
     151                return IRQ_HANDLED;
     152        }
     153
    149154        return IRQ_NONE;
    150155}
     
    156161        unsigned long time_left;
    157162
     163        i2c_dev->curr_msg = msg;
    158164        i2c_dev->msg_buf = msg->buf;
    159165        i2c_dev->msg_buf_remaining = msg->len;
  • src/linux/universal/linux-4.9/drivers/mtd/bcm47xxpart.c

    r31574 r31884  
    230230                        last_trx_part = curr_part - 1;
    231231
    232                         /*
    233                          * We have whole TRX scanned, skip to the next part. Use
    234                          * roundown (not roundup), as the loop will increase
    235                          * offset in next step.
    236                          */
    237                         offset = rounddown(offset + trx->length, blocksize);
     232                        /* Jump to the end of TRX */
     233                        offset = roundup(offset + trx->length, blocksize);
     234                        /* Next loop iteration will increase the offset */
     235                        offset -= blocksize;
    238236                        continue;
    239237                }
  • src/linux/universal/linux-4.9/drivers/net/ethernet/mellanox/mlx4/cq.c

    r31574 r31884  
    102102        struct mlx4_cq *cq;
    103103
     104        rcu_read_lock();
    104105        cq = radix_tree_lookup(&mlx4_priv(dev)->cq_table.tree,
    105106                               cqn & (dev->caps.num_cqs - 1));
     107        rcu_read_unlock();
     108
    106109        if (!cq) {
    107110                mlx4_dbg(dev, "Completion event for bogus CQ %08x\n", cqn);
     
    109112        }
    110113
     114        /* Acessing the CQ outside of rcu_read_lock is safe, because
     115         * the CQ is freed only after interrupt handling is completed.
     116         */
    111117        ++cq->arm_sn;
    112118
     
    119125        struct mlx4_cq *cq;
    120126
    121         spin_lock(&cq_table->lock);
    122 
     127        rcu_read_lock();
    123128        cq = radix_tree_lookup(&cq_table->tree, cqn & (dev->caps.num_cqs - 1));
    124         if (cq)
    125                 atomic_inc(&cq->refcount);
    126 
    127         spin_unlock(&cq_table->lock);
     129        rcu_read_unlock();
    128130
    129131        if (!cq) {
    130                 mlx4_warn(dev, "Async event for bogus CQ %08x\n", cqn);
     132                mlx4_dbg(dev, "Async event for bogus CQ %08x\n", cqn);
    131133                return;
    132134        }
    133135
     136        /* Acessing the CQ outside of rcu_read_lock is safe, because
     137         * the CQ is freed only after interrupt handling is completed.
     138         */
    134139        cq->event(cq, event_type);
    135 
    136         if (atomic_dec_and_test(&cq->refcount))
    137                 complete(&cq->free);
    138140}
    139141
     
    302304                return err;
    303305
    304         spin_lock_irq(&cq_table->lock);
     306        spin_lock(&cq_table->lock);
    305307        err = radix_tree_insert(&cq_table->tree, cq->cqn, cq);
    306         spin_unlock_irq(&cq_table->lock);
     308        spin_unlock(&cq_table->lock);
    307309        if (err)
    308310                goto err_icm;
     
    350352
    351353err_radix:
    352         spin_lock_irq(&cq_table->lock);
     354        spin_lock(&cq_table->lock);
    353355        radix_tree_delete(&cq_table->tree, cq->cqn);
    354         spin_unlock_irq(&cq_table->lock);
     356        spin_unlock(&cq_table->lock);
    355357
    356358err_icm:
     
    370372        if (err)
    371373                mlx4_warn(dev, "HW2SW_CQ failed (%d) for CQN %06x\n", err, cq->cqn);
     374
     375        spin_lock(&cq_table->lock);
     376        radix_tree_delete(&cq_table->tree, cq->cqn);
     377        spin_unlock(&cq_table->lock);
    372378
    373379        synchronize_irq(priv->eq_table.eq[MLX4_CQ_TO_EQ_VECTOR(cq->vector)].irq);
     
    376382                synchronize_irq(priv->eq_table.eq[MLX4_EQ_ASYNC].irq);
    377383
    378         spin_lock_irq(&cq_table->lock);
    379         radix_tree_delete(&cq_table->tree, cq->cqn);
    380         spin_unlock_irq(&cq_table->lock);
    381 
    382384        if (atomic_dec_and_test(&cq->refcount))
    383385                complete(&cq->free);
  • src/linux/universal/linux-4.9/drivers/net/ethernet/mellanox/mlx4/en_rx.c

    r31574 r31884  
    445445
    446446                ring->stride = stride;
    447                 if (ring->stride <= TXBB_SIZE)
     447                if (ring->stride <= TXBB_SIZE) {
     448                        /* Stamp first unused send wqe */
     449                        __be32 *ptr = (__be32 *)ring->buf;
     450                        __be32 stamp = cpu_to_be32(1 << STAMP_SHIFT);
     451                        *ptr = stamp;
     452                        /* Move pointer to start of rx section */
    448453                        ring->buf += TXBB_SIZE;
     454                }
    449455
    450456                ring->log_stride = ffs(ring->stride) - 1;
  • src/linux/universal/linux-4.9/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c

    r31574 r31884  
    29812981                qp->srq = srq;
    29822982        }
     2983
     2984        /* Save param3 for dynamic changes from VST back to VGT */
     2985        qp->param3 = qpc->param3;
    29832986        put_res(dev, slave, rcqn, RES_CQ);
    29842987        put_res(dev, slave, mtt_base, RES_MTT);
     
    37733776        struct res_qp *qp;
    37743777        u8 orig_sched_queue;
    3775         __be32  orig_param3 = qpc->param3;
    37763778        u8 orig_vlan_control = qpc->pri_path.vlan_control;
    37773779        u8 orig_fvl_rx = qpc->pri_path.fvl_rx;
     
    38153817        if (!err) {
    38163818                qp->sched_queue = orig_sched_queue;
    3817                 qp->param3      = orig_param3;
    38183819                qp->vlan_control = orig_vlan_control;
    38193820                qp->fvl_rx      =  orig_fvl_rx;
  • src/linux/universal/linux-4.9/drivers/net/wireless/ralink/rt2x00/rt2x00dev.c

    r31574 r31884  
    14231423        cancel_delayed_work_sync(&rt2x00dev->autowakeup_work);
    14241424        cancel_work_sync(&rt2x00dev->sleep_work);
    1425 #ifdef CONFIG_RT2X00_LIB_USB
     1425#if IS_ENABLED(CONFIG_RT2X00_LIB_USB)
    14261426        if (rt2x00_is_usb(rt2x00dev)) {
    14271427                usb_kill_anchored_urbs(rt2x00dev->anchor);
  • src/linux/universal/linux-4.9/drivers/net/wireless/ralink/rt2x00/rt2x00usb.c

    r31574 r31884  
    320320                          rt2x00usb_interrupt_txdone, entry);
    321321
    322         usb_anchor_urb(entry_priv->urb, rt2x00dev->anchor);
    323322        status = usb_submit_urb(entry_priv->urb, GFP_ATOMIC);
    324323        if (status) {
    325                 usb_unanchor_urb(entry_priv->urb);
    326324                if (status == -ENODEV)
    327325                        clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
     
    411409                          rt2x00usb_interrupt_rxdone, entry);
    412410
    413         usb_anchor_urb(entry_priv->urb, rt2x00dev->anchor);
    414411        status = usb_submit_urb(entry_priv->urb, GFP_ATOMIC);
    415412        if (status) {
    416                 usb_unanchor_urb(entry_priv->urb);
    417413                if (status == -ENODEV)
    418414                        clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
     
    825821                goto exit_free_device;
    826822
    827         retval = rt2x00lib_probe_dev(rt2x00dev);
    828         if (retval)
    829                 goto exit_free_reg;
    830 
    831823        rt2x00dev->anchor = devm_kmalloc(&usb_dev->dev,
    832824                                        sizeof(struct usb_anchor),
     
    836828                goto exit_free_reg;
    837829        }
    838 
    839830        init_usb_anchor(rt2x00dev->anchor);
     831
     832        retval = rt2x00lib_probe_dev(rt2x00dev);
     833        if (retval)
     834                goto exit_free_anchor;
     835
    840836        return 0;
     837
     838exit_free_anchor:
     839        usb_kill_anchored_urbs(rt2x00dev->anchor);
    841840
    842841exit_free_reg:
  • src/linux/universal/linux-4.9/drivers/usb/core/hub.c

    r31794 r31884  
    26642664                        return ret;
    26652665
    2666                 /* The port state is unknown until the reset completes. */
    2667                 if (!(portstatus & USB_PORT_STAT_RESET))
     2666                /*
     2667                 * The port state is unknown until the reset completes.
     2668                 *
     2669                 * On top of that, some chips may require additional time
     2670                 * to re-establish a connection after the reset is complete,
     2671                 * so also wait for the connection to be re-established.
     2672                 */
     2673                if (!(portstatus & USB_PORT_STAT_RESET) &&
     2674                    (portstatus & USB_PORT_STAT_CONNECTION))
    26682675                        break;
    26692676
  • src/linux/universal/linux-4.9/fs/orangefs/devorangefs-req.c

    r31574 r31884  
    403403        op = orangefs_devreq_remove_op(head.tag);
    404404        if (!op) {
    405                 gossip_err("WARNING: No one's waiting for tag %llu\n",
    406                            llu(head.tag));
     405                gossip_debug(GOSSIP_DEV_DEBUG,
     406                             "%s: No one's waiting for tag %llu\n",
     407                             __func__, llu(head.tag));
    407408                return ret;
    408409        }
  • src/linux/universal/linux-4.9/fs/orangefs/orangefs-debugfs.c

    r31574 r31884  
    672672                cdm_element_count =
    673673                        orangefs_prepare_cdm_array(client_debug_array_string);
    674                 if (cdm_element_count <= 0)
     674                if (cdm_element_count <= 0) {
     675                        kfree(new);
    675676                        goto out;
     677                }
    676678
    677679                for (i = 0; i < cdm_element_count; i++) {
     
    964966
    965967        ret = copy_from_user(&client_debug_array_string,
    966                                      (void __user *)arg,
    967                                      ORANGEFS_MAX_DEBUG_STRING_LEN);
     968                             (void __user *)arg,
     969                             ORANGEFS_MAX_DEBUG_STRING_LEN);
    968970
    969971        if (ret != 0) {
    970972                pr_info("%s: CLIENT_STRING: copy_from_user failed\n",
    971973                        __func__);
    972                 return -EIO;
     974                return -EFAULT;
    973975        }
    974976
     
    985987        client_debug_array_string[ORANGEFS_MAX_DEBUG_STRING_LEN - 1] =
    986988                '\0';
    987        
     989
    988990        pr_info("%s: client debug array string has been received.\n",
    989991                __func__);
     
    992994
    993995                /* Build a proper debug help string. */
    994                 if (orangefs_prepare_debugfs_help_string(0)) {
     996                ret = orangefs_prepare_debugfs_help_string(0);
     997                if (ret) {
    995998                        gossip_err("%s: no debug help string \n",
    996999                                   __func__);
    997                         return -EIO;
     1000                        return ret;
    9981001                }
    9991002
     
    10081011        help_string_initialized++;
    10091012
    1010         return ret;
     1013        return 0;
    10111014}
    10121015
  • src/linux/universal/linux-4.9/fs/orangefs/orangefs-dev-proto.h

    r31574 r31884  
    5151 * Otherwise 32-64 bit interactions will be messed up :)
    5252 */
    53 #define ORANGEFS_MAX_DEBUG_STRING_LEN   0x00000400
    54 #define ORANGEFS_MAX_DEBUG_ARRAY_LEN    0x00000800
     53#define ORANGEFS_MAX_DEBUG_STRING_LEN   0x00000800
    5554
    5655/*
  • src/linux/universal/linux-4.9/net/packet/af_packet.c

    r31732 r31884  
    42594259                        goto out;
    42604260                if (po->tp_version >= TPACKET_V3 &&
    4261                     (int)(req->tp_block_size -
    4262                           BLK_PLUS_PRIV(req_u->req3.tp_sizeof_priv)) <= 0)
     4261                    req->tp_block_size <=
     4262                          BLK_PLUS_PRIV((u64)req_u->req3.tp_sizeof_priv))
    42634263                        goto out;
    42644264                if (unlikely(req->tp_frame_size < po->tp_hdrlen +
Note: See TracChangeset for help on using the changeset viewer.