Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/kernel-magellan/patches-4.0/0100-4.0.1-all-fixes.patch

    Annotation of /trunk/kernel-magellan/patches-4.0/0100-4.0.1-all-fixes.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 2563 - (hide annotations) (download)
    Tue Nov 25 22:54:01 2014 UTC (9 years, 5 months ago) by niro
    File size: 14124 byte(s) 
    -linux-4.0.1
    1 niro 2563 diff --git a/Makefile b/Makefile
    2     index fbd43bfe4445..f499cd2f5738 100644
    3     --- a/Makefile
    4     +++ b/Makefile
    5     @@ -1,6 +1,6 @@
    6     VERSION = 4
    7     PATCHLEVEL = 0
    8     -SUBLEVEL = 0
    9     +SUBLEVEL = 1
    10     EXTRAVERSION =
    11     NAME = Hurr durr I'ma sheep
    12    
    13     diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h b/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
    14     index 4085c4b31047..355d5fea5be9 100644
    15     --- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
    16     +++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
    17     @@ -531,20 +531,8 @@ struct bnx2x_fastpath {
    18     struct napi_struct napi;
    19    
    20     #ifdef CONFIG_NET_RX_BUSY_POLL
    21     - unsigned int state;
    22     -#define BNX2X_FP_STATE_IDLE 0
    23     -#define BNX2X_FP_STATE_NAPI (1 << 0) /* NAPI owns this FP */
    24     -#define BNX2X_FP_STATE_POLL (1 << 1) /* poll owns this FP */
    25     -#define BNX2X_FP_STATE_DISABLED (1 << 2)
    26     -#define BNX2X_FP_STATE_NAPI_YIELD (1 << 3) /* NAPI yielded this FP */
    27     -#define BNX2X_FP_STATE_POLL_YIELD (1 << 4) /* poll yielded this FP */
    28     -#define BNX2X_FP_OWNED (BNX2X_FP_STATE_NAPI | BNX2X_FP_STATE_POLL)
    29     -#define BNX2X_FP_YIELD (BNX2X_FP_STATE_NAPI_YIELD | BNX2X_FP_STATE_POLL_YIELD)
    30     -#define BNX2X_FP_LOCKED (BNX2X_FP_OWNED | BNX2X_FP_STATE_DISABLED)
    31     -#define BNX2X_FP_USER_PEND (BNX2X_FP_STATE_POLL | BNX2X_FP_STATE_POLL_YIELD)
    32     - /* protect state */
    33     - spinlock_t lock;
    34     -#endif /* CONFIG_NET_RX_BUSY_POLL */
    35     + unsigned long busy_poll_state;
    36     +#endif
    37    
    38     union host_hc_status_block status_blk;
    39     /* chip independent shortcuts into sb structure */
    40     @@ -619,104 +607,83 @@ struct bnx2x_fastpath {
    41     #define bnx2x_fp_qstats(bp, fp) (&((bp)->fp_stats[(fp)->index].eth_q_stats))
    42    
    43     #ifdef CONFIG_NET_RX_BUSY_POLL
    44     -static inline void bnx2x_fp_init_lock(struct bnx2x_fastpath *fp)
    45     +
    46     +enum bnx2x_fp_state {
    47     + BNX2X_STATE_FP_NAPI = BIT(0), /* NAPI handler owns the queue */
    48     +
    49     + BNX2X_STATE_FP_NAPI_REQ_BIT = 1, /* NAPI would like to own the queue */
    50     + BNX2X_STATE_FP_NAPI_REQ = BIT(1),
    51     +
    52     + BNX2X_STATE_FP_POLL_BIT = 2,
    53     + BNX2X_STATE_FP_POLL = BIT(2), /* busy_poll owns the queue */
    54     +
    55     + BNX2X_STATE_FP_DISABLE_BIT = 3, /* queue is dismantled */
    56     +};
    57     +
    58     +static inline void bnx2x_fp_busy_poll_init(struct bnx2x_fastpath *fp)
    59     {
    60     - spin_lock_init(&fp->lock);
    61     - fp->state = BNX2X_FP_STATE_IDLE;
    62     + WRITE_ONCE(fp->busy_poll_state, 0);
    63     }
    64    
    65     /* called from the device poll routine to get ownership of a FP */
    66     static inline bool bnx2x_fp_lock_napi(struct bnx2x_fastpath *fp)
    67     {
    68     - bool rc = true;
    69     -
    70     - spin_lock_bh(&fp->lock);
    71     - if (fp->state & BNX2X_FP_LOCKED) {
    72     - WARN_ON(fp->state & BNX2X_FP_STATE_NAPI);
    73     - fp->state |= BNX2X_FP_STATE_NAPI_YIELD;
    74     - rc = false;
    75     - } else {
    76     - /* we don't care if someone yielded */
    77     - fp->state = BNX2X_FP_STATE_NAPI;
    78     + unsigned long prev, old = READ_ONCE(fp->busy_poll_state);
    79     +
    80     + while (1) {
    81     + switch (old) {
    82     + case BNX2X_STATE_FP_POLL:
    83     + /* make sure bnx2x_fp_lock_poll() wont starve us */
    84     + set_bit(BNX2X_STATE_FP_NAPI_REQ_BIT,
    85     + &fp->busy_poll_state);
    86     + /* fallthrough */
    87     + case BNX2X_STATE_FP_POLL | BNX2X_STATE_FP_NAPI_REQ:
    88     + return false;
    89     + default:
    90     + break;
    91     + }
    92     + prev = cmpxchg(&fp->busy_poll_state, old, BNX2X_STATE_FP_NAPI);
    93     + if (unlikely(prev != old)) {
    94     + old = prev;
    95     + continue;
    96     + }
    97     + return true;
    98     }
    99     - spin_unlock_bh(&fp->lock);
    100     - return rc;
    101     }
    102    
    103     -/* returns true is someone tried to get the FP while napi had it */
    104     -static inline bool bnx2x_fp_unlock_napi(struct bnx2x_fastpath *fp)
    105     +static inline void bnx2x_fp_unlock_napi(struct bnx2x_fastpath *fp)
    106     {
    107     - bool rc = false;
    108     -
    109     - spin_lock_bh(&fp->lock);
    110     - WARN_ON(fp->state &
    111     - (BNX2X_FP_STATE_POLL | BNX2X_FP_STATE_NAPI_YIELD));
    112     -
    113     - if (fp->state & BNX2X_FP_STATE_POLL_YIELD)
    114     - rc = true;
    115     -
    116     - /* state ==> idle, unless currently disabled */
    117     - fp->state &= BNX2X_FP_STATE_DISABLED;
    118     - spin_unlock_bh(&fp->lock);
    119     - return rc;
    120     + smp_wmb();
    121     + fp->busy_poll_state = 0;
    122     }
    123    
    124     /* called from bnx2x_low_latency_poll() */
    125     static inline bool bnx2x_fp_lock_poll(struct bnx2x_fastpath *fp)
    126     {
    127     - bool rc = true;
    128     -
    129     - spin_lock_bh(&fp->lock);
    130     - if ((fp->state & BNX2X_FP_LOCKED)) {
    131     - fp->state |= BNX2X_FP_STATE_POLL_YIELD;
    132     - rc = false;
    133     - } else {
    134     - /* preserve yield marks */
    135     - fp->state |= BNX2X_FP_STATE_POLL;
    136     - }
    137     - spin_unlock_bh(&fp->lock);
    138     - return rc;
    139     + return cmpxchg(&fp->busy_poll_state, 0, BNX2X_STATE_FP_POLL) == 0;
    140     }
    141    
    142     -/* returns true if someone tried to get the FP while it was locked */
    143     -static inline bool bnx2x_fp_unlock_poll(struct bnx2x_fastpath *fp)
    144     +static inline void bnx2x_fp_unlock_poll(struct bnx2x_fastpath *fp)
    145     {
    146     - bool rc = false;
    147     -
    148     - spin_lock_bh(&fp->lock);
    149     - WARN_ON(fp->state & BNX2X_FP_STATE_NAPI);
    150     -
    151     - if (fp->state & BNX2X_FP_STATE_POLL_YIELD)
    152     - rc = true;
    153     -
    154     - /* state ==> idle, unless currently disabled */
    155     - fp->state &= BNX2X_FP_STATE_DISABLED;
    156     - spin_unlock_bh(&fp->lock);
    157     - return rc;
    158     + smp_mb__before_atomic();
    159     + clear_bit(BNX2X_STATE_FP_POLL_BIT, &fp->busy_poll_state);
    160     }
    161    
    162     -/* true if a socket is polling, even if it did not get the lock */
    163     +/* true if a socket is polling */
    164     static inline bool bnx2x_fp_ll_polling(struct bnx2x_fastpath *fp)
    165     {
    166     - WARN_ON(!(fp->state & BNX2X_FP_OWNED));
    167     - return fp->state & BNX2X_FP_USER_PEND;
    168     + return READ_ONCE(fp->busy_poll_state) & BNX2X_STATE_FP_POLL;
    169     }
    170    
    171     /* false if fp is currently owned */
    172     static inline bool bnx2x_fp_ll_disable(struct bnx2x_fastpath *fp)
    173     {
    174     - int rc = true;
    175     -
    176     - spin_lock_bh(&fp->lock);
    177     - if (fp->state & BNX2X_FP_OWNED)
    178     - rc = false;
    179     - fp->state |= BNX2X_FP_STATE_DISABLED;
    180     - spin_unlock_bh(&fp->lock);
    181     + set_bit(BNX2X_STATE_FP_DISABLE_BIT, &fp->busy_poll_state);
    182     + return !bnx2x_fp_ll_polling(fp);
    183    
    184     - return rc;
    185     }
    186     #else
    187     -static inline void bnx2x_fp_init_lock(struct bnx2x_fastpath *fp)
    188     +static inline void bnx2x_fp_busy_poll_init(struct bnx2x_fastpath *fp)
    189     {
    190     }
    191    
    192     @@ -725,9 +692,8 @@ static inline bool bnx2x_fp_lock_napi(struct bnx2x_fastpath *fp)
    193     return true;
    194     }
    195    
    196     -static inline bool bnx2x_fp_unlock_napi(struct bnx2x_fastpath *fp)
    197     +static inline void bnx2x_fp_unlock_napi(struct bnx2x_fastpath *fp)
    198     {
    199     - return false;
    200     }
    201    
    202     static inline bool bnx2x_fp_lock_poll(struct bnx2x_fastpath *fp)
    203     @@ -735,9 +701,8 @@ static inline bool bnx2x_fp_lock_poll(struct bnx2x_fastpath *fp)
    204     return false;
    205     }
    206    
    207     -static inline bool bnx2x_fp_unlock_poll(struct bnx2x_fastpath *fp)
    208     +static inline void bnx2x_fp_unlock_poll(struct bnx2x_fastpath *fp)
    209     {
    210     - return false;
    211     }
    212    
    213     static inline bool bnx2x_fp_ll_polling(struct bnx2x_fastpath *fp)
    214     diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
    215     index 0a9faa134a9a..2f63467bce46 100644
    216     --- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
    217     +++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
    218     @@ -1849,7 +1849,7 @@ static void bnx2x_napi_enable_cnic(struct bnx2x *bp)
    219     int i;
    220    
    221     for_each_rx_queue_cnic(bp, i) {
    222     - bnx2x_fp_init_lock(&bp->fp[i]);
    223     + bnx2x_fp_busy_poll_init(&bp->fp[i]);
    224     napi_enable(&bnx2x_fp(bp, i, napi));
    225     }
    226     }
    227     @@ -1859,7 +1859,7 @@ static void bnx2x_napi_enable(struct bnx2x *bp)
    228     int i;
    229    
    230     for_each_eth_queue(bp, i) {
    231     - bnx2x_fp_init_lock(&bp->fp[i]);
    232     + bnx2x_fp_busy_poll_init(&bp->fp[i]);
    233     napi_enable(&bnx2x_fp(bp, i, napi));
    234     }
    235     }
    236     @@ -3191,9 +3191,10 @@ static int bnx2x_poll(struct napi_struct *napi, int budget)
    237     }
    238     }
    239    
    240     + bnx2x_fp_unlock_napi(fp);
    241     +
    242     /* Fall out from the NAPI loop if needed */
    243     - if (!bnx2x_fp_unlock_napi(fp) &&
    244     - !(bnx2x_has_rx_work(fp) || bnx2x_has_tx_work(fp))) {
    245     + if (!(bnx2x_has_rx_work(fp) || bnx2x_has_tx_work(fp))) {
    246    
    247     /* No need to update SB for FCoE L2 ring as long as
    248     * it's connected to the default SB and the SB
    249     diff --git a/drivers/net/vxlan.c b/drivers/net/vxlan.c
    250     index f8528a4cf54f..fceb637efd6b 100644
    251     --- a/drivers/net/vxlan.c
    252     +++ b/drivers/net/vxlan.c
    253     @@ -1713,12 +1713,6 @@ static int vxlan6_xmit_skb(struct dst_entry *dst, struct sk_buff *skb,
    254     }
    255     }
    256    
    257     - skb = iptunnel_handle_offloads(skb, udp_sum, type);
    258     - if (IS_ERR(skb)) {
    259     - err = -EINVAL;
    260     - goto err;
    261     - }
    262     -
    263     skb_scrub_packet(skb, xnet);
    264    
    265     min_headroom = LL_RESERVED_SPACE(dst->dev) + dst->header_len
    266     @@ -1738,6 +1732,12 @@ static int vxlan6_xmit_skb(struct dst_entry *dst, struct sk_buff *skb,
    267     goto err;
    268     }
    269    
    270     + skb = iptunnel_handle_offloads(skb, udp_sum, type);
    271     + if (IS_ERR(skb)) {
    272     + err = -EINVAL;
    273     + goto err;
    274     + }
    275     +
    276     vxh = (struct vxlanhdr *) __skb_push(skb, sizeof(*vxh));
    277     vxh->vx_flags = htonl(VXLAN_HF_VNI);
    278     vxh->vx_vni = md->vni;
    279     @@ -1798,10 +1798,6 @@ int vxlan_xmit_skb(struct rtable *rt, struct sk_buff *skb,
    280     }
    281     }
    282    
    283     - skb = iptunnel_handle_offloads(skb, udp_sum, type);
    284     - if (IS_ERR(skb))
    285     - return PTR_ERR(skb);
    286     -
    287     min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len
    288     + VXLAN_HLEN + sizeof(struct iphdr)
    289     + (skb_vlan_tag_present(skb) ? VLAN_HLEN : 0);
    290     @@ -1817,6 +1813,10 @@ int vxlan_xmit_skb(struct rtable *rt, struct sk_buff *skb,
    291     if (WARN_ON(!skb))
    292     return -ENOMEM;
    293    
    294     + skb = iptunnel_handle_offloads(skb, udp_sum, type);
    295     + if (IS_ERR(skb))
    296     + return PTR_ERR(skb);
    297     +
    298     vxh = (struct vxlanhdr *) __skb_push(skb, sizeof(*vxh));
    299     vxh->vx_flags = htonl(VXLAN_HF_VNI);
    300     vxh->vx_vni = md->vni;
    301     diff --git a/fs/exec.c b/fs/exec.c
    302     index c7f9b733406d..00400cf522dc 100644
    303     --- a/fs/exec.c
    304     +++ b/fs/exec.c
    305     @@ -1265,6 +1265,53 @@ static void check_unsafe_exec(struct linux_binprm *bprm)
    306     spin_unlock(&p->fs->lock);
    307     }
    308    
    309     +static void bprm_fill_uid(struct linux_binprm *bprm)
    310     +{
    311     + struct inode *inode;
    312     + unsigned int mode;
    313     + kuid_t uid;
    314     + kgid_t gid;
    315     +
    316     + /* clear any previous set[ug]id data from a previous binary */
    317     + bprm->cred->euid = current_euid();
    318     + bprm->cred->egid = current_egid();
    319     +
    320     + if (bprm->file->f_path.mnt->mnt_flags & MNT_NOSUID)
    321     + return;
    322     +
    323     + if (task_no_new_privs(current))
    324     + return;
    325     +
    326     + inode = file_inode(bprm->file);
    327     + mode = READ_ONCE(inode->i_mode);
    328     + if (!(mode & (S_ISUID|S_ISGID)))
    329     + return;
    330     +
    331     + /* Be careful if suid/sgid is set */
    332     + mutex_lock(&inode->i_mutex);
    333     +
    334     + /* reload atomically mode/uid/gid now that lock held */
    335     + mode = inode->i_mode;
    336     + uid = inode->i_uid;
    337     + gid = inode->i_gid;
    338     + mutex_unlock(&inode->i_mutex);
    339     +
    340     + /* We ignore suid/sgid if there are no mappings for them in the ns */
    341     + if (!kuid_has_mapping(bprm->cred->user_ns, uid) ||
    342     + !kgid_has_mapping(bprm->cred->user_ns, gid))
    343     + return;
    344     +
    345     + if (mode & S_ISUID) {
    346     + bprm->per_clear |= PER_CLEAR_ON_SETID;
    347     + bprm->cred->euid = uid;
    348     + }
    349     +
    350     + if ((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP)) {
    351     + bprm->per_clear |= PER_CLEAR_ON_SETID;
    352     + bprm->cred->egid = gid;
    353     + }
    354     +}
    355     +
    356     /*
    357     * Fill the binprm structure from the inode.
    358     * Check permissions, then read the first 128 (BINPRM_BUF_SIZE) bytes
    359     @@ -1273,36 +1320,9 @@ static void check_unsafe_exec(struct linux_binprm *bprm)
    360     */
    361     int prepare_binprm(struct linux_binprm *bprm)
    362     {
    363     - struct inode *inode = file_inode(bprm->file);
    364     - umode_t mode = inode->i_mode;
    365     int retval;
    366    
    367     -
    368     - /* clear any previous set[ug]id data from a previous binary */
    369     - bprm->cred->euid = current_euid();
    370     - bprm->cred->egid = current_egid();
    371     -
    372     - if (!(bprm->file->f_path.mnt->mnt_flags & MNT_NOSUID) &&
    373     - !task_no_new_privs(current) &&
    374     - kuid_has_mapping(bprm->cred->user_ns, inode->i_uid) &&
    375     - kgid_has_mapping(bprm->cred->user_ns, inode->i_gid)) {
    376     - /* Set-uid? */
    377     - if (mode & S_ISUID) {
    378     - bprm->per_clear |= PER_CLEAR_ON_SETID;
    379     - bprm->cred->euid = inode->i_uid;
    380     - }
    381     -
    382     - /* Set-gid? */
    383     - /*
    384     - * If setgid is set but no group execute bit then this
    385     - * is a candidate for mandatory locking, not a setgid
    386     - * executable.
    387     - */
    388     - if ((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP)) {
    389     - bprm->per_clear |= PER_CLEAR_ON_SETID;
    390     - bprm->cred->egid = inode->i_gid;
    391     - }
    392     - }
    393     + bprm_fill_uid(bprm);
    394    
    395     /* fill in binprm security blob */
    396     retval = security_bprm_set_creds(bprm);
    397     diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c
    398     index a28e09c7825d..36508e69e92a 100644
    399     --- a/kernel/bpf/verifier.c
    400     +++ b/kernel/bpf/verifier.c
    401     @@ -1380,7 +1380,8 @@ peek_stack:
    402     /* tell verifier to check for equivalent states
    403     * after every call and jump
    404     */
    405     - env->explored_states[t + 1] = STATE_LIST_MARK;
    406     + if (t + 1 < insn_cnt)
    407     + env->explored_states[t + 1] = STATE_LIST_MARK;
    408     } else {
    409     /* conditional jump with two edges */
    410     ret = push_insn(t, t + 1, FALLTHROUGH, env);
    411     diff --git a/net/core/skbuff.c b/net/core/skbuff.c
    412     index 8e4ac97c8477..98d45fe72f51 100644
    413     --- a/net/core/skbuff.c
    414     +++ b/net/core/skbuff.c
    415     @@ -4169,19 +4169,21 @@ EXPORT_SYMBOL(skb_try_coalesce);
    416     */
    417     void skb_scrub_packet(struct sk_buff *skb, bool xnet)
    418     {
    419     - if (xnet)
    420     - skb_orphan(skb);
    421     skb->tstamp.tv64 = 0;
    422     skb->pkt_type = PACKET_HOST;
    423     skb->skb_iif = 0;
    424     skb->ignore_df = 0;
    425     skb_dst_drop(skb);
    426     - skb->mark = 0;
    427     skb_sender_cpu_clear(skb);
    428     - skb_init_secmark(skb);
    429     secpath_reset(skb);
    430     nf_reset(skb);
    431     nf_reset_trace(skb);
    432     +
    433     + if (!xnet)
    434     + return;
    435     +
    436     + skb_orphan(skb);
    437     + skb->mark = 0;
    438     }
    439     EXPORT_SYMBOL_GPL(skb_scrub_packet);
    440    
    441     diff --git a/net/ipv4/geneve.c b/net/ipv4/geneve.c
    442     index 5a4828ba05ad..a566a2e4715b 100644
    443     --- a/net/ipv4/geneve.c
    444     +++ b/net/ipv4/geneve.c
    445     @@ -113,10 +113,6 @@ int geneve_xmit_skb(struct geneve_sock *gs, struct rtable *rt,
    446     int min_headroom;
    447     int err;
    448    
    449     - skb = udp_tunnel_handle_offloads(skb, csum);
    450     - if (IS_ERR(skb))
    451     - return PTR_ERR(skb);
    452     -
    453     min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len
    454     + GENEVE_BASE_HLEN + opt_len + sizeof(struct iphdr)
    455     + (skb_vlan_tag_present(skb) ? VLAN_HLEN : 0);
    456     @@ -131,6 +127,10 @@ int geneve_xmit_skb(struct geneve_sock *gs, struct rtable *rt,
    457     if (unlikely(!skb))
    458     return -ENOMEM;
    459    
    460     + skb = udp_tunnel_handle_offloads(skb, csum);
    461     + if (IS_ERR(skb))
    462     + return PTR_ERR(skb);
    463     +
    464     gnvh = (struct genevehdr *)__skb_push(skb, sizeof(*gnvh) + opt_len);
    465     geneve_build_header(gnvh, tun_flags, vni, opt_len, opt);
    466    
    467     diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
    468     index 1db253e36045..d520492ba698 100644
    469     --- a/net/ipv4/tcp_output.c
    470     +++ b/net/ipv4/tcp_output.c
    471     @@ -2929,6 +2929,8 @@ struct sk_buff *tcp_make_synack(struct sock *sk, struct dst_entry *dst,
    472     }
    473     #endif
    474    
    475     + /* Do not fool tcpdump (if any), clean our debris */
    476     + skb->tstamp.tv64 = 0;
    477     return skb;
    478     }
    479     EXPORT_SYMBOL(tcp_make_synack);