adulau/aha
1
0
Fork 0
mirror of https://github.com/adulau/aha.git synced 2024-12-27 11:16:11 +00:00
Code Issues Projects Releases Packages Wiki Activity

net: Move && and || to end of previous line

Browse source 
Not including net/atm/

Compiled tested x86 allyesconfig only
Added a > 80 column line or two, which I ignored.
Existing checkpatch plaints willfully, cheerfully ignored.

Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Joe Perches 2009-11-29 16:55:45 -08:00 committed by David S. Miller
parent 152b6a62ae
commit f64f9e7192
63 changed files with 235 additions and 233 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
net/9p/trans_fd.c
View file

@ -633,8 +633,8 @@ static void p9_poll_mux(struct p9_conn *m)
if (n & POLLOUT) { if (n & POLLOUT) {
set_bit(Wpending, &m->wsched); set_bit(Wpending, &m->wsched);
P9_DPRINTK(P9_DEBUG_TRANS, "mux %p can write\n", m); P9_DPRINTK(P9_DEBUG_TRANS, "mux %p can write\n", m);
if ((m->wsize || !list_empty(&m->unsent_req_list)) if ((m->wsize || !list_empty(&m->unsent_req_list)) &&
&& !test_and_set_bit(Wworksched, &m->wsched)) { !test_and_set_bit(Wworksched, &m->wsched)) {
P9_DPRINTK(P9_DEBUG_TRANS, "sched write work %p\n", m); P9_DPRINTK(P9_DEBUG_TRANS, "sched write work %p\n", m);
queue_work(p9_mux_wq, &m->wq); queue_work(p9_mux_wq, &m->wq);
} }

20
net/bluetooth/l2cap.c
View file

@ -1362,8 +1362,8 @@ static int l2cap_ertm_send(struct sock *sk)
if (pi->conn_state & L2CAP_CONN_WAIT_F) if (pi->conn_state & L2CAP_CONN_WAIT_F)
return 0; return 0;
while ((skb = sk->sk_send_head) && (!l2cap_tx_window_full(sk)) while ((skb = sk->sk_send_head) && (!l2cap_tx_window_full(sk)) &&
&& !(pi->conn_state & L2CAP_CONN_REMOTE_BUSY)) { !(pi->conn_state & L2CAP_CONN_REMOTE_BUSY)) {
tx_skb = skb_clone(skb, GFP_ATOMIC); tx_skb = skb_clone(skb, GFP_ATOMIC);
if (pi->remote_max_tx && if (pi->remote_max_tx &&
@ -1604,8 +1604,8 @@ static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock, struct ms
return -EOPNOTSUPP; return -EOPNOTSUPP;
/* Check outgoing MTU */ /* Check outgoing MTU */
if (sk->sk_type == SOCK_SEQPACKET && pi->mode == L2CAP_MODE_BASIC if (sk->sk_type == SOCK_SEQPACKET && pi->mode == L2CAP_MODE_BASIC &&
&& len > pi->omtu) len > pi->omtu)
return -EINVAL; return -EINVAL;
lock_sock(sk); lock_sock(sk);
@ -2756,8 +2756,8 @@ static inline int l2cap_config_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr
goto unlock; goto unlock;
if (l2cap_pi(sk)->conf_state & L2CAP_CONF_INPUT_DONE) { if (l2cap_pi(sk)->conf_state & L2CAP_CONF_INPUT_DONE) {
if (!(l2cap_pi(sk)->conf_state & L2CAP_CONF_NO_FCS_RECV) if (!(l2cap_pi(sk)->conf_state & L2CAP_CONF_NO_FCS_RECV) ||
|| l2cap_pi(sk)->fcs != L2CAP_FCS_NONE) l2cap_pi(sk)->fcs != L2CAP_FCS_NONE)
l2cap_pi(sk)->fcs = L2CAP_FCS_CRC16; l2cap_pi(sk)->fcs = L2CAP_FCS_CRC16;
sk->sk_state = BT_CONNECTED; sk->sk_state = BT_CONNECTED;
@ -2845,8 +2845,8 @@ static inline int l2cap_config_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr
l2cap_pi(sk)->conf_state |= L2CAP_CONF_INPUT_DONE; l2cap_pi(sk)->conf_state |= L2CAP_CONF_INPUT_DONE;
if (l2cap_pi(sk)->conf_state & L2CAP_CONF_OUTPUT_DONE) { if (l2cap_pi(sk)->conf_state & L2CAP_CONF_OUTPUT_DONE) {
if (!(l2cap_pi(sk)->conf_state & L2CAP_CONF_NO_FCS_RECV) if (!(l2cap_pi(sk)->conf_state & L2CAP_CONF_NO_FCS_RECV) ||
|| l2cap_pi(sk)->fcs != L2CAP_FCS_NONE) l2cap_pi(sk)->fcs != L2CAP_FCS_NONE)
l2cap_pi(sk)->fcs = L2CAP_FCS_CRC16; l2cap_pi(sk)->fcs = L2CAP_FCS_CRC16;
sk->sk_state = BT_CONNECTED; sk->sk_state = BT_CONNECTED;
@ -3388,8 +3388,8 @@ static inline int l2cap_data_channel_sframe(struct sock *sk, u16 rx_control, str
pi->expected_ack_seq = tx_seq; pi->expected_ack_seq = tx_seq;
l2cap_drop_acked_frames(sk); l2cap_drop_acked_frames(sk);
if ((pi->conn_state & L2CAP_CONN_REMOTE_BUSY) if ((pi->conn_state & L2CAP_CONN_REMOTE_BUSY) &&
&& (pi->unacked_frames > 0)) (pi->unacked_frames > 0))
__mod_retrans_timer(); __mod_retrans_timer();
l2cap_ertm_send(sk); l2cap_ertm_send(sk);

4
net/bridge/br_fdb.c
View file

@ -60,8 +60,8 @@ static inline unsigned long hold_time(const struct net_bridge *br)
static inline int has_expired(const struct net_bridge *br, static inline int has_expired(const struct net_bridge *br,
const struct net_bridge_fdb_entry *fdb) const struct net_bridge_fdb_entry *fdb)
{ {
return !fdb->is_static return !fdb->is_static &&
&& time_before_eq(fdb->ageing_timer + hold_time(br), jiffies); time_before_eq(fdb->ageing_timer + hold_time(br), jiffies);
} }
static inline int br_mac_hash(const unsigned char *mac) static inline int br_mac_hash(const unsigned char *mac)

6
net/bridge/br_sysfs_br.c
View file

@ -316,9 +316,9 @@ static ssize_t store_group_addr(struct device *d,
if (new_addr[5] & ~0xf) if (new_addr[5] & ~0xf)
return -EINVAL; return -EINVAL;
if (new_addr[5] == 1 /* 802.3x Pause address */ if (new_addr[5] == 1 || /* 802.3x Pause address */
|| new_addr[5] == 2 /* 802.3ad Slow protocols */ new_addr[5] == 2 || /* 802.3ad Slow protocols */
|| new_addr[5] == 3) /* 802.1X PAE address */ new_addr[5] == 3) /* 802.1X PAE address */
return -EINVAL; return -EINVAL;
spin_lock_bh(&br->lock); spin_lock_bh(&br->lock);

4
net/bridge/netfilter/ebt_stp.c
View file

@ -135,8 +135,8 @@ ebt_stp_mt(const struct sk_buff *skb, const struct xt_match_param *par)
if (memcmp(sp, header, sizeof(header))) if (memcmp(sp, header, sizeof(header)))
return false; return false;
if (info->bitmask & EBT_STP_TYPE if (info->bitmask & EBT_STP_TYPE &&
&& FWINV(info->type != sp->type, EBT_STP_TYPE)) FWINV(info->type != sp->type, EBT_STP_TYPE))
return false; return false;
if (sp->type == BPDU_TYPE_CONFIG && if (sp->type == BPDU_TYPE_CONFIG &&

8
net/can/af_can.c
View file

@ -375,8 +375,8 @@ static struct hlist_head *find_rcv_list(canid_t *can_id, canid_t *mask,
return &d->rx[RX_ALL]; return &d->rx[RX_ALL];
/* extra filterlists for the subscription of a single non-RTR can_id */ /* extra filterlists for the subscription of a single non-RTR can_id */
if (((*mask & CAN_EFF_RTR_FLAGS) == CAN_EFF_RTR_FLAGS) if (((*mask & CAN_EFF_RTR_FLAGS) == CAN_EFF_RTR_FLAGS) &&
&& !(*can_id & CAN_RTR_FLAG)) { !(*can_id & CAN_RTR_FLAG)) {
if (*can_id & CAN_EFF_FLAG) { if (*can_id & CAN_EFF_FLAG) {
if (*mask == (CAN_EFF_MASK | CAN_EFF_RTR_FLAGS)) { if (*mask == (CAN_EFF_MASK | CAN_EFF_RTR_FLAGS)) {
@ -525,8 +525,8 @@ void can_rx_unregister(struct net_device *dev, canid_t can_id, canid_t mask,
*/ */
hlist_for_each_entry_rcu(r, next, rl, list) { hlist_for_each_entry_rcu(r, next, rl, list) {
if (r->can_id == can_id && r->mask == mask if (r->can_id == can_id && r->mask == mask &&
&& r->func == func && r->data == data) r->func == func && r->data == data)
break; break;
} }

7
net/core/dev.c
View file

@ -2677,9 +2677,10 @@ __napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
return GRO_NORMAL; return GRO_NORMAL;
for (p = napi->gro_list; p; p = p->next) { for (p = napi->gro_list; p; p = p->next) {
NAPI_GRO_CB(p)->same_flow = (p->dev == skb->dev) NAPI_GRO_CB(p)->same_flow =
&& !compare_ether_header(skb_mac_header(p), (p->dev == skb->dev) &&
skb_gro_mac_header(skb)); !compare_ether_header(skb_mac_header(p),
skb_gro_mac_header(skb));
NAPI_GRO_CB(p)->flush = 0; NAPI_GRO_CB(p)->flush = 0;
} }

5
net/core/pktgen.c
View file

@ -2052,9 +2052,8 @@ static void pktgen_setup_inject(struct pktgen_dev *pkt_dev)
read_lock_bh(&idev->lock); read_lock_bh(&idev->lock);
for (ifp = idev->addr_list; ifp; for (ifp = idev->addr_list; ifp;
ifp = ifp->if_next) { ifp = ifp->if_next) {
if (ifp->scope == IFA_LINK if (ifp->scope == IFA_LINK &&
&& !(ifp-> !(ifp->flags & IFA_F_TENTATIVE)) {
flags & IFA_F_TENTATIVE)) {
ipv6_addr_copy(&pkt_dev-> ipv6_addr_copy(&pkt_dev->
cur_in6_saddr, cur_in6_saddr,
&ifp->addr); &ifp->addr);

4
net/dcb/dcbnl.c
View file

@ -1085,8 +1085,8 @@ static int dcbnl_bcn_setcfg(struct net_device *netdev, struct nlattr **tb,
u8 value_byte; u8 value_byte;
u32 value_int; u32 value_int;
if (!tb[DCB_ATTR_BCN] || !netdev->dcbnl_ops->setbcncfg if (!tb[DCB_ATTR_BCN] || !netdev->dcbnl_ops->setbcncfg ||
|| !netdev->dcbnl_ops->setbcnrp) !netdev->dcbnl_ops->setbcnrp)
return ret; return ret;
ret = nla_parse_nested(data, DCB_BCN_ATTR_MAX, ret = nla_parse_nested(data, DCB_BCN_ATTR_MAX,

5
net/decnet/dn_table.c
View file

@ -581,8 +581,9 @@ static int dn_fib_table_insert(struct dn_fib_table *tb, struct rtmsg *r, struct
DN_FIB_SCAN_KEY(f, fp, key) { DN_FIB_SCAN_KEY(f, fp, key) {
if (fi->fib_priority != DN_FIB_INFO(f)->fib_priority) if (fi->fib_priority != DN_FIB_INFO(f)->fib_priority)
break; break;
if (f->fn_type == type && f->fn_scope == r->rtm_scope if (f->fn_type == type &&
&& DN_FIB_INFO(f) == fi) f->fn_scope == r->rtm_scope &&
DN_FIB_INFO(f) == fi)
goto out; goto out;
} }

5
net/ipv4/igmp.c
View file

@ -1899,8 +1899,9 @@ int ip_mc_source(int add, int omode, struct sock *sk, struct
err = -EADDRNOTAVAIL; err = -EADDRNOTAVAIL;
for (pmc=inet->mc_list; pmc; pmc=pmc->next) { for (pmc=inet->mc_list; pmc; pmc=pmc->next) {
if (pmc->multi.imr_multiaddr.s_addr == imr.imr_multiaddr.s_addr if ((pmc->multi.imr_multiaddr.s_addr ==
&& pmc->multi.imr_ifindex == imr.imr_ifindex) imr.imr_multiaddr.s_addr) &&
(pmc->multi.imr_ifindex == imr.imr_ifindex))
break; break;
} }
if (!pmc) { /* must have a prior join */ if (!pmc) { /* must have a prior join */

8
net/ipv4/netfilter.c
View file

@ -155,10 +155,10 @@ static int nf_ip_reroute(struct sk_buff *skb,
if (entry->hook == NF_INET_LOCAL_OUT) { if (entry->hook == NF_INET_LOCAL_OUT) {
const struct iphdr *iph = ip_hdr(skb); const struct iphdr *iph = ip_hdr(skb);
if (!(iph->tos == rt_info->tos if (!(iph->tos == rt_info->tos &&
&& skb->mark == rt_info->mark skb->mark == rt_info->mark &&
&& iph->daddr == rt_info->daddr iph->daddr == rt_info->daddr &&
&& iph->saddr == rt_info->saddr)) iph->saddr == rt_info->saddr))
return ip_route_me_harder(skb, RTN_UNSPEC); return ip_route_me_harder(skb, RTN_UNSPEC);
} }
return 0; return 0;

4
net/irda/irnet/irnet_irda.c
View file

@ -1403,8 +1403,8 @@ irnet_connect_indication(void * instance,
/* Socket already connecting ? On primary ? */ /* Socket already connecting ? On primary ? */
if(0 if(0
#ifdef ALLOW_SIMULT_CONNECT #ifdef ALLOW_SIMULT_CONNECT
|| ((irttp_is_primary(server->tsap) == 1) /* primary */ || ((irttp_is_primary(server->tsap) == 1) && /* primary */
&& (test_and_clear_bit(0, &new->ttp_connect))) (test_and_clear_bit(0, &new->ttp_connect)))
#endif /* ALLOW_SIMULT_CONNECT */ #endif /* ALLOW_SIMULT_CONNECT */
) )
{ {

6
net/mac80211/agg-rx.c
View file

@ -211,9 +211,9 @@ void ieee80211_process_addba_request(struct ieee80211_local *local,
* check if configuration can support the BA policy * check if configuration can support the BA policy
* and if buffer size does not exceeds max value */ * and if buffer size does not exceeds max value */
/* XXX: check own ht delayed BA capability?? */ /* XXX: check own ht delayed BA capability?? */
if (((ba_policy != 1) if (((ba_policy != 1) &&
&& (!(sta->sta.ht_cap.cap & IEEE80211_HT_CAP_DELAY_BA))) (!(sta->sta.ht_cap.cap & IEEE80211_HT_CAP_DELAY_BA))) ||
|| (buf_size > IEEE80211_MAX_AMPDU_BUF)) { (buf_size > IEEE80211_MAX_AMPDU_BUF)) {
status = WLAN_STATUS_INVALID_QOS_PARAM; status = WLAN_STATUS_INVALID_QOS_PARAM;
#ifdef CONFIG_MAC80211_HT_DEBUG #ifdef CONFIG_MAC80211_HT_DEBUG
if (net_ratelimit()) if (net_ratelimit())

4
net/mac80211/main.c
View file

@ -631,8 +631,8 @@ void ieee80211_unregister_hw(struct ieee80211_hw *hw)
sta_info_stop(local); sta_info_stop(local);
rate_control_deinitialize(local); rate_control_deinitialize(local);
if (skb_queue_len(&local->skb_queue) if (skb_queue_len(&local->skb_queue) ||
|| skb_queue_len(&local->skb_queue_unreliable)) skb_queue_len(&local->skb_queue_unreliable))
printk(KERN_WARNING "%s: skb_queue not empty\n", printk(KERN_WARNING "%s: skb_queue not empty\n",
wiphy_name(local->hw.wiphy)); wiphy_name(local->hw.wiphy));
skb_queue_purge(&local->skb_queue); skb_queue_purge(&local->skb_queue);

4
net/mac80211/mesh.c
View file

@ -195,8 +195,8 @@ int mesh_rmc_check(u8 *sa, struct ieee80211s_hdr *mesh_hdr,
list_del(&p->list); list_del(&p->list);
kmem_cache_free(rm_cache, p); kmem_cache_free(rm_cache, p);
--entries; --entries;
} else if ((seqnum == p->seqnum) } else if ((seqnum == p->seqnum) &&
&& (memcmp(sa, p->sa, ETH_ALEN) == 0)) (memcmp(sa, p->sa, ETH_ALEN) == 0))
return -1; return -1;
} }

15
net/mac80211/mesh_hwmp.c
View file

@ -936,17 +936,16 @@ int mesh_nexthop_lookup(struct sk_buff *skb,
} }
if (mpath->flags & MESH_PATH_ACTIVE) { if (mpath->flags & MESH_PATH_ACTIVE) {
if (time_after(jiffies, mpath->exp_time + if (time_after(jiffies,
msecs_to_jiffies(sdata->u.mesh.mshcfg.path_refresh_time)) mpath->exp_time +
&& !memcmp(sdata->dev->dev_addr, hdr->addr4, msecs_to_jiffies(sdata->u.mesh.mshcfg.path_refresh_time)) &&
ETH_ALEN) !memcmp(sdata->dev->dev_addr, hdr->addr4, ETH_ALEN) &&
&& !(mpath->flags & MESH_PATH_RESOLVING) !(mpath->flags & MESH_PATH_RESOLVING) &&
&& !(mpath->flags & MESH_PATH_FIXED)) { !(mpath->flags & MESH_PATH_FIXED)) {
mesh_queue_preq(mpath, mesh_queue_preq(mpath,
PREQ_Q_F_START | PREQ_Q_F_REFRESH); PREQ_Q_F_START | PREQ_Q_F_REFRESH);
} }
memcpy(hdr->addr1, mpath->next_hop->sta.addr, memcpy(hdr->addr1, mpath->next_hop->sta.addr, ETH_ALEN);
ETH_ALEN);
} else { } else {
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
if (!(mpath->flags & MESH_PATH_RESOLVING)) { if (!(mpath->flags & MESH_PATH_RESOLVING)) {

4
net/mac80211/rx.c
View file

@ -1168,8 +1168,8 @@ ieee80211_drop_unencrypted(struct ieee80211_rx_data *rx, __le16 fc)
rx->key)) rx->key))
return -EACCES; return -EACCES;
/* BIP does not use Protected field, so need to check MMIE */ /* BIP does not use Protected field, so need to check MMIE */
if (unlikely(ieee80211_is_multicast_robust_mgmt_frame(rx->skb) if (unlikely(ieee80211_is_multicast_robust_mgmt_frame(rx->skb) &&
&& ieee80211_get_mmie_keyidx(rx->skb) < 0 && ieee80211_get_mmie_keyidx(rx->skb) < 0 &&
rx->key)) rx->key))
return -EACCES; return -EACCES;
/* /*

9
net/mac80211/tx.c
View file

@ -366,10 +366,11 @@ ieee80211_tx_h_unicast_ps_buf(struct ieee80211_tx_data *tx)
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data; struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
u32 staflags; u32 staflags;
if (unlikely(!sta || ieee80211_is_probe_resp(hdr->frame_control) if (unlikely(!sta ||
|| ieee80211_is_auth(hdr->frame_control) ieee80211_is_probe_resp(hdr->frame_control) ||
|| ieee80211_is_assoc_resp(hdr->frame_control) ieee80211_is_auth(hdr->frame_control) ||
|| ieee80211_is_reassoc_resp(hdr->frame_control))) ieee80211_is_assoc_resp(hdr->frame_control) ||
ieee80211_is_reassoc_resp(hdr->frame_control)))
return TX_CONTINUE; return TX_CONTINUE;
staflags = get_sta_flags(sta); staflags = get_sta_flags(sta);

6
net/netfilter/nf_conntrack_expect.c
View file

@ -202,9 +202,9 @@ static inline int expect_clash(const struct nf_conntrack_expect *a,
static inline int expect_matches(const struct nf_conntrack_expect *a, static inline int expect_matches(const struct nf_conntrack_expect *a,
const struct nf_conntrack_expect *b) const struct nf_conntrack_expect *b)
{ {
return a->master == b->master && a->class == b->class return a->master == b->master && a->class == b->class &&
&& nf_ct_tuple_equal(&a->tuple, &b->tuple) nf_ct_tuple_equal(&a->tuple, &b->tuple) &&
&& nf_ct_tuple_mask_equal(&a->mask, &b->mask); nf_ct_tuple_mask_equal(&a->mask, &b->mask);
} }
/* Generally a bad idea to call this: could have matched already. */ /* Generally a bad idea to call this: could have matched already. */

8
net/netfilter/nf_conntrack_ftp.c
View file

@ -243,8 +243,8 @@ static int try_epsv_response(const char *data, size_t dlen,
/* Three delimiters. */ /* Three delimiters. */
if (dlen <= 3) return 0; if (dlen <= 3) return 0;
delim = data[0]; delim = data[0];
if (isdigit(delim) || delim < 33 || delim > 126 if (isdigit(delim) || delim < 33 || delim > 126 ||
|| data[1] != delim || data[2] != delim) data[1] != delim || data[2] != delim)
return 0; return 0;
return get_port(data, 3, dlen, delim, &cmd->u.tcp.port); return get_port(data, 3, dlen, delim, &cmd->u.tcp.port);
@ -366,8 +366,8 @@ static int help(struct sk_buff *skb,
typeof(nf_nat_ftp_hook) nf_nat_ftp; typeof(nf_nat_ftp_hook) nf_nat_ftp;
/* Until there's been traffic both ways, don't look in packets. */ /* Until there's been traffic both ways, don't look in packets. */
if (ctinfo != IP_CT_ESTABLISHED if (ctinfo != IP_CT_ESTABLISHED &&
&& ctinfo != IP_CT_ESTABLISHED+IP_CT_IS_REPLY) { ctinfo != IP_CT_ESTABLISHED + IP_CT_IS_REPLY) {
pr_debug("ftp: Conntrackinfo = %u\n", ctinfo); pr_debug("ftp: Conntrackinfo = %u\n", ctinfo);
return NF_ACCEPT; return NF_ACCEPT;
} }

7
net/packet/af_packet.c
View file

@ -1034,9 +1034,10 @@ static int tpacket_snd(struct packet_sock *po, struct msghdr *msg)
goto out_xmit; goto out_xmit;
packet_increment_head(&po->tx_ring); packet_increment_head(&po->tx_ring);
len_sum += tp_len; len_sum += tp_len;
} while (likely((ph != NULL) || ((!(msg->msg_flags & MSG_DONTWAIT)) } while (likely((ph != NULL) ||
&& (atomic_read(&po->tx_ring.pending)))) ((!(msg->msg_flags & MSG_DONTWAIT)) &&
); (atomic_read(&po->tx_ring.pending))))
);
err = len_sum; err = len_sum;
goto out_put; goto out_put;

4
net/phonet/pep.c
View file

@ -714,8 +714,8 @@ static int pep_ioctl(struct sock *sk, int cmd, unsigned long arg)
return -EINVAL; return -EINVAL;
lock_sock(sk); lock_sock(sk);
if (sock_flag(sk, SOCK_URGINLINE) if (sock_flag(sk, SOCK_URGINLINE) &&
&& !skb_queue_empty(&pn->ctrlreq_queue)) !skb_queue_empty(&pn->ctrlreq_queue))
answ = skb_peek(&pn->ctrlreq_queue)->len; answ = skb_peek(&pn->ctrlreq_queue)->len;
else if (!skb_queue_empty(&sk->sk_receive_queue)) else if (!skb_queue_empty(&sk->sk_receive_queue))
answ = skb_peek(&sk->sk_receive_queue)->len; answ = skb_peek(&sk->sk_receive_queue)->len;

4
net/phonet/socket.c
View file

@ -98,8 +98,8 @@ struct sock *pn_find_sock_by_sa(struct net *net, const struct sockaddr_pn *spn)
if (pn->resource != res) if (pn->resource != res)
continue; continue;
} }
if (pn_addr(pn->sobject) if (pn_addr(pn->sobject) &&
&& pn_addr(pn->sobject) != pn_addr(obj)) pn_addr(pn->sobject) != pn_addr(obj))
continue; continue;
rval = sknode; rval = sknode;

8
net/rds/af_rds.c
View file

@ -174,8 +174,8 @@ static unsigned int rds_poll(struct file *file, struct socket *sock,
mask |= (POLLIN | POLLRDNORM); mask |= (POLLIN | POLLRDNORM);
spin_unlock(&rs->rs_lock); spin_unlock(&rs->rs_lock);
} }
if (!list_empty(&rs->rs_recv_queue) if (!list_empty(&rs->rs_recv_queue) ||
|| !list_empty(&rs->rs_notify_queue)) !list_empty(&rs->rs_notify_queue))
mask |= (POLLIN | POLLRDNORM); mask |= (POLLIN | POLLRDNORM);
if (rs->rs_snd_bytes < rds_sk_sndbuf(rs)) if (rs->rs_snd_bytes < rds_sk_sndbuf(rs))
mask |= (POLLOUT | POLLWRNORM); mask |= (POLLOUT | POLLWRNORM);
@ -308,8 +308,8 @@ static int rds_getsockopt(struct socket *sock, int level, int optname,
if (len < sizeof(int)) if (len < sizeof(int))
ret = -EINVAL; ret = -EINVAL;
else else
if (put_user(rs->rs_recverr, (int __user *) optval) if (put_user(rs->rs_recverr, (int __user *) optval) ||
|| put_user(sizeof(int), optlen)) put_user(sizeof(int), optlen))
ret = -EFAULT; ret = -EFAULT;
else else
ret = 0; ret = 0;

6
net/rds/connection.c
View file

@ -133,10 +133,8 @@ static struct rds_connection *__rds_conn_create(__be32 laddr, __be32 faddr,
spin_lock_irqsave(&rds_conn_lock, flags); spin_lock_irqsave(&rds_conn_lock, flags);
conn = rds_conn_lookup(head, laddr, faddr, trans); conn = rds_conn_lookup(head, laddr, faddr, trans);
if (conn if (conn && conn->c_loopback && conn->c_trans != &rds_loop_transport &&
&& conn->c_loopback !is_outgoing) {
&& conn->c_trans != &rds_loop_transport
&& !is_outgoing) {
/* This is a looped back IB connection, and we're /* This is a looped back IB connection, and we're
* called by the code handling the incoming connect. * called by the code handling the incoming connect.
* We need a second connection object into which we * We need a second connection object into which we

4
net/rds/ib_cm.c
View file

@ -377,8 +377,8 @@ static u32 rds_ib_protocol_compatible(struct rdma_cm_event *event)
} }
/* Even if len is crap *now* I still want to check it. -ASG */ /* Even if len is crap *now* I still want to check it. -ASG */
if (event->param.conn.private_data_len < sizeof (*dp) if (event->param.conn.private_data_len < sizeof (*dp) ||
|| dp->dp_protocol_major == 0) dp->dp_protocol_major == 0)
return RDS_PROTOCOL_3_0; return RDS_PROTOCOL_3_0;
common = be16_to_cpu(dp->dp_protocol_minor_mask) & RDS_IB_SUPPORTED_PROTOCOLS; common = be16_to_cpu(dp->dp_protocol_minor_mask) & RDS_IB_SUPPORTED_PROTOCOLS;

4
net/rds/ib_rdma.c
View file

@ -570,8 +570,8 @@ void rds_ib_free_mr(void *trans_private, int invalidate)
spin_unlock_irqrestore(&pool->list_lock, flags); spin_unlock_irqrestore(&pool->list_lock, flags);
/* If we've pinned too many pages, request a flush */ /* If we've pinned too many pages, request a flush */
if (atomic_read(&pool->free_pinned) >= pool->max_free_pinned if (atomic_read(&pool->free_pinned) >= pool->max_free_pinned ||
|| atomic_read(&pool->dirty_count) >= pool->max_items / 10) atomic_read(&pool->dirty_count) >= pool->max_items / 10)
queue_work(rds_wq, &pool->flush_worker); queue_work(rds_wq, &pool->flush_worker);
if (invalidate) { if (invalidate) {

12
net/rds/ib_recv.c
View file

@ -230,8 +230,8 @@ int rds_ib_recv_refill(struct rds_connection *conn, gfp_t kptr_gfp,
int ret = 0; int ret = 0;
u32 pos; u32 pos;
while ((prefill || rds_conn_up(conn)) while ((prefill || rds_conn_up(conn)) &&
&& rds_ib_ring_alloc(&ic->i_recv_ring, 1, &pos)) { rds_ib_ring_alloc(&ic->i_recv_ring, 1, &pos)) {
if (pos >= ic->i_recv_ring.w_nr) { if (pos >= ic->i_recv_ring.w_nr) {
printk(KERN_NOTICE "Argh - ring alloc returned pos=%u\n", printk(KERN_NOTICE "Argh - ring alloc returned pos=%u\n",
pos); pos);
@ -771,10 +771,10 @@ static void rds_ib_process_recv(struct rds_connection *conn,
hdr = &ibinc->ii_inc.i_hdr; hdr = &ibinc->ii_inc.i_hdr;
/* We can't just use memcmp here; fragments of a /* We can't just use memcmp here; fragments of a
* single message may carry different ACKs */ * single message may carry different ACKs */
if (hdr->h_sequence != ihdr->h_sequence if (hdr->h_sequence != ihdr->h_sequence ||
|| hdr->h_len != ihdr->h_len hdr->h_len != ihdr->h_len ||
|| hdr->h_sport != ihdr->h_sport hdr->h_sport != ihdr->h_sport ||
|| hdr->h_dport != ihdr->h_dport) { hdr->h_dport != ihdr->h_dport) {
rds_ib_conn_error(conn, rds_ib_conn_error(conn,
"fragment header mismatch; forcing reconnect\n"); "fragment header mismatch; forcing reconnect\n");
return; return;

4
net/rds/ib_send.c
View file

@ -252,8 +252,8 @@ void rds_ib_send_cq_comp_handler(struct ib_cq *cq, void *context)
rds_ib_ring_free(&ic->i_send_ring, completed); rds_ib_ring_free(&ic->i_send_ring, completed);
if (test_and_clear_bit(RDS_LL_SEND_FULL, &conn->c_flags) if (test_and_clear_bit(RDS_LL_SEND_FULL, &conn->c_flags) ||
|| test_bit(0, &conn->c_map_queued)) test_bit(0, &conn->c_map_queued))
queue_delayed_work(rds_wq, &conn->c_send_w, 0); queue_delayed_work(rds_wq, &conn->c_send_w, 0);
/* We expect errors as the qp is drained during shutdown */ /* We expect errors as the qp is drained during shutdown */

4
net/rds/iw_rdma.c
View file

@ -573,8 +573,8 @@ void rds_iw_free_mr(void *trans_private, int invalidate)
rds_iw_free_fastreg(pool, ibmr); rds_iw_free_fastreg(pool, ibmr);
/* If we've pinned too many pages, request a flush */ /* If we've pinned too many pages, request a flush */
if (atomic_read(&pool->free_pinned) >= pool->max_free_pinned if (atomic_read(&pool->free_pinned) >= pool->max_free_pinned ||
|| atomic_read(&pool->dirty_count) >= pool->max_items / 10) atomic_read(&pool->dirty_count) >= pool->max_items / 10)
queue_work(rds_wq, &pool->flush_worker); queue_work(rds_wq, &pool->flush_worker);
if (invalidate) { if (invalidate) {

12
net/rds/iw_recv.c
View file

@ -230,8 +230,8 @@ int rds_iw_recv_refill(struct rds_connection *conn, gfp_t kptr_gfp,
int ret = 0; int ret = 0;
u32 pos; u32 pos;
while ((prefill || rds_conn_up(conn)) while ((prefill || rds_conn_up(conn)) &&
&& rds_iw_ring_alloc(&ic->i_recv_ring, 1, &pos)) { rds_iw_ring_alloc(&ic->i_recv_ring, 1, &pos)) {
if (pos >= ic->i_recv_ring.w_nr) { if (pos >= ic->i_recv_ring.w_nr) {
printk(KERN_NOTICE "Argh - ring alloc returned pos=%u\n", printk(KERN_NOTICE "Argh - ring alloc returned pos=%u\n",
pos); pos);
@ -730,10 +730,10 @@ static void rds_iw_process_recv(struct rds_connection *conn,
hdr = &iwinc->ii_inc.i_hdr; hdr = &iwinc->ii_inc.i_hdr;
/* We can't just use memcmp here; fragments of a /* We can't just use memcmp here; fragments of a
* single message may carry different ACKs */ * single message may carry different ACKs */
if (hdr->h_sequence != ihdr->h_sequence if (hdr->h_sequence != ihdr->h_sequence ||
|| hdr->h_len != ihdr->h_len hdr->h_len != ihdr->h_len ||
|| hdr->h_sport != ihdr->h_sport hdr->h_sport != ihdr->h_sport ||
|| hdr->h_dport != ihdr->h_dport) { hdr->h_dport != ihdr->h_dport) {
rds_iw_conn_error(conn, rds_iw_conn_error(conn,
"fragment header mismatch; forcing reconnect\n"); "fragment header mismatch; forcing reconnect\n");
return; return;

7
net/rds/iw_send.c
View file

@ -288,8 +288,8 @@ void rds_iw_send_cq_comp_handler(struct ib_cq *cq, void *context)
rds_iw_ring_free(&ic->i_send_ring, completed); rds_iw_ring_free(&ic->i_send_ring, completed);
if (test_and_clear_bit(RDS_LL_SEND_FULL, &conn->c_flags) if (test_and_clear_bit(RDS_LL_SEND_FULL, &conn->c_flags) ||
|| test_bit(0, &conn->c_map_queued)) test_bit(0, &conn->c_map_queued))
queue_delayed_work(rds_wq, &conn->c_send_w, 0); queue_delayed_work(rds_wq, &conn->c_send_w, 0);
/* We expect errors as the qp is drained during shutdown */ /* We expect errors as the qp is drained during shutdown */
@ -519,8 +519,7 @@ int rds_iw_xmit(struct rds_connection *conn, struct rds_message *rm,
BUG_ON(hdr_off != 0 && hdr_off != sizeof(struct rds_header)); BUG_ON(hdr_off != 0 && hdr_off != sizeof(struct rds_header));
/* Fastreg support */ /* Fastreg support */
if (rds_rdma_cookie_key(rm->m_rdma_cookie) if (rds_rdma_cookie_key(rm->m_rdma_cookie) && !ic->i_fastreg_posted) {
&& !ic->i_fastreg_posted) {
ret = -EAGAIN; ret = -EAGAIN;
goto out; goto out;
} }

3
net/rds/message.c
View file

@ -122,8 +122,7 @@ int rds_message_add_extension(struct rds_header *hdr,
if (hdr->h_exthdr[0] != RDS_EXTHDR_NONE) if (hdr->h_exthdr[0] != RDS_EXTHDR_NONE)
return 0; return 0;
if (type >= __RDS_EXTHDR_MAX if (type >= __RDS_EXTHDR_MAX || len != rds_exthdr_size[type])
|| len != rds_exthdr_size[type])
return 0; return 0;
if (ext_len >= RDS_HEADER_EXT_SPACE) if (ext_len >= RDS_HEADER_EXT_SPACE)

12
net/rds/rdma.c
View file

@ -631,8 +631,8 @@ int rds_cmsg_rdma_args(struct rds_sock *rs, struct rds_message *rm,
{ {
struct rds_rdma_op *op; struct rds_rdma_op *op;
if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct rds_rdma_args)) if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct rds_rdma_args)) ||
|| rm->m_rdma_op != NULL) rm->m_rdma_op != NULL)
return -EINVAL; return -EINVAL;
op = rds_rdma_prepare(rs, CMSG_DATA(cmsg)); op = rds_rdma_prepare(rs, CMSG_DATA(cmsg));
@ -655,8 +655,8 @@ int rds_cmsg_rdma_dest(struct rds_sock *rs, struct rds_message *rm,
u32 r_key; u32 r_key;
int err = 0; int err = 0;
if (cmsg->cmsg_len < CMSG_LEN(sizeof(rds_rdma_cookie_t)) if (cmsg->cmsg_len < CMSG_LEN(sizeof(rds_rdma_cookie_t)) ||
|| rm->m_rdma_cookie != 0) rm->m_rdma_cookie != 0)
return -EINVAL; return -EINVAL;
memcpy(&rm->m_rdma_cookie, CMSG_DATA(cmsg), sizeof(rm->m_rdma_cookie)); memcpy(&rm->m_rdma_cookie, CMSG_DATA(cmsg), sizeof(rm->m_rdma_cookie));
@ -692,8 +692,8 @@ int rds_cmsg_rdma_dest(struct rds_sock *rs, struct rds_message *rm,
int rds_cmsg_rdma_map(struct rds_sock *rs, struct rds_message *rm, int rds_cmsg_rdma_map(struct rds_sock *rs, struct rds_message *rm,
struct cmsghdr *cmsg) struct cmsghdr *cmsg)
{ {
if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct rds_get_mr_args)) if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct rds_get_mr_args)) ||
|| rm->m_rdma_cookie != 0) rm->m_rdma_cookie != 0)
return -EINVAL; return -EINVAL;
return __rds_rdma_map(rs, CMSG_DATA(cmsg), &rm->m_rdma_cookie, &rm->m_rdma_mr); return __rds_rdma_map(rs, CMSG_DATA(cmsg), &rm->m_rdma_cookie, &rm->m_rdma_mr);

11
net/rds/recv.c
View file

@ -195,8 +195,8 @@ void rds_recv_incoming(struct rds_connection *conn, __be32 saddr, __be32 daddr,
* XXX we could spend more on the wire to get more robust failure * XXX we could spend more on the wire to get more robust failure
* detection, arguably worth it to avoid data corruption. * detection, arguably worth it to avoid data corruption.
*/ */
if (be64_to_cpu(inc->i_hdr.h_sequence) < conn->c_next_rx_seq if (be64_to_cpu(inc->i_hdr.h_sequence) < conn->c_next_rx_seq &&
&& (inc->i_hdr.h_flags & RDS_FLAG_RETRANSMITTED)) { (inc->i_hdr.h_flags & RDS_FLAG_RETRANSMITTED)) {
rds_stats_inc(s_recv_drop_old_seq); rds_stats_inc(s_recv_drop_old_seq);
goto out; goto out;
} }
@ -432,10 +432,9 @@ int rds_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
} }
timeo = wait_event_interruptible_timeout(*sk->sk_sleep, timeo = wait_event_interruptible_timeout(*sk->sk_sleep,
(!list_empty(&rs->rs_notify_queue) (!list_empty(&rs->rs_notify_queue) ||
|| rs->rs_cong_notify rs->rs_cong_notify ||
|| rds_next_incoming(rs, &inc)), rds_next_incoming(rs, &inc)), timeo);
timeo);
rdsdebug("recvmsg woke inc %p timeo %ld\n", inc, rdsdebug("recvmsg woke inc %p timeo %ld\n", inc,
timeo); timeo);
if (timeo > 0 || timeo == MAX_SCHEDULE_TIMEOUT) if (timeo > 0 || timeo == MAX_SCHEDULE_TIMEOUT)

27
net/rds/send.c
View file

@ -235,8 +235,8 @@ int rds_send_xmit(struct rds_connection *conn)
* connection. * connection.
* Therefore, we never retransmit messages with RDMA ops. * Therefore, we never retransmit messages with RDMA ops.
*/ */
if (rm->m_rdma_op if (rm->m_rdma_op &&
&& test_bit(RDS_MSG_RETRANSMITTED, &rm->m_flags)) { test_bit(RDS_MSG_RETRANSMITTED, &rm->m_flags)) {
spin_lock_irqsave(&conn->c_lock, flags); spin_lock_irqsave(&conn->c_lock, flags);
if (test_and_clear_bit(RDS_MSG_ON_CONN, &rm->m_flags)) if (test_and_clear_bit(RDS_MSG_ON_CONN, &rm->m_flags))
list_move(&rm->m_conn_item, &to_be_dropped); list_move(&rm->m_conn_item, &to_be_dropped);
@ -247,8 +247,8 @@ int rds_send_xmit(struct rds_connection *conn)
/* Require an ACK every once in a while */ /* Require an ACK every once in a while */
len = ntohl(rm->m_inc.i_hdr.h_len); len = ntohl(rm->m_inc.i_hdr.h_len);
if (conn->c_unacked_packets == 0 if (conn->c_unacked_packets == 0 ||
|| conn->c_unacked_bytes < len) { conn->c_unacked_bytes < len) {
__set_bit(RDS_MSG_ACK_REQUIRED, &rm->m_flags); __set_bit(RDS_MSG_ACK_REQUIRED, &rm->m_flags);
conn->c_unacked_packets = rds_sysctl_max_unacked_packets; conn->c_unacked_packets = rds_sysctl_max_unacked_packets;
@ -418,8 +418,8 @@ void rds_rdma_send_complete(struct rds_message *rm, int status)
spin_lock(&rm->m_rs_lock); spin_lock(&rm->m_rs_lock);
ro = rm->m_rdma_op; ro = rm->m_rdma_op;
if (test_bit(RDS_MSG_ON_SOCK, &rm->m_flags) if (test_bit(RDS_MSG_ON_SOCK, &rm->m_flags) &&
&& ro && ro->r_notify && ro->r_notifier) { ro && ro->r_notify && ro->r_notifier) {
notifier = ro->r_notifier; notifier = ro->r_notifier;
rs = rm->m_rs; rs = rm->m_rs;
sock_hold(rds_rs_to_sk(rs)); sock_hold(rds_rs_to_sk(rs));
@ -549,8 +549,7 @@ void rds_send_remove_from_sock(struct list_head *messages, int status)
list_del_init(&rm->m_sock_item); list_del_init(&rm->m_sock_item);
rds_send_sndbuf_remove(rs, rm); rds_send_sndbuf_remove(rs, rm);
if (ro && ro->r_notifier if (ro && ro->r_notifier && (status || ro->r_notify)) {
&& (status || ro->r_notify)) {
notifier = ro->r_notifier; notifier = ro->r_notifier;
list_add_tail(&notifier->n_list, list_add_tail(&notifier->n_list,
&rs->rs_notify_queue); &rs->rs_notify_queue);
@ -877,8 +876,8 @@ int rds_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
if (ret) if (ret)
goto out; goto out;
if ((rm->m_rdma_cookie || rm->m_rdma_op) if ((rm->m_rdma_cookie || rm->m_rdma_op) &&
&& conn->c_trans->xmit_rdma == NULL) { conn->c_trans->xmit_rdma == NULL) {
if (printk_ratelimit()) if (printk_ratelimit())
printk(KERN_NOTICE "rdma_op %p conn xmit_rdma %p\n", printk(KERN_NOTICE "rdma_op %p conn xmit_rdma %p\n",
rm->m_rdma_op, conn->c_trans->xmit_rdma); rm->m_rdma_op, conn->c_trans->xmit_rdma);
@ -890,8 +889,8 @@ int rds_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
* have scheduled a delayed reconnect however - in this case * have scheduled a delayed reconnect however - in this case
* we should not interfere. * we should not interfere.
*/ */
if (rds_conn_state(conn) == RDS_CONN_DOWN if (rds_conn_state(conn) == RDS_CONN_DOWN &&
&& !test_and_set_bit(RDS_RECONNECT_PENDING, &conn->c_flags)) !test_and_set_bit(RDS_RECONNECT_PENDING, &conn->c_flags))
queue_delayed_work(rds_wq, &conn->c_conn_w, 0); queue_delayed_work(rds_wq, &conn->c_conn_w, 0);
ret = rds_cong_wait(conn->c_fcong, dport, nonblock, rs); ret = rds_cong_wait(conn->c_fcong, dport, nonblock, rs);
@ -973,8 +972,8 @@ rds_send_pong(struct rds_connection *conn, __be16 dport)
* have scheduled a delayed reconnect however - in this case * have scheduled a delayed reconnect however - in this case
* we should not interfere. * we should not interfere.
*/ */
if (rds_conn_state(conn) == RDS_CONN_DOWN if (rds_conn_state(conn) == RDS_CONN_DOWN &&
&& !test_and_set_bit(RDS_RECONNECT_PENDING, &conn->c_flags)) !test_and_set_bit(RDS_RECONNECT_PENDING, &conn->c_flags))
queue_delayed_work(rds_wq, &conn->c_conn_w, 0); queue_delayed_work(rds_wq, &conn->c_conn_w, 0);
ret = rds_cong_wait(conn->c_fcong, dport, 1, NULL); ret = rds_cong_wait(conn->c_fcong, dport, 1, NULL);

4
net/rds/threads.c
View file

@ -170,8 +170,8 @@ void rds_shutdown_worker(struct work_struct *work)
* handler is supposed to check for state DISCONNECTING * handler is supposed to check for state DISCONNECTING
*/ */
mutex_lock(&conn->c_cm_lock); mutex_lock(&conn->c_cm_lock);
if (!rds_conn_transition(conn, RDS_CONN_UP, RDS_CONN_DISCONNECTING) if (!rds_conn_transition(conn, RDS_CONN_UP, RDS_CONN_DISCONNECTING) &&
&& !rds_conn_transition(conn, RDS_CONN_ERROR, RDS_CONN_DISCONNECTING)) { !rds_conn_transition(conn, RDS_CONN_ERROR, RDS_CONN_DISCONNECTING)) {
rds_conn_error(conn, "shutdown called in state %d\n", rds_conn_error(conn, "shutdown called in state %d\n",
atomic_read(&conn->c_state)); atomic_read(&conn->c_state));
mutex_unlock(&conn->c_cm_lock); mutex_unlock(&conn->c_cm_lock);

10
net/rose/rose_route.c
View file

@ -77,8 +77,9 @@ static int __must_check rose_add_node(struct rose_route_struct *rose_route,
rose_neigh = rose_neigh_list; rose_neigh = rose_neigh_list;
while (rose_neigh != NULL) { while (rose_neigh != NULL) {
if (ax25cmp(&rose_route->neighbour, &rose_neigh->callsign) == 0 if (ax25cmp(&rose_route->neighbour,
&& rose_neigh->dev == dev) &rose_neigh->callsign) == 0 &&
rose_neigh->dev == dev)
break; break;
rose_neigh = rose_neigh->next; rose_neigh = rose_neigh->next;
} }
@ -311,8 +312,9 @@ static int rose_del_node(struct rose_route_struct *rose_route,
rose_neigh = rose_neigh_list; rose_neigh = rose_neigh_list;
while (rose_neigh != NULL) { while (rose_neigh != NULL) {
if (ax25cmp(&rose_route->neighbour, &rose_neigh->callsign) == 0 if (ax25cmp(&rose_route->neighbour,
&& rose_neigh->dev == dev) &rose_neigh->callsign) == 0 &&
rose_neigh->dev == dev)
break; break;
rose_neigh = rose_neigh->next; rose_neigh = rose_neigh->next;
} }

28
net/sched/cls_rsvp.h
View file

@ -170,21 +170,23 @@ restart:
for (s = sht[h1]; s; s = s->next) { for (s = sht[h1]; s; s = s->next) {
if (dst[RSVP_DST_LEN-1] == s->dst[RSVP_DST_LEN-1] && if (dst[RSVP_DST_LEN-1] == s->dst[RSVP_DST_LEN-1] &&
protocol == s->protocol && protocol == s->protocol &&
!(s->dpi.mask & (*(u32*)(xprt+s->dpi.offset)^s->dpi.key)) !(s->dpi.mask &
(*(u32*)(xprt+s->dpi.offset)^s->dpi.key)) &&
#if RSVP_DST_LEN == 4 #if RSVP_DST_LEN == 4
&& dst[0] == s->dst[0] dst[0] == s->dst[0] &&
&& dst[1] == s->dst[1] dst[1] == s->dst[1] &&
&& dst[2] == s->dst[2] dst[2] == s->dst[2] &&
#endif #endif
&& tunnelid == s->tunnelid) { tunnelid == s->tunnelid) {
for (f = s->ht[h2]; f; f = f->next) { for (f = s->ht[h2]; f; f = f->next) {
if (src[RSVP_DST_LEN-1] == f->src[RSVP_DST_LEN-1] && if (src[RSVP_DST_LEN-1] == f->src[RSVP_DST_LEN-1] &&
!(f->spi.mask & (*(u32*)(xprt+f->spi.offset)^f->spi.key)) !(f->spi.mask & (*(u32*)(xprt+f->spi.offset)^f->spi.key))
#if RSVP_DST_LEN == 4 #if RSVP_DST_LEN == 4
&& src[0] == f->src[0] &&
&& src[1] == f->src[1] src[0] == f->src[0] &&
&& src[2] == f->src[2] src[1] == f->src[1] &&
src[2] == f->src[2]
#endif #endif
) { ) {
*res = f->res; *res = f->res;
@ -493,13 +495,13 @@ static int rsvp_change(struct tcf_proto *tp, unsigned long base,
for (sp = &data->ht[h1]; (s=*sp) != NULL; sp = &s->next) { for (sp = &data->ht[h1]; (s=*sp) != NULL; sp = &s->next) {
if (dst[RSVP_DST_LEN-1] == s->dst[RSVP_DST_LEN-1] && if (dst[RSVP_DST_LEN-1] == s->dst[RSVP_DST_LEN-1] &&
pinfo && pinfo->protocol == s->protocol && pinfo && pinfo->protocol == s->protocol &&
memcmp(&pinfo->dpi, &s->dpi, sizeof(s->dpi)) == 0 memcmp(&pinfo->dpi, &s->dpi, sizeof(s->dpi)) == 0 &&
#if RSVP_DST_LEN == 4 #if RSVP_DST_LEN == 4
&& dst[0] == s->dst[0] dst[0] == s->dst[0] &&
&& dst[1] == s->dst[1] dst[1] == s->dst[1] &&
&& dst[2] == s->dst[2] dst[2] == s->dst[2] &&
#endif #endif
&& pinfo->tunnelid == s->tunnelid) { pinfo->tunnelid == s->tunnelid) {
insert: insert:
/* OK, we found appropriate session */ /* OK, we found appropriate session */

4
net/sched/sch_htb.c
View file

@ -1344,8 +1344,8 @@ static int htb_change_class(struct Qdisc *sch, u32 classid,
}; };
/* check for valid classid */ /* check for valid classid */
if (!classid || TC_H_MAJ(classid ^ sch->handle) if (!classid || TC_H_MAJ(classid ^ sch->handle) ||
|| htb_find(classid, sch)) htb_find(classid, sch))
goto failure; goto failure;
/* check maximal depth */ /* check maximal depth */

12
net/sched/sch_netem.c
View file

@ -199,9 +199,9 @@ static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch)
* do it now in software before we mangle it. * do it now in software before we mangle it.
*/ */
if (q->corrupt && q->corrupt >= get_crandom(&q->corrupt_cor)) { if (q->corrupt && q->corrupt >= get_crandom(&q->corrupt_cor)) {
if (!(skb = skb_unshare(skb, GFP_ATOMIC)) if (!(skb = skb_unshare(skb, GFP_ATOMIC)) ||
|| (skb->ip_summed == CHECKSUM_PARTIAL (skb->ip_summed == CHECKSUM_PARTIAL &&
&& skb_checksum_help(skb))) { skb_checksum_help(skb))) {
sch->qstats.drops++; sch->qstats.drops++;
return NET_XMIT_DROP; return NET_XMIT_DROP;
} }
@ -210,9 +210,9 @@ static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch)
} }
cb = netem_skb_cb(skb); cb = netem_skb_cb(skb);
if (q->gap == 0 /* not doing reordering */ if (q->gap == 0 || /* not doing reordering */
|| q->counter < q->gap /* inside last reordering gap */ q->counter < q->gap || /* inside last reordering gap */
|| q->reorder < get_crandom(&q->reorder_cor)) { q->reorder < get_crandom(&q->reorder_cor)) {
psched_time_t now; psched_time_t now;
psched_tdiff_t delay; psched_tdiff_t delay;

11
net/sched/sch_teql.c
View file

@ -190,10 +190,13 @@ static int teql_qdisc_init(struct Qdisc *sch, struct nlattr *opt)
if (m->slaves) { if (m->slaves) {
if (m->dev->flags & IFF_UP) { if (m->dev->flags & IFF_UP) {
if ((m->dev->flags&IFF_POINTOPOINT && !(dev->flags&IFF_POINTOPOINT)) if ((m->dev->flags & IFF_POINTOPOINT &&
|| (m->dev->flags&IFF_BROADCAST && !(dev->flags&IFF_BROADCAST)) !(dev->flags & IFF_POINTOPOINT)) ||
|| (m->dev->flags&IFF_MULTICAST && !(dev->flags&IFF_MULTICAST)) (m->dev->flags & IFF_BROADCAST &&
|| dev->mtu < m->dev->mtu) !(dev->flags & IFF_BROADCAST)) ||
(m->dev->flags & IFF_MULTICAST &&
!(dev->flags & IFF_MULTICAST)) ||
dev->mtu < m->dev->mtu)
return -EINVAL; return -EINVAL;
} else { } else {
if (!(dev->flags&IFF_POINTOPOINT)) if (!(dev->flags&IFF_POINTOPOINT))

4
net/sctp/outqueue.c
View file

@ -191,8 +191,8 @@ static inline int sctp_cacc_skip(struct sctp_transport *primary,
__u32 tsn) __u32 tsn)
{ {
if (primary->cacc.changeover_active && if (primary->cacc.changeover_active &&
(sctp_cacc_skip_3_1(primary, transport, count_of_newacks) (sctp_cacc_skip_3_1(primary, transport, count_of_newacks) ||
|| sctp_cacc_skip_3_2(primary, tsn))) sctp_cacc_skip_3_2(primary, tsn)))
return 1; return 1;
return 0; return 0;
} }

4
net/sctp/socket.c
View file

@ -2356,8 +2356,8 @@ static int sctp_setsockopt_peer_addr_params(struct sock *sk,
pmtud_change == SPP_PMTUD || pmtud_change == SPP_PMTUD ||
sackdelay_change == SPP_SACKDELAY || sackdelay_change == SPP_SACKDELAY ||
params.spp_sackdelay > 500 || params.spp_sackdelay > 500 ||
(params.spp_pathmtu (params.spp_pathmtu &&
&& params.spp_pathmtu < SCTP_DEFAULT_MINSEGMENT)) params.spp_pathmtu < SCTP_DEFAULT_MINSEGMENT))
return -EINVAL; return -EINVAL;
/* If an address other than INADDR_ANY is specified, and /* If an address other than INADDR_ANY is specified, and

6
net/sunrpc/auth.c
View file

@ -332,9 +332,9 @@ rpcauth_lookup_credcache(struct rpc_auth *auth, struct auth_cred * acred,
list_add_tail(&new->cr_lru, &free); list_add_tail(&new->cr_lru, &free);
spin_unlock(&cache->lock); spin_unlock(&cache->lock);
found: found:
if (test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags) if (test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags) &&
&& cred->cr_ops->cr_init != NULL cred->cr_ops->cr_init != NULL &&
&& !(flags & RPCAUTH_LOOKUP_NEW)) { !(flags & RPCAUTH_LOOKUP_NEW)) {
int res = cred->cr_ops->cr_init(auth, cred); int res = cred->cr_ops->cr_init(auth, cred);
if (res < 0) { if (res < 0) {
put_rpccred(cred); put_rpccred(cred);

4
net/sunrpc/auth_gss/gss_krb5_seqnum.c
View file

@ -75,8 +75,8 @@ krb5_get_seq_num(struct crypto_blkcipher *key,
if ((code = krb5_decrypt(key, cksum, buf, plain, 8))) if ((code = krb5_decrypt(key, cksum, buf, plain, 8)))
return code; return code;
if ((plain[4] != plain[5]) || (plain[4] != plain[6]) if ((plain[4] != plain[5]) || (plain[4] != plain[6]) ||
|| (plain[4] != plain[7])) (plain[4] != plain[7]))
return (s32)KG_BAD_SEQ; return (s32)KG_BAD_SEQ;
*direction = plain[4]; *direction = plain[4];

4
net/sunrpc/auth_gss/svcauth_gss.c
View file

@ -105,8 +105,8 @@ static int rsi_match(struct cache_head *a, struct cache_head *b)
{ {
struct rsi *item = container_of(a, struct rsi, h); struct rsi *item = container_of(a, struct rsi, h);
struct rsi *tmp = container_of(b, struct rsi, h); struct rsi *tmp = container_of(b, struct rsi, h);
return netobj_equal(&item->in_handle, &tmp->in_handle) return netobj_equal(&item->in_handle, &tmp->in_handle) &&
&& netobj_equal(&item->in_token, &tmp->in_token); netobj_equal(&item->in_token, &tmp->in_token);
} }
static int dup_to_netobj(struct xdr_netobj *dst, char *src, int len) static int dup_to_netobj(struct xdr_netobj *dst, char *src, int len)

5
net/sunrpc/cache.c
View file

@ -401,9 +401,8 @@ static int cache_clean(void)
for (; ch; cp= & ch->next, ch= *cp) { for (; ch; cp= & ch->next, ch= *cp) {
if (current_detail->nextcheck > ch->expiry_time) if (current_detail->nextcheck > ch->expiry_time)
current_detail->nextcheck = ch->expiry_time+1; current_detail->nextcheck = ch->expiry_time+1;
if (ch->expiry_time >= get_seconds() if (ch->expiry_time >= get_seconds() &&
&& ch->last_refresh >= current_detail->flush_time ch->last_refresh >= current_detail->flush_time)
)
continue; continue;
if (test_and_clear_bit(CACHE_PENDING, &ch->flags)) if (test_and_clear_bit(CACHE_PENDING, &ch->flags))
cache_dequeue(current_detail, ch); cache_dequeue(current_detail, ch);

5
net/sunrpc/svc.c
View file

@ -1103,8 +1103,9 @@ svc_process_common(struct svc_rqst *rqstp, struct kvec *argv, struct kvec *resv)
procp->pc_release(rqstp, NULL, rqstp->rq_resp); procp->pc_release(rqstp, NULL, rqstp->rq_resp);
goto dropit; goto dropit;
} }
if (*statp == rpc_success && (xdr = procp->pc_encode) if (*statp == rpc_success &&
&& !xdr(rqstp, resv->iov_base+resv->iov_len, rqstp->rq_resp)) { (xdr = procp->pc_encode) &&
!xdr(rqstp, resv->iov_base+resv->iov_len, rqstp->rq_resp)) {
dprintk("svc: failed to encode reply\n"); dprintk("svc: failed to encode reply\n");
/* serv->sv_stats->rpcsystemerr++; */ /* serv->sv_stats->rpcsystemerr++; */
*statp = rpc_system_err; *statp = rpc_system_err;

8
net/sunrpc/svc_xprt.c
View file

@ -129,8 +129,8 @@ static void svc_xprt_free(struct kref *kref)
struct svc_xprt *xprt = struct svc_xprt *xprt =
container_of(kref, struct svc_xprt, xpt_ref); container_of(kref, struct svc_xprt, xpt_ref);
struct module *owner = xprt->xpt_class->xcl_owner; struct module *owner = xprt->xpt_class->xcl_owner;
if (test_bit(XPT_CACHE_AUTH, &xprt->xpt_flags) if (test_bit(XPT_CACHE_AUTH, &xprt->xpt_flags) &&
&& xprt->xpt_auth_cache != NULL) xprt->xpt_auth_cache != NULL)
svcauth_unix_info_release(xprt->xpt_auth_cache); svcauth_unix_info_release(xprt->xpt_auth_cache);
xprt->xpt_ops->xpo_free(xprt); xprt->xpt_ops->xpo_free(xprt);
module_put(owner); module_put(owner);
@ -846,8 +846,8 @@ static void svc_age_temp_xprts(unsigned long closure)
* through, close it. */ * through, close it. */
if (!test_and_set_bit(XPT_OLD, &xprt->xpt_flags)) if (!test_and_set_bit(XPT_OLD, &xprt->xpt_flags))
continue; continue;
if (atomic_read(&xprt->xpt_ref.refcount) > 1 if (atomic_read(&xprt->xpt_ref.refcount) > 1 ||
|| test_bit(XPT_BUSY, &xprt->xpt_flags)) test_bit(XPT_BUSY, &xprt->xpt_flags))
continue; continue;
svc_xprt_get(xprt); svc_xprt_get(xprt);
list_move(le, &to_be_aged); list_move(le, &to_be_aged);

4
net/sunrpc/svcauth.c
View file

@ -46,8 +46,8 @@ svc_authenticate(struct svc_rqst *rqstp, __be32 *authp)
dprintk("svc: svc_authenticate (%d)\n", flavor); dprintk("svc: svc_authenticate (%d)\n", flavor);
spin_lock(&authtab_lock); spin_lock(&authtab_lock);
if (flavor >= RPC_AUTH_MAXFLAVOR || !(aops = authtab[flavor]) if (flavor >= RPC_AUTH_MAXFLAVOR || !(aops = authtab[flavor]) ||
|| !try_module_get(aops->owner)) { !try_module_get(aops->owner)) {
spin_unlock(&authtab_lock); spin_unlock(&authtab_lock);
*authp = rpc_autherr_badcred; *authp = rpc_autherr_badcred;
return SVC_DENIED; return SVC_DENIED;

4
net/sunrpc/svcauth_unix.c
View file

@ -125,8 +125,8 @@ static int ip_map_match(struct cache_head *corig, struct cache_head *cnew)
{ {
struct ip_map *orig = container_of(corig, struct ip_map, h); struct ip_map *orig = container_of(corig, struct ip_map, h);
struct ip_map *new = container_of(cnew, struct ip_map, h); struct ip_map *new = container_of(cnew, struct ip_map, h);
return strcmp(orig->m_class, new->m_class) == 0 return strcmp(orig->m_class, new->m_class) == 0 &&
&& ipv6_addr_equal(&orig->m_addr, &new->m_addr); ipv6_addr_equal(&orig->m_addr, &new->m_addr);
} }
static void ip_map_init(struct cache_head *cnew, struct cache_head *citem) static void ip_map_init(struct cache_head *cnew, struct cache_head *citem)
{ {

7
net/sunrpc/xprtrdma/svc_rdma_recvfrom.c
View file

@ -337,10 +337,9 @@ static int rdma_set_ctxt_sge(struct svcxprt_rdma *xprt,
static int rdma_read_max_sge(struct svcxprt_rdma *xprt, int sge_count) static int rdma_read_max_sge(struct svcxprt_rdma *xprt, int sge_count)
{ {
if ((RDMA_TRANSPORT_IWARP == if ((rdma_node_get_transport(xprt->sc_cm_id->device->node_type) ==
rdma_node_get_transport(xprt->sc_cm_id-> RDMA_TRANSPORT_IWARP) &&
device->node_type)) sge_count > 1)
&& sge_count > 1)
return 1; return 1;
else else
return min_t(int, sge_count, xprt->sc_max_sge); return min_t(int, sge_count, xprt->sc_max_sge);

4
net/sunrpc/xprtrdma/verbs.c
View file

@ -878,8 +878,8 @@ if (strnicmp(ia->ri_id->device->dma_device->bus->name, "pci", 3) == 0) {
* others indicate a transport condition which has already * others indicate a transport condition which has already
* undergone a best-effort. * undergone a best-effort.
*/ */
if (ep->rep_connected == -ECONNREFUSED if (ep->rep_connected == -ECONNREFUSED &&
&& ++retry_count <= RDMA_CONNECT_RETRY_MAX) { ++retry_count <= RDMA_CONNECT_RETRY_MAX) {
dprintk("RPC: %s: non-peer_reject, retry\n", __func__); dprintk("RPC: %s: non-peer_reject, retry\n", __func__);
goto retry; goto retry;
} }

16
net/tipc/cluster.c
View file

@ -437,11 +437,11 @@ void tipc_cltr_recv_routing_table(struct sk_buff *buf)
break; break;
case ROUTE_ADDITION: case ROUTE_ADDITION:
if (!is_slave(tipc_own_addr)) { if (!is_slave(tipc_own_addr)) {
assert(!in_own_cluster(c_ptr->addr) assert(!in_own_cluster(c_ptr->addr) ||
|| is_slave(rem_node)); is_slave(rem_node));
} else { } else {
assert(in_own_cluster(c_ptr->addr) assert(in_own_cluster(c_ptr->addr) &&
&& !is_slave(rem_node)); !is_slave(rem_node));
} }
n_ptr = c_ptr->nodes[tipc_node(rem_node)]; n_ptr = c_ptr->nodes[tipc_node(rem_node)];
if (!n_ptr) if (!n_ptr)
@ -451,11 +451,11 @@ void tipc_cltr_recv_routing_table(struct sk_buff *buf)
break; break;
case ROUTE_REMOVAL: case ROUTE_REMOVAL:
if (!is_slave(tipc_own_addr)) { if (!is_slave(tipc_own_addr)) {
assert(!in_own_cluster(c_ptr->addr) assert(!in_own_cluster(c_ptr->addr) ||
|| is_slave(rem_node)); is_slave(rem_node));
} else { } else {
assert(in_own_cluster(c_ptr->addr) assert(in_own_cluster(c_ptr->addr) &&
&& !is_slave(rem_node)); !is_slave(rem_node));
} }
n_ptr = c_ptr->nodes[tipc_node(rem_node)]; n_ptr = c_ptr->nodes[tipc_node(rem_node)];
if (n_ptr) if (n_ptr)

12
net/tipc/link.c
View file

@ -378,8 +378,8 @@ static void link_timeout(struct link *l_ptr)
struct tipc_msg *msg = buf_msg(l_ptr->first_out); struct tipc_msg *msg = buf_msg(l_ptr->first_out);
u32 length = msg_size(msg); u32 length = msg_size(msg);
if ((msg_user(msg) == MSG_FRAGMENTER) if ((msg_user(msg) == MSG_FRAGMENTER) &&
&& (msg_type(msg) == FIRST_FRAGMENT)) { (msg_type(msg) == FIRST_FRAGMENT)) {
length = msg_size(msg_get_wrapped(msg)); length = msg_size(msg_get_wrapped(msg));
} }
if (length) { if (length) {
@ -2788,8 +2788,8 @@ int tipc_link_recv_fragment(struct sk_buff **pending, struct sk_buff **fb,
/* Is there an incomplete message waiting for this fragment? */ /* Is there an incomplete message waiting for this fragment? */
while (pbuf && ((msg_seqno(buf_msg(pbuf)) != long_msg_seq_no) while (pbuf && ((msg_seqno(buf_msg(pbuf)) != long_msg_seq_no) ||
|| (msg_orignode(fragm) != msg_orignode(buf_msg(pbuf))))) { (msg_orignode(fragm) != msg_orignode(buf_msg(pbuf))))) {
prev = pbuf; prev = pbuf;
pbuf = pbuf->next; pbuf = pbuf->next;
} }
@ -3325,8 +3325,8 @@ static void link_print(struct link *l_ptr, struct print_buf *buf,
(l_ptr->last_out)), l_ptr->out_queue_size); (l_ptr->last_out)), l_ptr->out_queue_size);
if ((mod(msg_seqno(buf_msg(l_ptr->last_out)) - if ((mod(msg_seqno(buf_msg(l_ptr->last_out)) -
msg_seqno(buf_msg(l_ptr->first_out))) msg_seqno(buf_msg(l_ptr->first_out)))
!= (l_ptr->out_queue_size - 1)) != (l_ptr->out_queue_size - 1)) ||
|| (l_ptr->last_out->next != NULL)) { (l_ptr->last_out->next != NULL)) {
tipc_printf(buf, "\nSend queue inconsistency\n"); tipc_printf(buf, "\nSend queue inconsistency\n");
tipc_printf(buf, "first_out= %x ", l_ptr->first_out); tipc_printf(buf, "first_out= %x ", l_ptr->first_out);
tipc_printf(buf, "next_out= %x ", l_ptr->next_out); tipc_printf(buf, "next_out= %x ", l_ptr->next_out);

12
net/tipc/socket.c
View file

@ -1136,13 +1136,11 @@ restart:
/* Loop around if more data is required */ /* Loop around if more data is required */
if ((sz_copied < buf_len) /* didn't get all requested data */ if ((sz_copied < buf_len) && /* didn't get all requested data */
&& (!skb_queue_empty(&sk->sk_receive_queue) || (!skb_queue_empty(&sk->sk_receive_queue) ||
(flags & MSG_WAITALL)) (flags & MSG_WAITALL)) && /* and more is ready or required */
/* ... and more is ready or required */ (!(flags & MSG_PEEK)) && /* and aren't just peeking at data */
&& (!(flags & MSG_PEEK)) /* ... and aren't just peeking at data */ (!err)) /* and haven't reached a FIN */
&& (!err) /* ... and haven't reached a FIN */
)
goto restart; goto restart;
exit: exit:

6
net/tipc/subscr.c
View file

@ -364,9 +364,9 @@ static struct subscription *subscr_subscribe(struct tipc_subscr *s,
sub->seq.upper = htohl(s->seq.upper, swap); sub->seq.upper = htohl(s->seq.upper, swap);
sub->timeout = htohl(s->timeout, swap); sub->timeout = htohl(s->timeout, swap);
sub->filter = htohl(s->filter, swap); sub->filter = htohl(s->filter, swap);
if ((!(sub->filter & TIPC_SUB_PORTS) if ((!(sub->filter & TIPC_SUB_PORTS) ==
== !(sub->filter & TIPC_SUB_SERVICE)) !(sub->filter & TIPC_SUB_SERVICE)) ||
|| (sub->seq.lower > sub->seq.upper)) { (sub->seq.lower > sub->seq.upper)) {
warn("Subscription rejected, illegal request\n"); warn("Subscription rejected, illegal request\n");
kfree(sub); kfree(sub);
subscr_terminate(subscriber); subscr_terminate(subscriber);

8
net/unix/af_unix.c
View file

@ -1033,8 +1033,8 @@ static int unix_stream_connect(struct socket *sock, struct sockaddr *uaddr,
goto out; goto out;
addr_len = err; addr_len = err;
if (test_bit(SOCK_PASSCRED, &sock->flags) if (test_bit(SOCK_PASSCRED, &sock->flags) && !u->addr &&
&& !u->addr && (err = unix_autobind(sock)) != 0) (err = unix_autobind(sock)) != 0)
goto out; goto out;
timeo = sock_sndtimeo(sk, flags & O_NONBLOCK); timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
@ -1378,8 +1378,8 @@ static int unix_dgram_sendmsg(struct kiocb *kiocb, struct socket *sock,
goto out; goto out;
} }
if (test_bit(SOCK_PASSCRED, &sock->flags) if (test_bit(SOCK_PASSCRED, &sock->flags) && !u->addr
&& !u->addr && (err = unix_autobind(sock)) != 0) && (err = unix_autobind(sock)) != 0)
goto out; goto out;
err = -EMSGSIZE; err = -EMSGSIZE;

8
net/wimax/op-rfkill.c
View file

@ -107,8 +107,8 @@ void wimax_report_rfkill_hw(struct wimax_dev *wimax_dev,
if (state != wimax_dev->rf_hw) { if (state != wimax_dev->rf_hw) {
wimax_dev->rf_hw = state; wimax_dev->rf_hw = state;
if (wimax_dev->rf_hw == WIMAX_RF_ON if (wimax_dev->rf_hw == WIMAX_RF_ON &&
&& wimax_dev->rf_sw == WIMAX_RF_ON) wimax_dev->rf_sw == WIMAX_RF_ON)
wimax_state = WIMAX_ST_READY; wimax_state = WIMAX_ST_READY;
else else
wimax_state = WIMAX_ST_RADIO_OFF; wimax_state = WIMAX_ST_RADIO_OFF;
@ -163,8 +163,8 @@ void wimax_report_rfkill_sw(struct wimax_dev *wimax_dev,
if (state != wimax_dev->rf_sw) { if (state != wimax_dev->rf_sw) {
wimax_dev->rf_sw = state; wimax_dev->rf_sw = state;
if (wimax_dev->rf_hw == WIMAX_RF_ON if (wimax_dev->rf_hw == WIMAX_RF_ON &&
&& wimax_dev->rf_sw == WIMAX_RF_ON) wimax_dev->rf_sw == WIMAX_RF_ON)
wimax_state = WIMAX_ST_READY; wimax_state = WIMAX_ST_READY;
else else
wimax_state = WIMAX_ST_RADIO_OFF; wimax_state = WIMAX_ST_RADIO_OFF;

4
net/wireless/scan.c
View file

@ -937,8 +937,8 @@ ieee80211_bss(struct wiphy *wiphy, struct iw_request_info *info,
ie += ie[1] + 2; ie += ie[1] + 2;
} }
if (bss->pub.capability & (WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_IBSS) if (bss->pub.capability & (WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_IBSS) ||
|| ismesh) { ismesh) {
memset(&iwe, 0, sizeof(iwe)); memset(&iwe, 0, sizeof(iwe));
iwe.cmd = SIOCGIWMODE; iwe.cmd = SIOCGIWMODE;
if (ismesh) if (ismesh)

5
net/wireless/wext-core.c
View file

@ -911,8 +911,9 @@ static int wireless_process_ioctl(struct net *net, struct ifreq *ifr,
*/ */
static int wext_permission_check(unsigned int cmd) static int wext_permission_check(unsigned int cmd)
{ {
if ((IW_IS_SET(cmd) || cmd == SIOCGIWENCODE || cmd == SIOCGIWENCODEEXT) if ((IW_IS_SET(cmd) || cmd == SIOCGIWENCODE ||
&& !capable(CAP_NET_ADMIN)) cmd == SIOCGIWENCODEEXT) &&
!capable(CAP_NET_ADMIN))
return -EPERM; return -EPERM;
return 0; return 0;