Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next-2.6
* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next-2.6:
bnx2: Fix the behavior of ethtool when ONBOOT=no
qla3xxx: Don't sleep while holding lock.
qla3xxx: Give the PHY time to come out of reset.
ipv4 routing: Ensure that route cache entries are usable and reclaimable with caching is off
net: Move rx skb_orphan call to where needed
ipv6: Use correct data types for ICMPv6 type and code
net: let KS8842 driver depend on HAS_IOMEM
can: let SJA1000 driver depend on HAS_IOMEM
netxen: fix firmware init handshake
netxen: fix build with without CONFIG_PM
netfilter: xt_rateest: fix comparison with self
netfilter: xt_quota: fix incomplete initialization
netfilter: nf_log: fix direct userspace memory access in proc handler
netfilter: fix some sparse endianess warnings
netfilter: nf_conntrack: fix conntrack lookup race
netfilter: nf_conntrack: fix confirmation race condition
netfilter: nf_conntrack: death_by_timeout() fix
+150
-89
+1
drivers/net/Kconfig
+1
drivers/net/Kconfig
+9
-1
drivers/net/bnx2.c
+9
-1
drivers/net/bnx2.c
···
6825
6825
return 0;
6826
6826
}
6827
6827
6828
+
static u32
6829
+
bnx2_get_link(struct net_device *dev)
6830
+
{
6831
+
struct bnx2 *bp = netdev_priv(dev);
6832
+
6833
+
return bp->link_up;
6834
+
}
6835
+
6828
6836
static int
6829
6837
bnx2_get_eeprom_len(struct net_device *dev)
6830
6838
{
···
7400
7392
.get_wol = bnx2_get_wol,
7401
7393
.set_wol = bnx2_set_wol,
7402
7394
.nway_reset = bnx2_nway_reset,
7403
-
.get_link = ethtool_op_get_link,
7395
+
.get_link = bnx2_get_link,
7404
7396
.get_eeprom_len = bnx2_get_eeprom_len,
7405
7397
.get_eeprom = bnx2_get_eeprom,
7406
7398
.set_eeprom = bnx2_set_eeprom,
+1
-1
drivers/net/can/Kconfig
+1
-1
drivers/net/can/Kconfig
+21
-18
drivers/net/netxen/netxen_nic_init.c
+21
-18
drivers/net/netxen/netxen_nic_init.c
···
944
944
u32 val = 0;
945
945
int retries = 60;
946
946
947
-
if (!pegtune_val) {
948
-
do {
949
-
val = NXRD32(adapter, CRB_CMDPEG_STATE);
947
+
if (pegtune_val)
948
+
return 0;
950
949
951
-
if (val == PHAN_INITIALIZE_COMPLETE ||
952
-
val == PHAN_INITIALIZE_ACK)
953
-
return 0;
950
+
do {
951
+
val = NXRD32(adapter, CRB_CMDPEG_STATE);
954
952
955
-
msleep(500);
956
-
957
-
} while (--retries);
958
-
959
-
if (!retries) {
960
-
pegtune_val = NXRD32(adapter,
961
-
NETXEN_ROMUSB_GLB_PEGTUNE_DONE);
962
-
printk(KERN_WARNING "netxen_phantom_init: init failed, "
963
-
"pegtune_val=%x\n", pegtune_val);
964
-
return -1;
953
+
switch (val) {
954
+
case PHAN_INITIALIZE_COMPLETE:
955
+
case PHAN_INITIALIZE_ACK:
956
+
return 0;
957
+
case PHAN_INITIALIZE_FAILED:
958
+
goto out_err;
959
+
default:
960
+
break;
965
961
}
966
-
}
967
962
968
-
return 0;
963
+
msleep(500);
964
+
965
+
} while (--retries);
966
+
967
+
NXWR32(adapter, CRB_CMDPEG_STATE, PHAN_INITIALIZE_FAILED);
968
+
969
+
out_err:
970
+
dev_warn(&adapter->pdev->dev, "firmware init failed\n");
971
+
return -EIO;
969
972
}
970
973
971
974
static int
+6
-1
drivers/net/netxen/netxen_nic_main.c
+6
-1
drivers/net/netxen/netxen_nic_main.c
···
705
705
first_driver = (adapter->ahw.pci_func == 0);
706
706
707
707
if (!first_driver)
708
-
return 0;
708
+
goto wait_init;
709
709
710
710
first_boot = NXRD32(adapter, NETXEN_CAM_RAM(0x1fc));
711
711
···
752
752
| (_NETXEN_NIC_LINUX_SUBVERSION);
753
753
NXWR32(adapter, CRB_DRIVER_VERSION, val);
754
754
755
+
wait_init:
755
756
/* Handshake with the card before we register the devices. */
756
757
err = netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
757
758
if (err) {
···
1179
1178
free_netdev(netdev);
1180
1179
}
1181
1180
1181
+
#ifdef CONFIG_PM
1182
1182
static int
1183
1183
netxen_nic_suspend(struct pci_dev *pdev, pm_message_t state)
1184
1184
{
···
1244
1242
1245
1243
return 0;
1246
1244
}
1245
+
#endif
1247
1246
1248
1247
static int netxen_nic_open(struct net_device *netdev)
1249
1248
{
···
1774
1771
.id_table = netxen_pci_tbl,
1775
1772
.probe = netxen_nic_probe,
1776
1773
.remove = __devexit_p(netxen_nic_remove),
1774
+
#ifdef CONFIG_PM
1777
1775
.suspend = netxen_nic_suspend,
1778
1776
.resume = netxen_nic_resume
1777
+
#endif
1779
1778
};
1780
1779
1781
1780
/* Driver Registration on NetXen card */
+5
-1
drivers/net/qla3xxx.c
+5
-1
drivers/net/qla3xxx.c
···
3142
3142
(void __iomem *)port_regs;
3143
3143
u32 delay = 10;
3144
3144
int status = 0;
3145
+
unsigned long hw_flags = 0;
3145
3146
3146
3147
if(ql_mii_setup(qdev))
3147
3148
return -1;
···
3151
3150
ql_write_common_reg(qdev, &port_regs->CommonRegs.serialPortInterfaceReg,
3152
3151
(ISP_SERIAL_PORT_IF_WE |
3153
3152
(ISP_SERIAL_PORT_IF_WE << 16)));
3154
-
3153
+
/* Give the PHY time to come out of reset. */
3154
+
mdelay(100);
3155
3155
qdev->port_link_state = LS_DOWN;
3156
3156
netif_carrier_off(qdev->ndev);
3157
3157
···
3352
3350
value = ql_read_page0_reg(qdev, &port_regs->portStatus);
3353
3351
if (value & PORT_STATUS_IC)
3354
3352
break;
3353
+
spin_unlock_irqrestore(&qdev->hw_lock, hw_flags);
3355
3354
msleep(500);
3355
+
spin_lock_irqsave(&qdev->hw_lock, hw_flags);
3356
3356
} while (--delay);
3357
3357
3358
3358
if (delay == 0) {
+3
-3
include/linux/icmpv6.h
+3
-3
include/linux/icmpv6.h
···
175
175
176
176
177
177
extern void icmpv6_send(struct sk_buff *skb,
178
-
int type, int code,
178
+
u8 type, u8 code,
179
179
__u32 info,
180
180
struct net_device *dev);
181
181
182
182
extern int icmpv6_init(void);
183
-
extern int icmpv6_err_convert(int type, int code,
183
+
extern int icmpv6_err_convert(u8 type, u8 code,
184
184
int *err);
185
185
extern void icmpv6_cleanup(void);
186
186
extern void icmpv6_param_prob(struct sk_buff *skb,
187
-
int code, int pos);
187
+
u8 code, int pos);
188
188
189
189
struct flowi;
190
190
struct in6_addr;
+1
-1
include/net/protocol.h
+1
-1
include/net/protocol.h
+1
-1
include/net/rawv6.h
+1
-1
include/net/rawv6.h
+1
include/net/sctp/sctp.h
+1
include/net/sctp/sctp.h
+2
include/net/sock.h
+2
include/net/sock.h
···
1252
1252
1253
1253
static inline void skb_set_owner_w(struct sk_buff *skb, struct sock *sk)
1254
1254
{
1255
+
skb_orphan(skb);
1255
1256
skb->sk = sk;
1256
1257
skb->destructor = sock_wfree;
1257
1258
/*
···
1265
1264
1266
1265
static inline void skb_set_owner_r(struct sk_buff *skb, struct sock *sk)
1267
1266
{
1267
+
skb_orphan(skb);
1268
1268
skb->sk = sk;
1269
1269
skb->destructor = sock_rfree;
1270
1270
atomic_add(skb->truesize, &sk->sk_rmem_alloc);
+1
-1
include/net/xfrm.h
+1
-1
include/net/xfrm.h
···
1274
1274
struct xfrm6_tunnel {
1275
1275
int (*handler)(struct sk_buff *skb);
1276
1276
int (*err_handler)(struct sk_buff *skb, struct inet6_skb_parm *opt,
1277
-
int type, int code, int offset, __be32 info);
1277
+
u8 type, u8 code, int offset, __be32 info);
1278
1278
struct xfrm6_tunnel *next;
1279
1279
int priority;
1280
1280
};
+1
-2
net/ax25/ax25_in.c
+1
-2
net/ax25/ax25_in.c
···
437
437
int ax25_kiss_rcv(struct sk_buff *skb, struct net_device *dev,
438
438
struct packet_type *ptype, struct net_device *orig_dev)
439
439
{
440
-
skb->sk = NULL; /* Initially we don't know who it's for */
441
-
skb->destructor = NULL; /* Who initializes this, dammit?! */
440
+
skb_orphan(skb);
442
441
443
442
if (!net_eq(dev_net(dev), &init_net)) {
444
443
kfree_skb(skb);
-2
net/core/dev.c
-2
net/core/dev.c
+1
-1
net/dccp/ipv6.c
+1
-1
net/dccp/ipv6.c
···
85
85
}
86
86
87
87
static void dccp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
88
-
int type, int code, int offset, __be32 info)
88
+
u8 type, u8 code, int offset, __be32 info)
89
89
{
90
90
struct ipv6hdr *hdr = (struct ipv6hdr *)skb->data;
91
91
const struct dccp_hdr *dh = (struct dccp_hdr *)(skb->data + offset);
+23
-3
net/ipv4/route.c
+23
-3
net/ipv4/route.c
···
1093
1093
* If we drop it here, the callers have no way to resolve routes
1094
1094
* when we're not caching. Instead, just point *rp at rt, so
1095
1095
* the caller gets a single use out of the route
1096
+
* Note that we do rt_free on this new route entry, so that
1097
+
* once its refcount hits zero, we are still able to reap it
1098
+
* (Thanks Alexey)
1099
+
* Note also the rt_free uses call_rcu. We don't actually
1100
+
* need rcu protection here, this is just our path to get
1101
+
* on the route gc list.
1096
1102
*/
1097
-
goto report_and_exit;
1103
+
1104
+
if (rt->rt_type == RTN_UNICAST || rt->fl.iif == 0) {
1105
+
int err = arp_bind_neighbour(&rt->u.dst);
1106
+
if (err) {
1107
+
if (net_ratelimit())
1108
+
printk(KERN_WARNING
1109
+
"Neighbour table failure & not caching routes.\n");
1110
+
rt_drop(rt);
1111
+
return err;
1112
+
}
1113
+
}
1114
+
1115
+
rt_free(rt);
1116
+
goto skip_hashing;
1098
1117
}
1099
1118
1100
1119
rthp = &rt_hash_table[hash].chain;
···
1230
1211
#if RT_CACHE_DEBUG >= 2
1231
1212
if (rt->u.dst.rt_next) {
1232
1213
struct rtable *trt;
1233
-
printk(KERN_DEBUG "rt_cache @%02x: %pI4", hash, &rt->rt_dst);
1214
+
printk(KERN_DEBUG "rt_cache @%02x: %pI4",
1215
+
hash, &rt->rt_dst);
1234
1216
for (trt = rt->u.dst.rt_next; trt; trt = trt->u.dst.rt_next)
1235
1217
printk(" . %pI4", &trt->rt_dst);
1236
1218
printk("\n");
···
1246
1226
1247
1227
spin_unlock_bh(rt_hash_lock_addr(hash));
1248
1228
1249
-
report_and_exit:
1229
+
skip_hashing:
1250
1230
if (rp)
1251
1231
*rp = rt;
1252
1232
else
+1
-1
net/ipv6/ah6.c
+1
-1
net/ipv6/ah6.c
···
405
405
}
406
406
407
407
static void ah6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
408
-
int type, int code, int offset, __be32 info)
408
+
u8 type, u8 code, int offset, __be32 info)
409
409
{
410
410
struct net *net = dev_net(skb->dev);
411
411
struct ipv6hdr *iph = (struct ipv6hdr*)skb->data;
+1
-1
net/ipv6/esp6.c
+1
-1
net/ipv6/esp6.c
···
354
354
}
355
355
356
356
static void esp6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
357
-
int type, int code, int offset, __be32 info)
357
+
u8 type, u8 code, int offset, __be32 info)
358
358
{
359
359
struct net *net = dev_net(skb->dev);
360
360
struct ipv6hdr *iph = (struct ipv6hdr*)skb->data;
+6
-6
net/ipv6/icmp.c
+6
-6
net/ipv6/icmp.c
···
117
117
/*
118
118
* Slightly more convenient version of icmpv6_send.
119
119
*/
120
-
void icmpv6_param_prob(struct sk_buff *skb, int code, int pos)
120
+
void icmpv6_param_prob(struct sk_buff *skb, u8 code, int pos)
121
121
{
122
122
icmpv6_send(skb, ICMPV6_PARAMPROB, code, pos, skb->dev);
123
123
kfree_skb(skb);
···
161
161
/*
162
162
* Check the ICMP output rate limit
163
163
*/
164
-
static inline int icmpv6_xrlim_allow(struct sock *sk, int type,
164
+
static inline int icmpv6_xrlim_allow(struct sock *sk, u8 type,
165
165
struct flowi *fl)
166
166
{
167
167
struct dst_entry *dst;
···
305
305
/*
306
306
* Send an ICMP message in response to a packet in error
307
307
*/
308
-
void icmpv6_send(struct sk_buff *skb, int type, int code, __u32 info,
308
+
void icmpv6_send(struct sk_buff *skb, u8 type, u8 code, __u32 info,
309
309
struct net_device *dev)
310
310
{
311
311
struct net *net = dev_net(skb->dev);
···
590
590
icmpv6_xmit_unlock(sk);
591
591
}
592
592
593
-
static void icmpv6_notify(struct sk_buff *skb, int type, int code, __be32 info)
593
+
static void icmpv6_notify(struct sk_buff *skb, u8 type, u8 code, __be32 info)
594
594
{
595
595
struct inet6_protocol *ipprot;
596
596
int inner_offset;
···
643
643
struct in6_addr *saddr, *daddr;
644
644
struct ipv6hdr *orig_hdr;
645
645
struct icmp6hdr *hdr;
646
-
int type;
646
+
u8 type;
647
647
648
648
if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
649
649
struct sec_path *sp = skb_sec_path(skb);
···
914
914
},
915
915
};
916
916
917
-
int icmpv6_err_convert(int type, int code, int *err)
917
+
int icmpv6_err_convert(u8 type, u8 code, int *err)
918
918
{
919
919
int fatal = 0;
920
920
+9
-9
net/ipv6/ip6_tunnel.c
+9
-9
net/ipv6/ip6_tunnel.c
···
394
394
395
395
static int
396
396
ip6_tnl_err(struct sk_buff *skb, __u8 ipproto, struct inet6_skb_parm *opt,
397
-
int *type, int *code, int *msg, __u32 *info, int offset)
397
+
u8 *type, u8 *code, int *msg, __u32 *info, int offset)
398
398
{
399
399
struct ipv6hdr *ipv6h = (struct ipv6hdr *) skb->data;
400
400
struct ip6_tnl *t;
401
401
int rel_msg = 0;
402
-
int rel_type = ICMPV6_DEST_UNREACH;
403
-
int rel_code = ICMPV6_ADDR_UNREACH;
402
+
u8 rel_type = ICMPV6_DEST_UNREACH;
403
+
u8 rel_code = ICMPV6_ADDR_UNREACH;
404
404
__u32 rel_info = 0;
405
405
__u16 len;
406
406
int err = -ENOENT;
···
488
488
489
489
static int
490
490
ip4ip6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
491
-
int type, int code, int offset, __be32 info)
491
+
u8 type, u8 code, int offset, __be32 info)
492
492
{
493
493
int rel_msg = 0;
494
-
int rel_type = type;
495
-
int rel_code = code;
494
+
u8 rel_type = type;
495
+
u8 rel_code = code;
496
496
__u32 rel_info = ntohl(info);
497
497
int err;
498
498
struct sk_buff *skb2;
···
586
586
587
587
static int
588
588
ip6ip6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
589
-
int type, int code, int offset, __be32 info)
589
+
u8 type, u8 code, int offset, __be32 info)
590
590
{
591
591
int rel_msg = 0;
592
-
int rel_type = type;
593
-
int rel_code = code;
592
+
u8 rel_type = type;
593
+
u8 rel_code = code;
594
594
__u32 rel_info = ntohl(info);
595
595
int err;
596
596
+1
-1
net/ipv6/ipcomp6.c
+1
-1
net/ipv6/ipcomp6.c
+1
-1
net/ipv6/mip6.c
+1
-1
net/ipv6/mip6.c
+2
-2
net/ipv6/raw.c
+2
-2
net/ipv6/raw.c
···
310
310
311
311
static void rawv6_err(struct sock *sk, struct sk_buff *skb,
312
312
struct inet6_skb_parm *opt,
313
-
int type, int code, int offset, __be32 info)
313
+
u8 type, u8 code, int offset, __be32 info)
314
314
{
315
315
struct inet_sock *inet = inet_sk(sk);
316
316
struct ipv6_pinfo *np = inet6_sk(sk);
···
343
343
}
344
344
345
345
void raw6_icmp_error(struct sk_buff *skb, int nexthdr,
346
-
int type, int code, int inner_offset, __be32 info)
346
+
u8 type, u8 code, int inner_offset, __be32 info)
347
347
{
348
348
struct sock *sk;
349
349
int hash;
+1
-1
net/ipv6/route.c
+1
-1
net/ipv6/route.c
···
1865
1865
* Drop the packet on the floor
1866
1866
*/
1867
1867
1868
-
static int ip6_pkt_drop(struct sk_buff *skb, int code, int ipstats_mib_noroutes)
1868
+
static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
1869
1869
{
1870
1870
int type;
1871
1871
struct dst_entry *dst = skb_dst(skb);
+1
-1
net/ipv6/tcp_ipv6.c
+1
-1
net/ipv6/tcp_ipv6.c
···
317
317
}
318
318
319
319
static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
320
-
int type, int code, int offset, __be32 info)
320
+
u8 type, u8 code, int offset, __be32 info)
321
321
{
322
322
struct ipv6hdr *hdr = (struct ipv6hdr*)skb->data;
323
323
const struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
+1
-1
net/ipv6/tunnel6.c
+1
-1
net/ipv6/tunnel6.c
+3
-3
net/ipv6/udp.c
+3
-3
net/ipv6/udp.c
···
312
312
}
313
313
314
314
void __udp6_lib_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
315
-
int type, int code, int offset, __be32 info,
315
+
u8 type, u8 code, int offset, __be32 info,
316
316
struct udp_table *udptable)
317
317
{
318
318
struct ipv6_pinfo *np;
···
346
346
}
347
347
348
348
static __inline__ void udpv6_err(struct sk_buff *skb,
349
-
struct inet6_skb_parm *opt, int type,
350
-
int code, int offset, __be32 info )
349
+
struct inet6_skb_parm *opt, u8 type,
350
+
u8 code, int offset, __be32 info )
351
351
{
352
352
__udp6_lib_err(skb, opt, type, code, offset, info, &udp_table);
353
353
}
+1
-1
net/ipv6/udp_impl.h
+1
-1
net/ipv6/udp_impl.h
···
9
9
10
10
extern int __udp6_lib_rcv(struct sk_buff *, struct udp_table *, int );
11
11
extern void __udp6_lib_err(struct sk_buff *, struct inet6_skb_parm *,
12
-
int , int , int , __be32 , struct udp_table *);
12
+
u8 , u8 , int , __be32 , struct udp_table *);
13
13
14
14
extern int udp_v6_get_port(struct sock *sk, unsigned short snum);
15
15
+1
-1
net/ipv6/udplite.c
+1
-1
net/ipv6/udplite.c
+1
-1
net/ipv6/xfrm6_tunnel.c
+1
-1
net/ipv6/xfrm6_tunnel.c
-3
net/irda/af_irda.c
-3
net/irda/af_irda.c
+1
net/irda/ircomm/ircomm_lmp.c
+1
net/irda/ircomm/ircomm_lmp.c
+20
-5
net/netfilter/nf_conntrack_core.c
+20
-5
net/netfilter/nf_conntrack_core.c
···
335
335
h = __nf_conntrack_find(net, tuple);
336
336
if (h) {
337
337
ct = nf_ct_tuplehash_to_ctrack(h);
338
-
if (unlikely(!atomic_inc_not_zero(&ct->ct_general.use)))
338
+
if (unlikely(nf_ct_is_dying(ct) ||
339
+
!atomic_inc_not_zero(&ct->ct_general.use)))
339
340
h = NULL;
340
341
else {
341
342
if (unlikely(!nf_ct_tuple_equal(tuple, &h->tuple))) {
···
426
425
/* Remove from unconfirmed list */
427
426
hlist_nulls_del_rcu(&ct->tuplehash[IP_CT_DIR_ORIGINAL].hnnode);
428
427
429
-
__nf_conntrack_hash_insert(ct, hash, repl_hash);
430
428
/* Timer relative to confirmation time, not original
431
429
setting time, otherwise we'd get timer wrap in
432
430
weird delay cases. */
···
433
433
add_timer(&ct->timeout);
434
434
atomic_inc(&ct->ct_general.use);
435
435
set_bit(IPS_CONFIRMED_BIT, &ct->status);
436
+
437
+
/* Since the lookup is lockless, hash insertion must be done after
438
+
* starting the timer and setting the CONFIRMED bit. The RCU barriers
439
+
* guarantee that no other CPU can find the conntrack before the above
440
+
* stores are visible.
441
+
*/
442
+
__nf_conntrack_hash_insert(ct, hash, repl_hash);
436
443
NF_CT_STAT_INC(net, insert);
437
444
spin_unlock_bh(&nf_conntrack_lock);
445
+
438
446
help = nfct_help(ct);
439
447
if (help && help->helper)
440
448
nf_conntrack_event_cache(IPCT_HELPER, ct);
···
511
503
cnt++;
512
504
}
513
505
514
-
if (ct && unlikely(!atomic_inc_not_zero(&ct->ct_general.use)))
506
+
if (ct && unlikely(nf_ct_is_dying(ct) ||
507
+
!atomic_inc_not_zero(&ct->ct_general.use)))
515
508
ct = NULL;
516
509
if (ct || cnt >= NF_CT_EVICTION_RANGE)
517
510
break;
···
1276
1267
return ret;
1277
1268
}
1278
1269
1270
+
/*
1271
+
* We need to use special "null" values, not used in hash table
1272
+
*/
1273
+
#define UNCONFIRMED_NULLS_VAL ((1<<30)+0)
1274
+
#define DYING_NULLS_VAL ((1<<30)+1)
1275
+
1279
1276
static int nf_conntrack_init_net(struct net *net)
1280
1277
{
1281
1278
int ret;
1282
1279
1283
1280
atomic_set(&net->ct.count, 0);
1284
-
INIT_HLIST_NULLS_HEAD(&net->ct.unconfirmed, 0);
1285
-
INIT_HLIST_NULLS_HEAD(&net->ct.dying, 0);
1281
+
INIT_HLIST_NULLS_HEAD(&net->ct.unconfirmed, UNCONFIRMED_NULLS_VAL);
1282
+
INIT_HLIST_NULLS_HEAD(&net->ct.dying, DYING_NULLS_VAL);
1286
1283
net->ct.stat = alloc_percpu(struct ip_conntrack_stat);
1287
1284
if (!net->ct.stat) {
1288
1285
ret = -ENOMEM;
+11
-5
net/netfilter/nf_log.c
+11
-5
net/netfilter/nf_log.c
···
47
47
mutex_lock(&nf_log_mutex);
48
48
49
49
if (pf == NFPROTO_UNSPEC) {
50
-
int i;
51
50
for (i = NFPROTO_UNSPEC; i < NFPROTO_NUMPROTO; i++)
52
51
list_add_tail(&(logger->list[i]), &(nf_loggers_l[i]));
53
52
} else {
···
215
216
#endif /* PROC_FS */
216
217
217
218
#ifdef CONFIG_SYSCTL
218
-
struct ctl_path nf_log_sysctl_path[] = {
219
+
static struct ctl_path nf_log_sysctl_path[] = {
219
220
{ .procname = "net", .ctl_name = CTL_NET, },
220
221
{ .procname = "netfilter", .ctl_name = NET_NETFILTER, },
221
222
{ .procname = "nf_log", .ctl_name = CTL_UNNUMBERED, },
···
227
228
static struct ctl_table_header *nf_log_dir_header;
228
229
229
230
static int nf_log_proc_dostring(ctl_table *table, int write, struct file *filp,
230
-
void *buffer, size_t *lenp, loff_t *ppos)
231
+
void __user *buffer, size_t *lenp, loff_t *ppos)
231
232
{
232
233
const struct nf_logger *logger;
234
+
char buf[NFLOGGER_NAME_LEN];
235
+
size_t size = *lenp;
233
236
int r = 0;
234
237
int tindex = (unsigned long)table->extra1;
235
238
236
239
if (write) {
237
-
if (!strcmp(buffer, "NONE")) {
240
+
if (size > sizeof(buf))
241
+
size = sizeof(buf);
242
+
if (copy_from_user(buf, buffer, size))
243
+
return -EFAULT;
244
+
245
+
if (!strcmp(buf, "NONE")) {
238
246
nf_log_unbind_pf(tindex);
239
247
return 0;
240
248
}
241
249
mutex_lock(&nf_log_mutex);
242
-
logger = __find_logger(tindex, buffer);
250
+
logger = __find_logger(tindex, buf);
243
251
if (logger == NULL) {
244
252
mutex_unlock(&nf_log_mutex);
245
253
return -ENOENT;
+4
-4
net/netfilter/xt_NFQUEUE.c
+4
-4
net/netfilter/xt_NFQUEUE.c
···
40
40
static u32 hash_v4(const struct sk_buff *skb)
41
41
{
42
42
const struct iphdr *iph = ip_hdr(skb);
43
-
u32 ipaddr;
43
+
__be32 ipaddr;
44
44
45
45
/* packets in either direction go into same queue */
46
46
ipaddr = iph->saddr ^ iph->daddr;
47
47
48
-
return jhash_2words(ipaddr, iph->protocol, jhash_initval);
48
+
return jhash_2words((__force u32)ipaddr, iph->protocol, jhash_initval);
49
49
}
50
50
51
51
static unsigned int
···
63
63
static u32 hash_v6(const struct sk_buff *skb)
64
64
{
65
65
const struct ipv6hdr *ip6h = ipv6_hdr(skb);
66
-
u32 addr[4];
66
+
__be32 addr[4];
67
67
68
68
addr[0] = ip6h->saddr.s6_addr32[0] ^ ip6h->daddr.s6_addr32[0];
69
69
addr[1] = ip6h->saddr.s6_addr32[1] ^ ip6h->daddr.s6_addr32[1];
70
70
addr[2] = ip6h->saddr.s6_addr32[2] ^ ip6h->daddr.s6_addr32[2];
71
71
addr[3] = ip6h->saddr.s6_addr32[3] ^ ip6h->daddr.s6_addr32[3];
72
72
73
-
return jhash2(addr, ARRAY_SIZE(addr), jhash_initval);
73
+
return jhash2((__force u32 *)addr, ARRAY_SIZE(addr), jhash_initval);
74
74
}
75
75
76
76
static unsigned int
+4
-4
net/netfilter/xt_cluster.c
+4
-4
net/netfilter/xt_cluster.c
···
15
15
#include <net/netfilter/nf_conntrack.h>
16
16
#include <linux/netfilter/xt_cluster.h>
17
17
18
-
static inline u_int32_t nf_ct_orig_ipv4_src(const struct nf_conn *ct)
18
+
static inline u32 nf_ct_orig_ipv4_src(const struct nf_conn *ct)
19
19
{
20
-
return ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.u3.ip;
20
+
return (__force u32)ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.u3.ip;
21
21
}
22
22
23
-
static inline const void *nf_ct_orig_ipv6_src(const struct nf_conn *ct)
23
+
static inline const u32 *nf_ct_orig_ipv6_src(const struct nf_conn *ct)
24
24
{
25
-
return ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.u3.ip6;
25
+
return (__force u32 *)ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.u3.ip6;
26
26
}
27
27
28
28
static inline u_int32_t
+1
net/netfilter/xt_quota.c
+1
net/netfilter/xt_quota.c
+1
-1
net/netfilter/xt_rateest.c
+1
-1
net/netfilter/xt_rateest.c
+1
-1
net/sctp/ipv6.c
+1
-1
net/sctp/ipv6.c