blob: e0516a22be2e06052da233423be8b88dde1680f4 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * PACKET - implements raw packet sockets.
7 *
Jesper Juhl02c30a82005-05-05 16:16:16 -07008 * Authors: Ross Biro
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
10 * Alan Cox, <gw4pts@gw4pts.ampr.org>
11 *
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +090012 * Fixes:
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 * Alan Cox : verify_area() now used correctly
14 * Alan Cox : new skbuff lists, look ma no backlogs!
15 * Alan Cox : tidied skbuff lists.
16 * Alan Cox : Now uses generic datagram routines I
17 * added. Also fixed the peek/read crash
18 * from all old Linux datagram code.
19 * Alan Cox : Uses the improved datagram code.
20 * Alan Cox : Added NULL's for socket options.
21 * Alan Cox : Re-commented the code.
22 * Alan Cox : Use new kernel side addressing
23 * Rob Janssen : Correct MTU usage.
24 * Dave Platt : Counter leaks caused by incorrect
25 * interrupt locking and some slightly
26 * dubious gcc output. Can you read
27 * compiler: it said _VOLATILE_
28 * Richard Kooijman : Timestamp fixes.
29 * Alan Cox : New buffers. Use sk->mac.raw.
30 * Alan Cox : sendmsg/recvmsg support.
31 * Alan Cox : Protocol setting support
32 * Alexey Kuznetsov : Untied from IPv4 stack.
33 * Cyrus Durgin : Fixed kerneld for kmod.
34 * Michal Ostrowski : Module initialization cleanup.
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +090035 * Ulises Alonso : Frame number limit removal and
Linus Torvalds1da177e2005-04-16 15:20:36 -070036 * packet_set_ring memory leak.
Eric W. Biederman0fb375f2005-09-21 00:11:37 -070037 * Eric Biederman : Allow for > 8 byte hardware addresses.
38 * The convention is that longer addresses
39 * will simply extend the hardware address
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +090040 * byte arrays at the end of sockaddr_ll
Eric W. Biederman0fb375f2005-09-21 00:11:37 -070041 * and packet_mreq.
Johann Baudy69e3c752009-05-18 22:11:22 -070042 * Johann Baudy : Added TX RING.
Linus Torvalds1da177e2005-04-16 15:20:36 -070043 *
44 * This program is free software; you can redistribute it and/or
45 * modify it under the terms of the GNU General Public License
46 * as published by the Free Software Foundation; either version
47 * 2 of the License, or (at your option) any later version.
48 *
49 */
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +090050
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#include <linux/types.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070052#include <linux/mm.h>
Randy Dunlap4fc268d2006-01-11 12:17:47 -080053#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070054#include <linux/fcntl.h>
55#include <linux/socket.h>
56#include <linux/in.h>
57#include <linux/inet.h>
58#include <linux/netdevice.h>
59#include <linux/if_packet.h>
60#include <linux/wireless.h>
Herbert Xuffbc6112007-02-04 23:33:10 -080061#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070062#include <linux/kmod.h>
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020063#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070064#include <net/ip.h>
65#include <net/protocol.h>
66#include <linux/skbuff.h>
67#include <net/sock.h>
68#include <linux/errno.h>
69#include <linux/timer.h>
70#include <asm/system.h>
71#include <asm/uaccess.h>
72#include <asm/ioctls.h>
73#include <asm/page.h>
Al Viroa1f8e7f2006-10-19 16:08:53 -040074#include <asm/cacheflush.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070075#include <asm/io.h>
76#include <linux/proc_fs.h>
77#include <linux/seq_file.h>
78#include <linux/poll.h>
79#include <linux/module.h>
80#include <linux/init.h>
Herbert Xu905db442009-01-30 14:12:06 -080081#include <linux/mutex.h>
Eric Dumazet05423b22009-10-26 18:40:35 -070082#include <linux/if_vlan.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070083
84#ifdef CONFIG_INET
85#include <net/inet_common.h>
86#endif
87
Linus Torvalds1da177e2005-04-16 15:20:36 -070088/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 Assumptions:
90 - if device has no dev->hard_header routine, it adds and removes ll header
91 inside itself. In this case ll header is invisible outside of device,
92 but higher levels still should reserve dev->hard_header_len.
93 Some devices are enough clever to reallocate skb, when header
94 will not fit to reserved space (tunnel), another ones are silly
95 (PPP).
96 - packet socket receives packets with pulled ll header,
97 so that SOCK_RAW should push it back.
98
99On receive:
100-----------
101
102Incoming, dev->hard_header!=NULL
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -0700103 mac_header -> ll header
104 data -> data
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105
106Outgoing, dev->hard_header!=NULL
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -0700107 mac_header -> ll header
108 data -> ll header
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
110Incoming, dev->hard_header==NULL
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -0700111 mac_header -> UNKNOWN position. It is very likely, that it points to ll
112 header. PPP makes it, that is wrong, because introduce
YOSHIFUJI Hideakidb0c58f2007-07-19 10:44:35 +0900113 assymetry between rx and tx paths.
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -0700114 data -> data
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115
116Outgoing, dev->hard_header==NULL
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -0700117 mac_header -> data. ll header is still not built!
118 data -> data
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119
120Resume
121 If dev->hard_header==NULL we are unlikely to restore sensible ll header.
122
123
124On transmit:
125------------
126
127dev->hard_header != NULL
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -0700128 mac_header -> ll header
129 data -> ll header
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130
131dev->hard_header == NULL (ll header is added by device, we cannot control it)
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -0700132 mac_header -> data
133 data -> data
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134
135 We should set nh.raw on output to correct posistion,
136 packet classifier depends on it.
137 */
138
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139/* Private packet socket structures. */
140
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000141struct packet_mclist {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 struct packet_mclist *next;
143 int ifindex;
144 int count;
145 unsigned short type;
146 unsigned short alen;
Eric W. Biederman0fb375f2005-09-21 00:11:37 -0700147 unsigned char addr[MAX_ADDR_LEN];
148};
149/* identical to struct packet_mreq except it has
150 * a longer address field.
151 */
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000152struct packet_mreq_max {
Eric W. Biederman0fb375f2005-09-21 00:11:37 -0700153 int mr_ifindex;
154 unsigned short mr_type;
155 unsigned short mr_alen;
156 unsigned char mr_address[MAX_ADDR_LEN];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157};
David S. Millera2efcfa2007-05-29 13:12:50 -0700158
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159#ifdef CONFIG_PACKET_MMAP
Johann Baudy69e3c752009-05-18 22:11:22 -0700160static int packet_set_ring(struct sock *sk, struct tpacket_req *req,
161 int closing, int tx_ring);
162
163struct packet_ring_buffer {
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000164 char **pg_vec;
Johann Baudy69e3c752009-05-18 22:11:22 -0700165 unsigned int head;
166 unsigned int frames_per_block;
167 unsigned int frame_size;
168 unsigned int frame_max;
169
170 unsigned int pg_vec_order;
171 unsigned int pg_vec_pages;
172 unsigned int pg_vec_len;
173
174 atomic_t pending;
175};
176
177struct packet_sock;
178static int tpacket_snd(struct packet_sock *po, struct msghdr *msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179#endif
180
181static void packet_flush_mclist(struct sock *sk);
182
183struct packet_sock {
184 /* struct sock has to be the first member of packet_sock */
185 struct sock sk;
186 struct tpacket_stats stats;
187#ifdef CONFIG_PACKET_MMAP
Johann Baudy69e3c752009-05-18 22:11:22 -0700188 struct packet_ring_buffer rx_ring;
189 struct packet_ring_buffer tx_ring;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 int copy_thresh;
191#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 spinlock_t bind_lock;
Herbert Xu905db442009-01-30 14:12:06 -0800193 struct mutex pg_vec_lock;
Herbert Xu8dc41942007-02-04 23:31:32 -0800194 unsigned int running:1, /* prot_hook is attached*/
Peter P. Waskiewicz Jr80feaac2007-04-20 16:05:39 -0700195 auxdata:1,
196 origdev:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 int ifindex; /* bound device */
Al Viro0e11c912006-11-08 00:26:29 -0800198 __be16 num;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 struct packet_mclist *mclist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200#ifdef CONFIG_PACKET_MMAP
201 atomic_t mapped;
Patrick McHardybbd6ef82008-07-14 22:50:15 -0700202 enum tpacket_versions tp_version;
203 unsigned int tp_hdrlen;
Patrick McHardy89133362008-07-18 18:05:19 -0700204 unsigned int tp_reserve;
Johann Baudy69e3c752009-05-18 22:11:22 -0700205 unsigned int tp_loss:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206#endif
Eric Dumazet94b05952009-10-16 04:02:20 +0000207 struct packet_type prot_hook ____cacheline_aligned_in_smp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208};
209
Herbert Xuffbc6112007-02-04 23:33:10 -0800210struct packet_skb_cb {
211 unsigned int origlen;
212 union {
213 struct sockaddr_pkt pkt;
214 struct sockaddr_ll ll;
215 } sa;
216};
217
218#define PACKET_SKB_CB(__skb) ((struct packet_skb_cb *)((__skb)->cb))
Herbert Xu8dc41942007-02-04 23:31:32 -0800219
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220#ifdef CONFIG_PACKET_MMAP
221
Patrick McHardybbd6ef82008-07-14 22:50:15 -0700222static void __packet_set_status(struct packet_sock *po, void *frame, int status)
223{
224 union {
225 struct tpacket_hdr *h1;
226 struct tpacket2_hdr *h2;
227 void *raw;
228 } h;
229
230 h.raw = frame;
231 switch (po->tp_version) {
232 case TPACKET_V1:
233 h.h1->tp_status = status;
Johann Baudy69e3c752009-05-18 22:11:22 -0700234 flush_dcache_page(virt_to_page(&h.h1->tp_status));
Patrick McHardybbd6ef82008-07-14 22:50:15 -0700235 break;
236 case TPACKET_V2:
237 h.h2->tp_status = status;
Johann Baudy69e3c752009-05-18 22:11:22 -0700238 flush_dcache_page(virt_to_page(&h.h2->tp_status));
Patrick McHardybbd6ef82008-07-14 22:50:15 -0700239 break;
Johann Baudy69e3c752009-05-18 22:11:22 -0700240 default:
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000241 pr_err("TPACKET version not supported\n");
Johann Baudy69e3c752009-05-18 22:11:22 -0700242 BUG();
243 }
244
245 smp_wmb();
246}
247
248static int __packet_get_status(struct packet_sock *po, void *frame)
249{
250 union {
251 struct tpacket_hdr *h1;
252 struct tpacket2_hdr *h2;
253 void *raw;
254 } h;
255
256 smp_rmb();
257
258 h.raw = frame;
259 switch (po->tp_version) {
260 case TPACKET_V1:
261 flush_dcache_page(virt_to_page(&h.h1->tp_status));
262 return h.h1->tp_status;
263 case TPACKET_V2:
264 flush_dcache_page(virt_to_page(&h.h2->tp_status));
265 return h.h2->tp_status;
266 default:
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000267 pr_err("TPACKET version not supported\n");
Johann Baudy69e3c752009-05-18 22:11:22 -0700268 BUG();
269 return 0;
Patrick McHardybbd6ef82008-07-14 22:50:15 -0700270 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271}
Johann Baudy69e3c752009-05-18 22:11:22 -0700272
273static void *packet_lookup_frame(struct packet_sock *po,
274 struct packet_ring_buffer *rb,
275 unsigned int position,
276 int status)
277{
278 unsigned int pg_vec_pos, frame_offset;
279 union {
280 struct tpacket_hdr *h1;
281 struct tpacket2_hdr *h2;
282 void *raw;
283 } h;
284
285 pg_vec_pos = position / rb->frames_per_block;
286 frame_offset = position % rb->frames_per_block;
287
288 h.raw = rb->pg_vec[pg_vec_pos] + (frame_offset * rb->frame_size);
289
290 if (status != __packet_get_status(po, h.raw))
291 return NULL;
292
293 return h.raw;
294}
295
296static inline void *packet_current_frame(struct packet_sock *po,
297 struct packet_ring_buffer *rb,
298 int status)
299{
300 return packet_lookup_frame(po, rb, rb->head, status);
301}
302
303static inline void *packet_previous_frame(struct packet_sock *po,
304 struct packet_ring_buffer *rb,
305 int status)
306{
307 unsigned int previous = rb->head ? rb->head - 1 : rb->frame_max;
308 return packet_lookup_frame(po, rb, previous, status);
309}
310
311static inline void packet_increment_head(struct packet_ring_buffer *buff)
312{
313 buff->head = buff->head != buff->frame_max ? buff->head+1 : 0;
314}
315
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316#endif
317
318static inline struct packet_sock *pkt_sk(struct sock *sk)
319{
320 return (struct packet_sock *)sk;
321}
322
323static void packet_sock_destruct(struct sock *sk)
324{
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700325 WARN_ON(atomic_read(&sk->sk_rmem_alloc));
326 WARN_ON(atomic_read(&sk->sk_wmem_alloc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327
328 if (!sock_flag(sk, SOCK_DEAD)) {
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000329 pr_err("Attempt to release alive packet socket: %p\n", sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 return;
331 }
332
Pavel Emelyanov17ab56a2007-11-10 21:38:48 -0800333 sk_refcnt_debug_dec(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334}
335
336
Eric Dumazet90ddc4f2005-12-22 12:49:22 -0800337static const struct proto_ops packet_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338
Eric Dumazet90ddc4f2005-12-22 12:49:22 -0800339static const struct proto_ops packet_ops_spkt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000341static int packet_rcv_spkt(struct sk_buff *skb, struct net_device *dev,
342 struct packet_type *pt, struct net_device *orig_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343{
344 struct sock *sk;
345 struct sockaddr_pkt *spkt;
346
347 /*
348 * When we registered the protocol we saved the socket in the data
349 * field for just this event.
350 */
351
352 sk = pt->af_packet_priv;
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +0900353
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 /*
355 * Yank back the headers [hope the device set this
356 * right or kerboom...]
357 *
358 * Incoming packets have ll header pulled,
359 * push it back.
360 *
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -0700361 * For outgoing ones skb->data == skb_mac_header(skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 * so that this procedure is noop.
363 */
364
365 if (skb->pkt_type == PACKET_LOOPBACK)
366 goto out;
367
Octavian Purdila09ad9bc2009-11-25 15:14:13 -0800368 if (!net_eq(dev_net(dev), sock_net(sk)))
Denis V. Lunevd12d01d2007-11-19 22:28:35 -0800369 goto out;
370
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000371 skb = skb_share_check(skb, GFP_ATOMIC);
372 if (skb == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 goto oom;
374
375 /* drop any routing info */
Eric Dumazetadf30902009-06-02 05:19:30 +0000376 skb_dst_drop(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377
Phil Oester84531c22005-07-12 11:57:52 -0700378 /* drop conntrack reference */
379 nf_reset(skb);
380
Herbert Xuffbc6112007-02-04 23:33:10 -0800381 spkt = &PACKET_SKB_CB(skb)->sa.pkt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -0700383 skb_push(skb, skb->data - skb_mac_header(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384
385 /*
386 * The SOCK_PACKET socket receives _all_ frames.
387 */
388
389 spkt->spkt_family = dev->type;
390 strlcpy(spkt->spkt_device, dev->name, sizeof(spkt->spkt_device));
391 spkt->spkt_protocol = skb->protocol;
392
393 /*
394 * Charge the memory to the socket. This is done specifically
395 * to prevent sockets using all the memory up.
396 */
397
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000398 if (sock_queue_rcv_skb(sk, skb) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 return 0;
400
401out:
402 kfree_skb(skb);
403oom:
404 return 0;
405}
406
407
408/*
409 * Output a raw packet to a device layer. This bypasses all the other
410 * protocol layers and you must therefore supply it with a complete frame
411 */
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +0900412
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413static int packet_sendmsg_spkt(struct kiocb *iocb, struct socket *sock,
414 struct msghdr *msg, size_t len)
415{
416 struct sock *sk = sock->sk;
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000417 struct sockaddr_pkt *saddr = (struct sockaddr_pkt *)msg->msg_name;
Eric Dumazet1a35ca82009-12-15 05:47:03 +0000418 struct sk_buff *skb = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 struct net_device *dev;
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000420 __be16 proto = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 int err;
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +0900422
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 /*
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +0900424 * Get and verify the address.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 */
426
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000427 if (saddr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 if (msg->msg_namelen < sizeof(struct sockaddr))
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000429 return -EINVAL;
430 if (msg->msg_namelen == sizeof(struct sockaddr_pkt))
431 proto = saddr->spkt_protocol;
432 } else
433 return -ENOTCONN; /* SOCK_PACKET must be sent giving an address */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434
435 /*
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +0900436 * Find the device first to size check it
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 */
438
439 saddr->spkt_device[13] = 0;
Eric Dumazet1a35ca82009-12-15 05:47:03 +0000440retry:
Eric Dumazet654d1f82009-11-02 10:43:32 +0100441 rcu_read_lock();
442 dev = dev_get_by_name_rcu(sock_net(sk), saddr->spkt_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 err = -ENODEV;
444 if (dev == NULL)
445 goto out_unlock;
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +0900446
David S. Millerd5e76b02007-01-25 19:30:36 -0800447 err = -ENETDOWN;
448 if (!(dev->flags & IFF_UP))
449 goto out_unlock;
450
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 /*
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000452 * You may not queue a frame bigger than the mtu. This is the lowest level
453 * raw protocol and you must do your own fragmentation at this level.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 */
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +0900455
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 err = -EMSGSIZE;
Kris Katterjohn8ae55f02006-01-23 16:28:02 -0800457 if (len > dev->mtu + dev->hard_header_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 goto out_unlock;
459
Eric Dumazet1a35ca82009-12-15 05:47:03 +0000460 if (!skb) {
461 size_t reserved = LL_RESERVED_SPACE(dev);
462 unsigned int hhlen = dev->header_ops ? dev->hard_header_len : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463
Eric Dumazet1a35ca82009-12-15 05:47:03 +0000464 rcu_read_unlock();
465 skb = sock_wmalloc(sk, len + reserved, 0, GFP_KERNEL);
466 if (skb == NULL)
467 return -ENOBUFS;
468 /* FIXME: Save some space for broken drivers that write a hard
469 * header at transmission time by themselves. PPP is the notable
470 * one here. This should really be fixed at the driver level.
471 */
472 skb_reserve(skb, reserved);
473 skb_reset_network_header(skb);
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +0900474
Eric Dumazet1a35ca82009-12-15 05:47:03 +0000475 /* Try to align data part correctly */
476 if (hhlen) {
477 skb->data -= hhlen;
478 skb->tail -= hhlen;
479 if (len < hhlen)
480 skb_reset_network_header(skb);
481 }
482 err = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
483 if (err)
484 goto out_free;
485 goto retry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 }
487
Eric Dumazet1a35ca82009-12-15 05:47:03 +0000488
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 skb->protocol = proto;
490 skb->dev = dev;
491 skb->priority = sk->sk_priority;
Eric Dumazet2d37a182009-10-01 19:14:46 +0000492 skb->mark = sk->sk_mark;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493
494 dev_queue_xmit(skb);
Eric Dumazet654d1f82009-11-02 10:43:32 +0100495 rcu_read_unlock();
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000496 return len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498out_unlock:
Eric Dumazet654d1f82009-11-02 10:43:32 +0100499 rcu_read_unlock();
Eric Dumazet1a35ca82009-12-15 05:47:03 +0000500out_free:
501 kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 return err;
503}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504
David S. Millerdbcb5852007-01-24 15:21:02 -0800505static inline unsigned int run_filter(struct sk_buff *skb, struct sock *sk,
506 unsigned int res)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507{
508 struct sk_filter *filter;
509
Dmitry Mishinfda9ef52006-08-31 15:28:39 -0700510 rcu_read_lock_bh();
511 filter = rcu_dereference(sk->sk_filter);
David S. Millerdbcb5852007-01-24 15:21:02 -0800512 if (filter != NULL)
513 res = sk_run_filter(skb, filter->insns, filter->len);
Dmitry Mishinfda9ef52006-08-31 15:28:39 -0700514 rcu_read_unlock_bh();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515
David S. Millerdbcb5852007-01-24 15:21:02 -0800516 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517}
518
519/*
520 This function makes lazy skb cloning in hope that most of packets
521 are discarded by BPF.
522
523 Note tricky part: we DO mangle shared skb! skb->data, skb->len
524 and skb->cb are mangled. It works because (and until) packets
525 falling here are owned by current CPU. Output packets are cloned
526 by dev_queue_xmit_nit(), input packets are processed by net_bh
527 sequencially, so that if we return skb to original state on exit,
528 we will not harm anyone.
529 */
530
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000531static int packet_rcv(struct sk_buff *skb, struct net_device *dev,
532 struct packet_type *pt, struct net_device *orig_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533{
534 struct sock *sk;
535 struct sockaddr_ll *sll;
536 struct packet_sock *po;
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000537 u8 *skb_head = skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 int skb_len = skb->len;
David S. Millerdbcb5852007-01-24 15:21:02 -0800539 unsigned int snaplen, res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540
541 if (skb->pkt_type == PACKET_LOOPBACK)
542 goto drop;
543
544 sk = pt->af_packet_priv;
545 po = pkt_sk(sk);
546
Octavian Purdila09ad9bc2009-11-25 15:14:13 -0800547 if (!net_eq(dev_net(dev), sock_net(sk)))
Denis V. Lunevd12d01d2007-11-19 22:28:35 -0800548 goto drop;
549
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 skb->dev = dev;
551
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700552 if (dev->header_ops) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 /* The device has an explicit notion of ll header,
554 exported to higher levels.
555
556 Otherwise, the device hides datails of it frame
557 structure, so that corresponding packet head
558 never delivered to user.
559 */
560 if (sk->sk_type != SOCK_DGRAM)
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -0700561 skb_push(skb, skb->data - skb_mac_header(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 else if (skb->pkt_type == PACKET_OUTGOING) {
563 /* Special case: outgoing packets have ll header at head */
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -0300564 skb_pull(skb, skb_network_offset(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 }
566 }
567
568 snaplen = skb->len;
569
David S. Millerdbcb5852007-01-24 15:21:02 -0800570 res = run_filter(skb, sk, snaplen);
571 if (!res)
Dmitry Mishinfda9ef52006-08-31 15:28:39 -0700572 goto drop_n_restore;
David S. Millerdbcb5852007-01-24 15:21:02 -0800573 if (snaplen > res)
574 snaplen = res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575
576 if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
577 (unsigned)sk->sk_rcvbuf)
578 goto drop_n_acct;
579
580 if (skb_shared(skb)) {
581 struct sk_buff *nskb = skb_clone(skb, GFP_ATOMIC);
582 if (nskb == NULL)
583 goto drop_n_acct;
584
585 if (skb_head != skb->data) {
586 skb->data = skb_head;
587 skb->len = skb_len;
588 }
589 kfree_skb(skb);
590 skb = nskb;
591 }
592
Herbert Xuffbc6112007-02-04 23:33:10 -0800593 BUILD_BUG_ON(sizeof(*PACKET_SKB_CB(skb)) + MAX_ADDR_LEN - 8 >
594 sizeof(skb->cb));
595
596 sll = &PACKET_SKB_CB(skb)->sa.ll;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 sll->sll_family = AF_PACKET;
598 sll->sll_hatype = dev->type;
599 sll->sll_protocol = skb->protocol;
600 sll->sll_pkttype = skb->pkt_type;
Peter P Waskiewicz Jr8032b462007-11-10 22:03:25 -0800601 if (unlikely(po->origdev))
Peter P. Waskiewicz Jr80feaac2007-04-20 16:05:39 -0700602 sll->sll_ifindex = orig_dev->ifindex;
603 else
604 sll->sll_ifindex = dev->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605
Stephen Hemmingerb95cce32007-09-26 22:13:38 -0700606 sll->sll_halen = dev_parse_header(skb, sll->sll_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607
Herbert Xuffbc6112007-02-04 23:33:10 -0800608 PACKET_SKB_CB(skb)->origlen = skb->len;
Herbert Xu8dc41942007-02-04 23:31:32 -0800609
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 if (pskb_trim(skb, snaplen))
611 goto drop_n_acct;
612
613 skb_set_owner_r(skb, sk);
614 skb->dev = NULL;
Eric Dumazetadf30902009-06-02 05:19:30 +0000615 skb_dst_drop(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616
Phil Oester84531c22005-07-12 11:57:52 -0700617 /* drop conntrack reference */
618 nf_reset(skb);
619
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 spin_lock(&sk->sk_receive_queue.lock);
621 po->stats.tp_packets++;
Neil Horman3b885782009-10-12 13:26:31 -0700622 skb->dropcount = atomic_read(&sk->sk_drops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 __skb_queue_tail(&sk->sk_receive_queue, skb);
624 spin_unlock(&sk->sk_receive_queue.lock);
625 sk->sk_data_ready(sk, skb->len);
626 return 0;
627
628drop_n_acct:
Neil Horman3b885782009-10-12 13:26:31 -0700629 po->stats.tp_drops = atomic_inc_return(&sk->sk_drops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630
631drop_n_restore:
632 if (skb_head != skb->data && skb_shared(skb)) {
633 skb->data = skb_head;
634 skb->len = skb_len;
635 }
636drop:
Neil Hormanead2ceb2009-03-11 09:49:55 +0000637 consume_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 return 0;
639}
640
641#ifdef CONFIG_PACKET_MMAP
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000642static int tpacket_rcv(struct sk_buff *skb, struct net_device *dev,
643 struct packet_type *pt, struct net_device *orig_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644{
645 struct sock *sk;
646 struct packet_sock *po;
647 struct sockaddr_ll *sll;
Patrick McHardybbd6ef82008-07-14 22:50:15 -0700648 union {
649 struct tpacket_hdr *h1;
650 struct tpacket2_hdr *h2;
651 void *raw;
652 } h;
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000653 u8 *skb_head = skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 int skb_len = skb->len;
David S. Millerdbcb5852007-01-24 15:21:02 -0800655 unsigned int snaplen, res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 unsigned long status = TP_STATUS_LOSING|TP_STATUS_USER;
Patrick McHardybbd6ef82008-07-14 22:50:15 -0700657 unsigned short macoff, netoff, hdrlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 struct sk_buff *copy_skb = NULL;
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -0700659 struct timeval tv;
Patrick McHardybbd6ef82008-07-14 22:50:15 -0700660 struct timespec ts;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661
662 if (skb->pkt_type == PACKET_LOOPBACK)
663 goto drop;
664
665 sk = pt->af_packet_priv;
666 po = pkt_sk(sk);
667
Octavian Purdila09ad9bc2009-11-25 15:14:13 -0800668 if (!net_eq(dev_net(dev), sock_net(sk)))
Denis V. Lunevd12d01d2007-11-19 22:28:35 -0800669 goto drop;
670
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700671 if (dev->header_ops) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 if (sk->sk_type != SOCK_DGRAM)
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -0700673 skb_push(skb, skb->data - skb_mac_header(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 else if (skb->pkt_type == PACKET_OUTGOING) {
675 /* Special case: outgoing packets have ll header at head */
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -0300676 skb_pull(skb, skb_network_offset(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 }
678 }
679
Herbert Xu8dc41942007-02-04 23:31:32 -0800680 if (skb->ip_summed == CHECKSUM_PARTIAL)
681 status |= TP_STATUS_CSUMNOTREADY;
682
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 snaplen = skb->len;
684
David S. Millerdbcb5852007-01-24 15:21:02 -0800685 res = run_filter(skb, sk, snaplen);
686 if (!res)
Dmitry Mishinfda9ef52006-08-31 15:28:39 -0700687 goto drop_n_restore;
David S. Millerdbcb5852007-01-24 15:21:02 -0800688 if (snaplen > res)
689 snaplen = res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690
691 if (sk->sk_type == SOCK_DGRAM) {
Patrick McHardy89133362008-07-18 18:05:19 -0700692 macoff = netoff = TPACKET_ALIGN(po->tp_hdrlen) + 16 +
693 po->tp_reserve;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 } else {
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -0300695 unsigned maclen = skb_network_offset(skb);
Patrick McHardybbd6ef82008-07-14 22:50:15 -0700696 netoff = TPACKET_ALIGN(po->tp_hdrlen +
Patrick McHardy89133362008-07-18 18:05:19 -0700697 (maclen < 16 ? 16 : maclen)) +
698 po->tp_reserve;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 macoff = netoff - maclen;
700 }
701
Johann Baudy69e3c752009-05-18 22:11:22 -0700702 if (macoff + snaplen > po->rx_ring.frame_size) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 if (po->copy_thresh &&
704 atomic_read(&sk->sk_rmem_alloc) + skb->truesize <
705 (unsigned)sk->sk_rcvbuf) {
706 if (skb_shared(skb)) {
707 copy_skb = skb_clone(skb, GFP_ATOMIC);
708 } else {
709 copy_skb = skb_get(skb);
710 skb_head = skb->data;
711 }
712 if (copy_skb)
713 skb_set_owner_r(copy_skb, sk);
714 }
Johann Baudy69e3c752009-05-18 22:11:22 -0700715 snaplen = po->rx_ring.frame_size - macoff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 if ((int)snaplen < 0)
717 snaplen = 0;
718 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719
720 spin_lock(&sk->sk_receive_queue.lock);
Johann Baudy69e3c752009-05-18 22:11:22 -0700721 h.raw = packet_current_frame(po, &po->rx_ring, TP_STATUS_KERNEL);
Patrick McHardybbd6ef82008-07-14 22:50:15 -0700722 if (!h.raw)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 goto ring_is_full;
Johann Baudy69e3c752009-05-18 22:11:22 -0700724 packet_increment_head(&po->rx_ring);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 po->stats.tp_packets++;
726 if (copy_skb) {
727 status |= TP_STATUS_COPY;
728 __skb_queue_tail(&sk->sk_receive_queue, copy_skb);
729 }
730 if (!po->stats.tp_drops)
731 status &= ~TP_STATUS_LOSING;
732 spin_unlock(&sk->sk_receive_queue.lock);
733
Patrick McHardybbd6ef82008-07-14 22:50:15 -0700734 skb_copy_bits(skb, 0, h.raw + macoff, snaplen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735
Patrick McHardybbd6ef82008-07-14 22:50:15 -0700736 switch (po->tp_version) {
737 case TPACKET_V1:
738 h.h1->tp_len = skb->len;
739 h.h1->tp_snaplen = snaplen;
740 h.h1->tp_mac = macoff;
741 h.h1->tp_net = netoff;
742 if (skb->tstamp.tv64)
743 tv = ktime_to_timeval(skb->tstamp);
744 else
745 do_gettimeofday(&tv);
746 h.h1->tp_sec = tv.tv_sec;
747 h.h1->tp_usec = tv.tv_usec;
748 hdrlen = sizeof(*h.h1);
749 break;
750 case TPACKET_V2:
751 h.h2->tp_len = skb->len;
752 h.h2->tp_snaplen = snaplen;
753 h.h2->tp_mac = macoff;
754 h.h2->tp_net = netoff;
755 if (skb->tstamp.tv64)
756 ts = ktime_to_timespec(skb->tstamp);
757 else
758 getnstimeofday(&ts);
759 h.h2->tp_sec = ts.tv_sec;
760 h.h2->tp_nsec = ts.tv_nsec;
Eric Dumazet05423b22009-10-26 18:40:35 -0700761 h.h2->tp_vlan_tci = vlan_tx_tag_get(skb);
Patrick McHardybbd6ef82008-07-14 22:50:15 -0700762 hdrlen = sizeof(*h.h2);
763 break;
764 default:
765 BUG();
766 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767
Patrick McHardybbd6ef82008-07-14 22:50:15 -0700768 sll = h.raw + TPACKET_ALIGN(hdrlen);
Stephen Hemmingerb95cce32007-09-26 22:13:38 -0700769 sll->sll_halen = dev_parse_header(skb, sll->sll_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 sll->sll_family = AF_PACKET;
771 sll->sll_hatype = dev->type;
772 sll->sll_protocol = skb->protocol;
773 sll->sll_pkttype = skb->pkt_type;
Peter P Waskiewicz Jr8032b462007-11-10 22:03:25 -0800774 if (unlikely(po->origdev))
Peter P. Waskiewicz Jr80feaac2007-04-20 16:05:39 -0700775 sll->sll_ifindex = orig_dev->ifindex;
776 else
777 sll->sll_ifindex = dev->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778
Patrick McHardybbd6ef82008-07-14 22:50:15 -0700779 __packet_set_status(po, h.raw, status);
Ralf Baechlee16aa202006-12-07 00:11:33 -0800780 smp_mb();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 {
782 struct page *p_start, *p_end;
Patrick McHardybbd6ef82008-07-14 22:50:15 -0700783 u8 *h_end = h.raw + macoff + snaplen - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784
Patrick McHardybbd6ef82008-07-14 22:50:15 -0700785 p_start = virt_to_page(h.raw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 p_end = virt_to_page(h_end);
787 while (p_start <= p_end) {
788 flush_dcache_page(p_start);
789 p_start++;
790 }
791 }
792
793 sk->sk_data_ready(sk, 0);
794
795drop_n_restore:
796 if (skb_head != skb->data && skb_shared(skb)) {
797 skb->data = skb_head;
798 skb->len = skb_len;
799 }
800drop:
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +0900801 kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 return 0;
803
804ring_is_full:
805 po->stats.tp_drops++;
806 spin_unlock(&sk->sk_receive_queue.lock);
807
808 sk->sk_data_ready(sk, 0);
Wei Yongjunacb5d752009-02-25 00:36:42 +0000809 kfree_skb(copy_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 goto drop_n_restore;
811}
812
Johann Baudy69e3c752009-05-18 22:11:22 -0700813static void tpacket_destruct_skb(struct sk_buff *skb)
814{
815 struct packet_sock *po = pkt_sk(skb->sk);
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000816 void *ph;
Johann Baudy69e3c752009-05-18 22:11:22 -0700817
818 BUG_ON(skb == NULL);
819
820 if (likely(po->tx_ring.pg_vec)) {
821 ph = skb_shinfo(skb)->destructor_arg;
822 BUG_ON(__packet_get_status(po, ph) != TP_STATUS_SENDING);
823 BUG_ON(atomic_read(&po->tx_ring.pending) == 0);
824 atomic_dec(&po->tx_ring.pending);
825 __packet_set_status(po, ph, TP_STATUS_AVAILABLE);
826 }
827
828 sock_wfree(skb);
829}
830
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000831static int tpacket_fill_skb(struct packet_sock *po, struct sk_buff *skb,
832 void *frame, struct net_device *dev, int size_max,
833 __be16 proto, unsigned char *addr)
Johann Baudy69e3c752009-05-18 22:11:22 -0700834{
835 union {
836 struct tpacket_hdr *h1;
837 struct tpacket2_hdr *h2;
838 void *raw;
839 } ph;
840 int to_write, offset, len, tp_len, nr_frags, len_max;
841 struct socket *sock = po->sk.sk_socket;
842 struct page *page;
843 void *data;
844 int err;
845
846 ph.raw = frame;
847
848 skb->protocol = proto;
849 skb->dev = dev;
850 skb->priority = po->sk.sk_priority;
Eric Dumazet2d37a182009-10-01 19:14:46 +0000851 skb->mark = po->sk.sk_mark;
Johann Baudy69e3c752009-05-18 22:11:22 -0700852 skb_shinfo(skb)->destructor_arg = ph.raw;
853
854 switch (po->tp_version) {
855 case TPACKET_V2:
856 tp_len = ph.h2->tp_len;
857 break;
858 default:
859 tp_len = ph.h1->tp_len;
860 break;
861 }
862 if (unlikely(tp_len > size_max)) {
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000863 pr_err("packet size is too long (%d > %d)\n", tp_len, size_max);
Johann Baudy69e3c752009-05-18 22:11:22 -0700864 return -EMSGSIZE;
865 }
866
867 skb_reserve(skb, LL_RESERVED_SPACE(dev));
868 skb_reset_network_header(skb);
869
870 data = ph.raw + po->tp_hdrlen - sizeof(struct sockaddr_ll);
871 to_write = tp_len;
872
873 if (sock->type == SOCK_DGRAM) {
874 err = dev_hard_header(skb, dev, ntohs(proto), addr,
875 NULL, tp_len);
876 if (unlikely(err < 0))
877 return -EINVAL;
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000878 } else if (dev->hard_header_len) {
Johann Baudy69e3c752009-05-18 22:11:22 -0700879 /* net device doesn't like empty head */
880 if (unlikely(tp_len <= dev->hard_header_len)) {
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000881 pr_err("packet size is too short (%d < %d)\n",
882 tp_len, dev->hard_header_len);
Johann Baudy69e3c752009-05-18 22:11:22 -0700883 return -EINVAL;
884 }
885
886 skb_push(skb, dev->hard_header_len);
887 err = skb_store_bits(skb, 0, data,
888 dev->hard_header_len);
889 if (unlikely(err))
890 return err;
891
892 data += dev->hard_header_len;
893 to_write -= dev->hard_header_len;
894 }
895
896 err = -EFAULT;
897 page = virt_to_page(data);
898 offset = offset_in_page(data);
899 len_max = PAGE_SIZE - offset;
900 len = ((to_write > len_max) ? len_max : to_write);
901
902 skb->data_len = to_write;
903 skb->len += to_write;
904 skb->truesize += to_write;
905 atomic_add(to_write, &po->sk.sk_wmem_alloc);
906
907 while (likely(to_write)) {
908 nr_frags = skb_shinfo(skb)->nr_frags;
909
910 if (unlikely(nr_frags >= MAX_SKB_FRAGS)) {
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000911 pr_err("Packet exceed the number of skb frags(%lu)\n",
912 MAX_SKB_FRAGS);
Johann Baudy69e3c752009-05-18 22:11:22 -0700913 return -EFAULT;
914 }
915
916 flush_dcache_page(page);
917 get_page(page);
918 skb_fill_page_desc(skb,
919 nr_frags,
920 page++, offset, len);
921 to_write -= len;
922 offset = 0;
923 len_max = PAGE_SIZE;
924 len = ((to_write > len_max) ? len_max : to_write);
925 }
926
927 return tp_len;
928}
929
930static int tpacket_snd(struct packet_sock *po, struct msghdr *msg)
931{
932 struct socket *sock;
933 struct sk_buff *skb;
934 struct net_device *dev;
935 __be16 proto;
936 int ifindex, err, reserve = 0;
Eric Dumazet40d4e3d2009-07-21 21:57:59 +0000937 void *ph;
938 struct sockaddr_ll *saddr = (struct sockaddr_ll *)msg->msg_name;
Johann Baudy69e3c752009-05-18 22:11:22 -0700939 int tp_len, size_max;
940 unsigned char *addr;
941 int len_sum = 0;
942 int status = 0;
943
944 sock = po->sk.sk_socket;
945
946 mutex_lock(&po->pg_vec_lock);
947
948 err = -EBUSY;
949 if (saddr == NULL) {
950 ifindex = po->ifindex;
951 proto = po->num;
952 addr = NULL;
953 } else {
954 err = -EINVAL;
955 if (msg->msg_namelen < sizeof(struct sockaddr_ll))
956 goto out;
957 if (msg->msg_namelen < (saddr->sll_halen
958 + offsetof(struct sockaddr_ll,
959 sll_addr)))
960 goto out;
961 ifindex = saddr->sll_ifindex;
962 proto = saddr->sll_protocol;
963 addr = saddr->sll_addr;
964 }
965
966 dev = dev_get_by_index(sock_net(&po->sk), ifindex);
967 err = -ENXIO;
968 if (unlikely(dev == NULL))
969 goto out;
970
971 reserve = dev->hard_header_len;
972
973 err = -ENETDOWN;
974 if (unlikely(!(dev->flags & IFF_UP)))
975 goto out_put;
976
977 size_max = po->tx_ring.frame_size
Gabor Gombasb5dd8842009-10-29 03:19:11 -0700978 - (po->tp_hdrlen - sizeof(struct sockaddr_ll));
Johann Baudy69e3c752009-05-18 22:11:22 -0700979
980 if (size_max > dev->mtu + reserve)
981 size_max = dev->mtu + reserve;
982
983 do {
984 ph = packet_current_frame(po, &po->tx_ring,
985 TP_STATUS_SEND_REQUEST);
986
987 if (unlikely(ph == NULL)) {
988 schedule();
989 continue;
990 }
991
992 status = TP_STATUS_SEND_REQUEST;
993 skb = sock_alloc_send_skb(&po->sk,
994 LL_ALLOCATED_SPACE(dev)
995 + sizeof(struct sockaddr_ll),
996 0, &err);
997
998 if (unlikely(skb == NULL))
999 goto out_status;
1000
1001 tp_len = tpacket_fill_skb(po, skb, ph, dev, size_max, proto,
1002 addr);
1003
1004 if (unlikely(tp_len < 0)) {
1005 if (po->tp_loss) {
1006 __packet_set_status(po, ph,
1007 TP_STATUS_AVAILABLE);
1008 packet_increment_head(&po->tx_ring);
1009 kfree_skb(skb);
1010 continue;
1011 } else {
1012 status = TP_STATUS_WRONG_FORMAT;
1013 err = tp_len;
1014 goto out_status;
1015 }
1016 }
1017
1018 skb->destructor = tpacket_destruct_skb;
1019 __packet_set_status(po, ph, TP_STATUS_SENDING);
1020 atomic_inc(&po->tx_ring.pending);
1021
1022 status = TP_STATUS_SEND_REQUEST;
1023 err = dev_queue_xmit(skb);
1024 if (unlikely(err > 0 && (err = net_xmit_errno(err)) != 0))
1025 goto out_xmit;
1026 packet_increment_head(&po->tx_ring);
1027 len_sum += tp_len;
Joe Perchesf64f9e72009-11-29 16:55:45 -08001028 } while (likely((ph != NULL) ||
1029 ((!(msg->msg_flags & MSG_DONTWAIT)) &&
1030 (atomic_read(&po->tx_ring.pending))))
1031 );
Johann Baudy69e3c752009-05-18 22:11:22 -07001032
1033 err = len_sum;
1034 goto out_put;
1035
1036out_xmit:
1037 skb->destructor = sock_wfree;
1038 atomic_dec(&po->tx_ring.pending);
1039out_status:
1040 __packet_set_status(po, ph, status);
1041 kfree_skb(skb);
1042out_put:
1043 dev_put(dev);
1044out:
1045 mutex_unlock(&po->pg_vec_lock);
1046 return err;
1047}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048#endif
1049
Johann Baudy69e3c752009-05-18 22:11:22 -07001050static int packet_snd(struct socket *sock,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 struct msghdr *msg, size_t len)
1052{
1053 struct sock *sk = sock->sk;
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00001054 struct sockaddr_ll *saddr = (struct sockaddr_ll *)msg->msg_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 struct sk_buff *skb;
1056 struct net_device *dev;
Al Viro0e11c912006-11-08 00:26:29 -08001057 __be16 proto;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 unsigned char *addr;
1059 int ifindex, err, reserve = 0;
1060
1061 /*
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +09001062 * Get and verify the address.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 */
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +09001064
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 if (saddr == NULL) {
1066 struct packet_sock *po = pkt_sk(sk);
1067
1068 ifindex = po->ifindex;
1069 proto = po->num;
1070 addr = NULL;
1071 } else {
1072 err = -EINVAL;
1073 if (msg->msg_namelen < sizeof(struct sockaddr_ll))
1074 goto out;
Eric W. Biederman0fb375f2005-09-21 00:11:37 -07001075 if (msg->msg_namelen < (saddr->sll_halen + offsetof(struct sockaddr_ll, sll_addr)))
1076 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 ifindex = saddr->sll_ifindex;
1078 proto = saddr->sll_protocol;
1079 addr = saddr->sll_addr;
1080 }
1081
1082
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001083 dev = dev_get_by_index(sock_net(sk), ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 err = -ENXIO;
1085 if (dev == NULL)
1086 goto out_unlock;
1087 if (sock->type == SOCK_RAW)
1088 reserve = dev->hard_header_len;
1089
David S. Millerd5e76b02007-01-25 19:30:36 -08001090 err = -ENETDOWN;
1091 if (!(dev->flags & IFF_UP))
1092 goto out_unlock;
1093
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094 err = -EMSGSIZE;
1095 if (len > dev->mtu+reserve)
1096 goto out_unlock;
1097
Johannes Bergf5184d22008-05-12 20:48:31 -07001098 skb = sock_alloc_send_skb(sk, len + LL_ALLOCATED_SPACE(dev),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 msg->msg_flags & MSG_DONTWAIT, &err);
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00001100 if (skb == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 goto out_unlock;
1102
1103 skb_reserve(skb, LL_RESERVED_SPACE(dev));
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07001104 skb_reset_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105
Stephen Hemminger0c4e8582007-10-09 01:36:32 -07001106 err = -EINVAL;
1107 if (sock->type == SOCK_DGRAM &&
1108 dev_hard_header(skb, dev, ntohs(proto), addr, NULL, len) < 0)
1109 goto out_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110
1111 /* Returns -EFAULT on error */
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00001112 err = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113 if (err)
1114 goto out_free;
1115
1116 skb->protocol = proto;
1117 skb->dev = dev;
1118 skb->priority = sk->sk_priority;
Eric Dumazet2d37a182009-10-01 19:14:46 +00001119 skb->mark = sk->sk_mark;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 /*
1122 * Now send it
1123 */
1124
1125 err = dev_queue_xmit(skb);
1126 if (err > 0 && (err = net_xmit_errno(err)) != 0)
1127 goto out_unlock;
1128
1129 dev_put(dev);
1130
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00001131 return len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132
1133out_free:
1134 kfree_skb(skb);
1135out_unlock:
1136 if (dev)
1137 dev_put(dev);
1138out:
1139 return err;
1140}
1141
Johann Baudy69e3c752009-05-18 22:11:22 -07001142static int packet_sendmsg(struct kiocb *iocb, struct socket *sock,
1143 struct msghdr *msg, size_t len)
1144{
1145#ifdef CONFIG_PACKET_MMAP
1146 struct sock *sk = sock->sk;
1147 struct packet_sock *po = pkt_sk(sk);
1148 if (po->tx_ring.pg_vec)
1149 return tpacket_snd(po, msg);
1150 else
1151#endif
1152 return packet_snd(sock, msg, len);
1153}
1154
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155/*
1156 * Close a PACKET socket. This is fairly simple. We immediately go
1157 * to 'closed' state and remove our protocol entry in the device list.
1158 */
1159
1160static int packet_release(struct socket *sock)
1161{
1162 struct sock *sk = sock->sk;
1163 struct packet_sock *po;
Denis V. Lunevd12d01d2007-11-19 22:28:35 -08001164 struct net *net;
Johann Baudy69e3c752009-05-18 22:11:22 -07001165#ifdef CONFIG_PACKET_MMAP
1166 struct tpacket_req req;
1167#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168
1169 if (!sk)
1170 return 0;
1171
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001172 net = sock_net(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 po = pkt_sk(sk);
1174
Denis V. Lunev2aaef4e2007-12-11 04:19:54 -08001175 write_lock_bh(&net->packet.sklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 sk_del_node_init(sk);
Eric Dumazet920de802008-11-24 00:09:29 -08001177 sock_prot_inuse_add(net, sk->sk_prot, -1);
Denis V. Lunev2aaef4e2007-12-11 04:19:54 -08001178 write_unlock_bh(&net->packet.sklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179
1180 /*
1181 * Unhook packet receive handler.
1182 */
1183
1184 if (po->running) {
1185 /*
1186 * Remove the protocol hook
1187 */
1188 dev_remove_pack(&po->prot_hook);
1189 po->running = 0;
1190 po->num = 0;
1191 __sock_put(sk);
1192 }
1193
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 packet_flush_mclist(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195
1196#ifdef CONFIG_PACKET_MMAP
Johann Baudy69e3c752009-05-18 22:11:22 -07001197 memset(&req, 0, sizeof(req));
1198
1199 if (po->rx_ring.pg_vec)
1200 packet_set_ring(sk, &req, 1, 0);
1201
1202 if (po->tx_ring.pg_vec)
1203 packet_set_ring(sk, &req, 1, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204#endif
1205
1206 /*
1207 * Now the socket is dead. No more input will appear.
1208 */
1209
1210 sock_orphan(sk);
1211 sock->sk = NULL;
1212
1213 /* Purge queues */
1214
1215 skb_queue_purge(&sk->sk_receive_queue);
Pavel Emelyanov17ab56a2007-11-10 21:38:48 -08001216 sk_refcnt_debug_release(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217
1218 sock_put(sk);
1219 return 0;
1220}
1221
1222/*
1223 * Attach a packet hook.
1224 */
1225
Al Viro0e11c912006-11-08 00:26:29 -08001226static int packet_do_bind(struct sock *sk, struct net_device *dev, __be16 protocol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227{
1228 struct packet_sock *po = pkt_sk(sk);
1229 /*
1230 * Detach an existing hook if present.
1231 */
1232
1233 lock_sock(sk);
1234
1235 spin_lock(&po->bind_lock);
1236 if (po->running) {
1237 __sock_put(sk);
1238 po->running = 0;
1239 po->num = 0;
1240 spin_unlock(&po->bind_lock);
1241 dev_remove_pack(&po->prot_hook);
1242 spin_lock(&po->bind_lock);
1243 }
1244
1245 po->num = protocol;
1246 po->prot_hook.type = protocol;
1247 po->prot_hook.dev = dev;
1248
1249 po->ifindex = dev ? dev->ifindex : 0;
1250
1251 if (protocol == 0)
1252 goto out_unlock;
1253
Urs Thuermannbe85d4a2007-11-12 21:05:20 -08001254 if (!dev || (dev->flags & IFF_UP)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 dev_add_pack(&po->prot_hook);
1256 sock_hold(sk);
1257 po->running = 1;
Urs Thuermannbe85d4a2007-11-12 21:05:20 -08001258 } else {
1259 sk->sk_err = ENETDOWN;
1260 if (!sock_flag(sk, SOCK_DEAD))
1261 sk->sk_error_report(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 }
1263
1264out_unlock:
1265 spin_unlock(&po->bind_lock);
1266 release_sock(sk);
1267 return 0;
1268}
1269
1270/*
1271 * Bind a packet socket to a device
1272 */
1273
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00001274static int packet_bind_spkt(struct socket *sock, struct sockaddr *uaddr,
1275 int addr_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276{
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00001277 struct sock *sk = sock->sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278 char name[15];
1279 struct net_device *dev;
1280 int err = -ENODEV;
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +09001281
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 /*
1283 * Check legality
1284 */
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +09001285
Kris Katterjohn8ae55f02006-01-23 16:28:02 -08001286 if (addr_len != sizeof(struct sockaddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 return -EINVAL;
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00001288 strlcpy(name, uaddr->sa_data, sizeof(name));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001290 dev = dev_get_by_name(sock_net(sk), name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291 if (dev) {
1292 err = packet_do_bind(sk, dev, pkt_sk(sk)->num);
1293 dev_put(dev);
1294 }
1295 return err;
1296}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297
1298static int packet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1299{
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00001300 struct sockaddr_ll *sll = (struct sockaddr_ll *)uaddr;
1301 struct sock *sk = sock->sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 struct net_device *dev = NULL;
1303 int err;
1304
1305
1306 /*
1307 * Check legality
1308 */
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +09001309
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 if (addr_len < sizeof(struct sockaddr_ll))
1311 return -EINVAL;
1312 if (sll->sll_family != AF_PACKET)
1313 return -EINVAL;
1314
1315 if (sll->sll_ifindex) {
1316 err = -ENODEV;
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001317 dev = dev_get_by_index(sock_net(sk), sll->sll_ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 if (dev == NULL)
1319 goto out;
1320 }
1321 err = packet_do_bind(sk, dev, sll->sll_protocol ? : pkt_sk(sk)->num);
1322 if (dev)
1323 dev_put(dev);
1324
1325out:
1326 return err;
1327}
1328
1329static struct proto packet_proto = {
1330 .name = "PACKET",
1331 .owner = THIS_MODULE,
1332 .obj_size = sizeof(struct packet_sock),
1333};
1334
1335/*
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +09001336 * Create a packet of type SOCK_PACKET.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 */
1338
Eric Paris3f378b62009-11-05 22:18:14 -08001339static int packet_create(struct net *net, struct socket *sock, int protocol,
1340 int kern)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341{
1342 struct sock *sk;
1343 struct packet_sock *po;
Al Viro0e11c912006-11-08 00:26:29 -08001344 __be16 proto = (__force __be16)protocol; /* weird, but documented */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 int err;
1346
1347 if (!capable(CAP_NET_RAW))
1348 return -EPERM;
David S. Millerbe020972007-05-29 13:16:31 -07001349 if (sock->type != SOCK_DGRAM && sock->type != SOCK_RAW &&
1350 sock->type != SOCK_PACKET)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 return -ESOCKTNOSUPPORT;
1352
1353 sock->state = SS_UNCONNECTED;
1354
1355 err = -ENOBUFS;
Pavel Emelyanov6257ff22007-11-01 00:39:31 -07001356 sk = sk_alloc(net, PF_PACKET, GFP_KERNEL, &packet_proto);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 if (sk == NULL)
1358 goto out;
1359
1360 sock->ops = &packet_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361 if (sock->type == SOCK_PACKET)
1362 sock->ops = &packet_ops_spkt;
David S. Millerbe020972007-05-29 13:16:31 -07001363
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 sock_init_data(sock, sk);
1365
1366 po = pkt_sk(sk);
1367 sk->sk_family = PF_PACKET;
Al Viro0e11c912006-11-08 00:26:29 -08001368 po->num = proto;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369
1370 sk->sk_destruct = packet_sock_destruct;
Pavel Emelyanov17ab56a2007-11-10 21:38:48 -08001371 sk_refcnt_debug_inc(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372
1373 /*
1374 * Attach a protocol block
1375 */
1376
1377 spin_lock_init(&po->bind_lock);
Herbert Xu905db442009-01-30 14:12:06 -08001378 mutex_init(&po->pg_vec_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379 po->prot_hook.func = packet_rcv;
David S. Millerbe020972007-05-29 13:16:31 -07001380
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 if (sock->type == SOCK_PACKET)
1382 po->prot_hook.func = packet_rcv_spkt;
David S. Millerbe020972007-05-29 13:16:31 -07001383
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 po->prot_hook.af_packet_priv = sk;
1385
Al Viro0e11c912006-11-08 00:26:29 -08001386 if (proto) {
1387 po->prot_hook.type = proto;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 dev_add_pack(&po->prot_hook);
1389 sock_hold(sk);
1390 po->running = 1;
1391 }
1392
Denis V. Lunev2aaef4e2007-12-11 04:19:54 -08001393 write_lock_bh(&net->packet.sklist_lock);
1394 sk_add_node(sk, &net->packet.sklist);
Eric Dumazet36804532008-11-19 14:25:35 -08001395 sock_prot_inuse_add(net, &packet_proto, 1);
Eric Dumazet920de802008-11-24 00:09:29 -08001396 write_unlock_bh(&net->packet.sklist_lock);
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00001397 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398out:
1399 return err;
1400}
1401
1402/*
1403 * Pull a packet from our receive queue and hand it to the user.
1404 * If necessary we block.
1405 */
1406
1407static int packet_recvmsg(struct kiocb *iocb, struct socket *sock,
1408 struct msghdr *msg, size_t len, int flags)
1409{
1410 struct sock *sk = sock->sk;
1411 struct sk_buff *skb;
1412 int copied, err;
Eric W. Biederman0fb375f2005-09-21 00:11:37 -07001413 struct sockaddr_ll *sll;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414
1415 err = -EINVAL;
1416 if (flags & ~(MSG_PEEK|MSG_DONTWAIT|MSG_TRUNC|MSG_CMSG_COMPAT))
1417 goto out;
1418
1419#if 0
1420 /* What error should we return now? EUNATTACH? */
1421 if (pkt_sk(sk)->ifindex < 0)
1422 return -ENODEV;
1423#endif
1424
1425 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 * Call the generic datagram receiver. This handles all sorts
1427 * of horrible races and re-entrancy so we can forget about it
1428 * in the protocol layers.
1429 *
1430 * Now it will return ENETDOWN, if device have just gone down,
1431 * but then it will block.
1432 */
1433
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00001434 skb = skb_recv_datagram(sk, flags, flags & MSG_DONTWAIT, &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435
1436 /*
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +09001437 * An error occurred so return it. Because skb_recv_datagram()
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438 * handles the blocking we don't see and worry about blocking
1439 * retries.
1440 */
1441
Kris Katterjohn8ae55f02006-01-23 16:28:02 -08001442 if (skb == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443 goto out;
1444
1445 /*
Eric W. Biederman0fb375f2005-09-21 00:11:37 -07001446 * If the address length field is there to be filled in, we fill
1447 * it in now.
1448 */
1449
Herbert Xuffbc6112007-02-04 23:33:10 -08001450 sll = &PACKET_SKB_CB(skb)->sa.ll;
Eric W. Biederman0fb375f2005-09-21 00:11:37 -07001451 if (sock->type == SOCK_PACKET)
1452 msg->msg_namelen = sizeof(struct sockaddr_pkt);
1453 else
1454 msg->msg_namelen = sll->sll_halen + offsetof(struct sockaddr_ll, sll_addr);
1455
1456 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 * You lose any data beyond the buffer you gave. If it worries a
1458 * user program they can ask the device for its MTU anyway.
1459 */
1460
1461 copied = skb->len;
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00001462 if (copied > len) {
1463 copied = len;
1464 msg->msg_flags |= MSG_TRUNC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465 }
1466
1467 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1468 if (err)
1469 goto out_free;
1470
Neil Horman3b885782009-10-12 13:26:31 -07001471 sock_recv_ts_and_drops(msg, sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472
1473 if (msg->msg_name)
Herbert Xuffbc6112007-02-04 23:33:10 -08001474 memcpy(msg->msg_name, &PACKET_SKB_CB(skb)->sa,
1475 msg->msg_namelen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476
Herbert Xu8dc41942007-02-04 23:31:32 -08001477 if (pkt_sk(sk)->auxdata) {
Herbert Xuffbc6112007-02-04 23:33:10 -08001478 struct tpacket_auxdata aux;
1479
1480 aux.tp_status = TP_STATUS_USER;
1481 if (skb->ip_summed == CHECKSUM_PARTIAL)
1482 aux.tp_status |= TP_STATUS_CSUMNOTREADY;
1483 aux.tp_len = PACKET_SKB_CB(skb)->origlen;
1484 aux.tp_snaplen = skb->len;
1485 aux.tp_mac = 0;
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -03001486 aux.tp_net = skb_network_offset(skb);
Eric Dumazet05423b22009-10-26 18:40:35 -07001487 aux.tp_vlan_tci = vlan_tx_tag_get(skb);
Herbert Xuffbc6112007-02-04 23:33:10 -08001488
1489 put_cmsg(msg, SOL_PACKET, PACKET_AUXDATA, sizeof(aux), &aux);
Herbert Xu8dc41942007-02-04 23:31:32 -08001490 }
1491
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492 /*
1493 * Free or return the buffer as appropriate. Again this
1494 * hides all the races and re-entrancy issues from us.
1495 */
1496 err = (flags&MSG_TRUNC) ? skb->len : copied;
1497
1498out_free:
1499 skb_free_datagram(sk, skb);
1500out:
1501 return err;
1502}
1503
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504static int packet_getname_spkt(struct socket *sock, struct sockaddr *uaddr,
1505 int *uaddr_len, int peer)
1506{
1507 struct net_device *dev;
1508 struct sock *sk = sock->sk;
1509
1510 if (peer)
1511 return -EOPNOTSUPP;
1512
1513 uaddr->sa_family = AF_PACKET;
Eric Dumazet654d1f82009-11-02 10:43:32 +01001514 rcu_read_lock();
1515 dev = dev_get_by_index_rcu(sock_net(sk), pkt_sk(sk)->ifindex);
1516 if (dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517 strlcpy(uaddr->sa_data, dev->name, 15);
Eric Dumazet654d1f82009-11-02 10:43:32 +01001518 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519 memset(uaddr->sa_data, 0, 14);
Eric Dumazet654d1f82009-11-02 10:43:32 +01001520 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521 *uaddr_len = sizeof(*uaddr);
1522
1523 return 0;
1524}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525
1526static int packet_getname(struct socket *sock, struct sockaddr *uaddr,
1527 int *uaddr_len, int peer)
1528{
1529 struct net_device *dev;
1530 struct sock *sk = sock->sk;
1531 struct packet_sock *po = pkt_sk(sk);
Cyrill Gorcunov13cfa972009-11-08 05:51:19 +00001532 DECLARE_SOCKADDR(struct sockaddr_ll *, sll, uaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533
1534 if (peer)
1535 return -EOPNOTSUPP;
1536
1537 sll->sll_family = AF_PACKET;
1538 sll->sll_ifindex = po->ifindex;
1539 sll->sll_protocol = po->num;
Eric Dumazet654d1f82009-11-02 10:43:32 +01001540 rcu_read_lock();
1541 dev = dev_get_by_index_rcu(sock_net(sk), po->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542 if (dev) {
1543 sll->sll_hatype = dev->type;
1544 sll->sll_halen = dev->addr_len;
1545 memcpy(sll->sll_addr, dev->dev_addr, dev->addr_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546 } else {
1547 sll->sll_hatype = 0; /* Bad: we have no ARPHRD_UNSPEC */
1548 sll->sll_halen = 0;
1549 }
Eric Dumazet654d1f82009-11-02 10:43:32 +01001550 rcu_read_unlock();
Eric W. Biederman0fb375f2005-09-21 00:11:37 -07001551 *uaddr_len = offsetof(struct sockaddr_ll, sll_addr) + sll->sll_halen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552
1553 return 0;
1554}
1555
Wang Chen2aeb0b82008-07-14 20:49:46 -07001556static int packet_dev_mc(struct net_device *dev, struct packet_mclist *i,
1557 int what)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558{
1559 switch (i->type) {
1560 case PACKET_MR_MULTICAST:
1561 if (what > 0)
Eric W. Biedermand95ed922009-05-19 18:27:17 +00001562 return dev_mc_add(dev, i->addr, i->alen, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 else
Eric W. Biedermand95ed922009-05-19 18:27:17 +00001564 return dev_mc_delete(dev, i->addr, i->alen, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 break;
1566 case PACKET_MR_PROMISC:
Wang Chen2aeb0b82008-07-14 20:49:46 -07001567 return dev_set_promiscuity(dev, what);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568 break;
1569 case PACKET_MR_ALLMULTI:
Wang Chen2aeb0b82008-07-14 20:49:46 -07001570 return dev_set_allmulti(dev, what);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571 break;
Eric W. Biedermand95ed922009-05-19 18:27:17 +00001572 case PACKET_MR_UNICAST:
1573 if (what > 0)
Jiri Pirkoccffad22009-05-22 23:22:17 +00001574 return dev_unicast_add(dev, i->addr);
Eric W. Biedermand95ed922009-05-19 18:27:17 +00001575 else
Jiri Pirkoccffad22009-05-22 23:22:17 +00001576 return dev_unicast_delete(dev, i->addr);
Eric W. Biedermand95ed922009-05-19 18:27:17 +00001577 break;
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00001578 default:
1579 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580 }
Wang Chen2aeb0b82008-07-14 20:49:46 -07001581 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582}
1583
1584static void packet_dev_mclist(struct net_device *dev, struct packet_mclist *i, int what)
1585{
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00001586 for ( ; i; i = i->next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 if (i->ifindex == dev->ifindex)
1588 packet_dev_mc(dev, i, what);
1589 }
1590}
1591
Eric W. Biederman0fb375f2005-09-21 00:11:37 -07001592static int packet_mc_add(struct sock *sk, struct packet_mreq_max *mreq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593{
1594 struct packet_sock *po = pkt_sk(sk);
1595 struct packet_mclist *ml, *i;
1596 struct net_device *dev;
1597 int err;
1598
1599 rtnl_lock();
1600
1601 err = -ENODEV;
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001602 dev = __dev_get_by_index(sock_net(sk), mreq->mr_ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603 if (!dev)
1604 goto done;
1605
1606 err = -EINVAL;
1607 if (mreq->mr_alen > dev->addr_len)
1608 goto done;
1609
1610 err = -ENOBUFS;
Kris Katterjohn8b3a7002006-01-11 15:56:43 -08001611 i = kmalloc(sizeof(*i), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612 if (i == NULL)
1613 goto done;
1614
1615 err = 0;
1616 for (ml = po->mclist; ml; ml = ml->next) {
1617 if (ml->ifindex == mreq->mr_ifindex &&
1618 ml->type == mreq->mr_type &&
1619 ml->alen == mreq->mr_alen &&
1620 memcmp(ml->addr, mreq->mr_address, ml->alen) == 0) {
1621 ml->count++;
1622 /* Free the new element ... */
1623 kfree(i);
1624 goto done;
1625 }
1626 }
1627
1628 i->type = mreq->mr_type;
1629 i->ifindex = mreq->mr_ifindex;
1630 i->alen = mreq->mr_alen;
1631 memcpy(i->addr, mreq->mr_address, i->alen);
1632 i->count = 1;
1633 i->next = po->mclist;
1634 po->mclist = i;
Wang Chen2aeb0b82008-07-14 20:49:46 -07001635 err = packet_dev_mc(dev, i, 1);
1636 if (err) {
1637 po->mclist = i->next;
1638 kfree(i);
1639 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640
1641done:
1642 rtnl_unlock();
1643 return err;
1644}
1645
Eric W. Biederman0fb375f2005-09-21 00:11:37 -07001646static int packet_mc_drop(struct sock *sk, struct packet_mreq_max *mreq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647{
1648 struct packet_mclist *ml, **mlp;
1649
1650 rtnl_lock();
1651
1652 for (mlp = &pkt_sk(sk)->mclist; (ml = *mlp) != NULL; mlp = &ml->next) {
1653 if (ml->ifindex == mreq->mr_ifindex &&
1654 ml->type == mreq->mr_type &&
1655 ml->alen == mreq->mr_alen &&
1656 memcmp(ml->addr, mreq->mr_address, ml->alen) == 0) {
1657 if (--ml->count == 0) {
1658 struct net_device *dev;
1659 *mlp = ml->next;
Eric Dumazetad959e72009-10-16 06:38:46 +00001660 dev = __dev_get_by_index(sock_net(sk), ml->ifindex);
1661 if (dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662 packet_dev_mc(dev, ml, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 kfree(ml);
1664 }
1665 rtnl_unlock();
1666 return 0;
1667 }
1668 }
1669 rtnl_unlock();
1670 return -EADDRNOTAVAIL;
1671}
1672
1673static void packet_flush_mclist(struct sock *sk)
1674{
1675 struct packet_sock *po = pkt_sk(sk);
1676 struct packet_mclist *ml;
1677
1678 if (!po->mclist)
1679 return;
1680
1681 rtnl_lock();
1682 while ((ml = po->mclist) != NULL) {
1683 struct net_device *dev;
1684
1685 po->mclist = ml->next;
Eric Dumazetad959e72009-10-16 06:38:46 +00001686 dev = __dev_get_by_index(sock_net(sk), ml->ifindex);
1687 if (dev != NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688 packet_dev_mc(dev, ml, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689 kfree(ml);
1690 }
1691 rtnl_unlock();
1692}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693
1694static int
David S. Millerb7058842009-09-30 16:12:20 -07001695packet_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696{
1697 struct sock *sk = sock->sk;
Herbert Xu8dc41942007-02-04 23:31:32 -08001698 struct packet_sock *po = pkt_sk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 int ret;
1700
1701 if (level != SOL_PACKET)
1702 return -ENOPROTOOPT;
1703
Johann Baudy69e3c752009-05-18 22:11:22 -07001704 switch (optname) {
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +09001705 case PACKET_ADD_MEMBERSHIP:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706 case PACKET_DROP_MEMBERSHIP:
1707 {
Eric W. Biederman0fb375f2005-09-21 00:11:37 -07001708 struct packet_mreq_max mreq;
1709 int len = optlen;
1710 memset(&mreq, 0, sizeof(mreq));
1711 if (len < sizeof(struct packet_mreq))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 return -EINVAL;
Eric W. Biederman0fb375f2005-09-21 00:11:37 -07001713 if (len > sizeof(mreq))
1714 len = sizeof(mreq);
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00001715 if (copy_from_user(&mreq, optval, len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716 return -EFAULT;
Eric W. Biederman0fb375f2005-09-21 00:11:37 -07001717 if (len < (mreq.mr_alen + offsetof(struct packet_mreq, mr_address)))
1718 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719 if (optname == PACKET_ADD_MEMBERSHIP)
1720 ret = packet_mc_add(sk, &mreq);
1721 else
1722 ret = packet_mc_drop(sk, &mreq);
1723 return ret;
1724 }
David S. Millera2efcfa2007-05-29 13:12:50 -07001725
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726#ifdef CONFIG_PACKET_MMAP
1727 case PACKET_RX_RING:
Johann Baudy69e3c752009-05-18 22:11:22 -07001728 case PACKET_TX_RING:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 {
1730 struct tpacket_req req;
1731
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00001732 if (optlen < sizeof(req))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733 return -EINVAL;
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00001734 if (copy_from_user(&req, optval, sizeof(req)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735 return -EFAULT;
Johann Baudy69e3c752009-05-18 22:11:22 -07001736 return packet_set_ring(sk, &req, 0, optname == PACKET_TX_RING);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737 }
1738 case PACKET_COPY_THRESH:
1739 {
1740 int val;
1741
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00001742 if (optlen != sizeof(val))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743 return -EINVAL;
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00001744 if (copy_from_user(&val, optval, sizeof(val)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745 return -EFAULT;
1746
1747 pkt_sk(sk)->copy_thresh = val;
1748 return 0;
1749 }
Patrick McHardybbd6ef82008-07-14 22:50:15 -07001750 case PACKET_VERSION:
1751 {
1752 int val;
1753
1754 if (optlen != sizeof(val))
1755 return -EINVAL;
Johann Baudy69e3c752009-05-18 22:11:22 -07001756 if (po->rx_ring.pg_vec || po->tx_ring.pg_vec)
Patrick McHardybbd6ef82008-07-14 22:50:15 -07001757 return -EBUSY;
1758 if (copy_from_user(&val, optval, sizeof(val)))
1759 return -EFAULT;
1760 switch (val) {
1761 case TPACKET_V1:
1762 case TPACKET_V2:
1763 po->tp_version = val;
1764 return 0;
1765 default:
1766 return -EINVAL;
1767 }
1768 }
Patrick McHardy89133362008-07-18 18:05:19 -07001769 case PACKET_RESERVE:
1770 {
1771 unsigned int val;
1772
1773 if (optlen != sizeof(val))
1774 return -EINVAL;
Johann Baudy69e3c752009-05-18 22:11:22 -07001775 if (po->rx_ring.pg_vec || po->tx_ring.pg_vec)
Patrick McHardy89133362008-07-18 18:05:19 -07001776 return -EBUSY;
1777 if (copy_from_user(&val, optval, sizeof(val)))
1778 return -EFAULT;
1779 po->tp_reserve = val;
1780 return 0;
1781 }
Johann Baudy69e3c752009-05-18 22:11:22 -07001782 case PACKET_LOSS:
1783 {
1784 unsigned int val;
1785
1786 if (optlen != sizeof(val))
1787 return -EINVAL;
1788 if (po->rx_ring.pg_vec || po->tx_ring.pg_vec)
1789 return -EBUSY;
1790 if (copy_from_user(&val, optval, sizeof(val)))
1791 return -EFAULT;
1792 po->tp_loss = !!val;
1793 return 0;
1794 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001795#endif
Herbert Xu8dc41942007-02-04 23:31:32 -08001796 case PACKET_AUXDATA:
1797 {
1798 int val;
1799
1800 if (optlen < sizeof(val))
1801 return -EINVAL;
1802 if (copy_from_user(&val, optval, sizeof(val)))
1803 return -EFAULT;
1804
1805 po->auxdata = !!val;
1806 return 0;
1807 }
Peter P. Waskiewicz Jr80feaac2007-04-20 16:05:39 -07001808 case PACKET_ORIGDEV:
1809 {
1810 int val;
1811
1812 if (optlen < sizeof(val))
1813 return -EINVAL;
1814 if (copy_from_user(&val, optval, sizeof(val)))
1815 return -EFAULT;
1816
1817 po->origdev = !!val;
1818 return 0;
1819 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820 default:
1821 return -ENOPROTOOPT;
1822 }
1823}
1824
1825static int packet_getsockopt(struct socket *sock, int level, int optname,
1826 char __user *optval, int __user *optlen)
1827{
1828 int len;
Herbert Xu8dc41942007-02-04 23:31:32 -08001829 int val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830 struct sock *sk = sock->sk;
1831 struct packet_sock *po = pkt_sk(sk);
Herbert Xu8dc41942007-02-04 23:31:32 -08001832 void *data;
1833 struct tpacket_stats st;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834
1835 if (level != SOL_PACKET)
1836 return -ENOPROTOOPT;
1837
Kris Katterjohn8ae55f02006-01-23 16:28:02 -08001838 if (get_user(len, optlen))
1839 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001840
1841 if (len < 0)
1842 return -EINVAL;
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +09001843
Johann Baudy69e3c752009-05-18 22:11:22 -07001844 switch (optname) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845 case PACKET_STATISTICS:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846 if (len > sizeof(struct tpacket_stats))
1847 len = sizeof(struct tpacket_stats);
1848 spin_lock_bh(&sk->sk_receive_queue.lock);
1849 st = po->stats;
1850 memset(&po->stats, 0, sizeof(st));
1851 spin_unlock_bh(&sk->sk_receive_queue.lock);
1852 st.tp_packets += st.tp_drops;
1853
Herbert Xu8dc41942007-02-04 23:31:32 -08001854 data = &st;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855 break;
Herbert Xu8dc41942007-02-04 23:31:32 -08001856 case PACKET_AUXDATA:
1857 if (len > sizeof(int))
1858 len = sizeof(int);
1859 val = po->auxdata;
1860
1861 data = &val;
1862 break;
Peter P. Waskiewicz Jr80feaac2007-04-20 16:05:39 -07001863 case PACKET_ORIGDEV:
1864 if (len > sizeof(int))
1865 len = sizeof(int);
1866 val = po->origdev;
1867
1868 data = &val;
1869 break;
Patrick McHardybbd6ef82008-07-14 22:50:15 -07001870#ifdef CONFIG_PACKET_MMAP
1871 case PACKET_VERSION:
1872 if (len > sizeof(int))
1873 len = sizeof(int);
1874 val = po->tp_version;
1875 data = &val;
1876 break;
1877 case PACKET_HDRLEN:
1878 if (len > sizeof(int))
1879 len = sizeof(int);
1880 if (copy_from_user(&val, optval, len))
1881 return -EFAULT;
1882 switch (val) {
1883 case TPACKET_V1:
1884 val = sizeof(struct tpacket_hdr);
1885 break;
1886 case TPACKET_V2:
1887 val = sizeof(struct tpacket2_hdr);
1888 break;
1889 default:
1890 return -EINVAL;
1891 }
1892 data = &val;
1893 break;
Patrick McHardy89133362008-07-18 18:05:19 -07001894 case PACKET_RESERVE:
1895 if (len > sizeof(unsigned int))
1896 len = sizeof(unsigned int);
1897 val = po->tp_reserve;
1898 data = &val;
1899 break;
Johann Baudy69e3c752009-05-18 22:11:22 -07001900 case PACKET_LOSS:
1901 if (len > sizeof(unsigned int))
1902 len = sizeof(unsigned int);
1903 val = po->tp_loss;
1904 data = &val;
1905 break;
Patrick McHardybbd6ef82008-07-14 22:50:15 -07001906#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907 default:
1908 return -ENOPROTOOPT;
1909 }
1910
Kris Katterjohn8ae55f02006-01-23 16:28:02 -08001911 if (put_user(len, optlen))
1912 return -EFAULT;
Herbert Xu8dc41942007-02-04 23:31:32 -08001913 if (copy_to_user(optval, data, len))
1914 return -EFAULT;
Kris Katterjohn8ae55f02006-01-23 16:28:02 -08001915 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916}
1917
1918
1919static int packet_notifier(struct notifier_block *this, unsigned long msg, void *data)
1920{
1921 struct sock *sk;
1922 struct hlist_node *node;
Jason Lunzad930652007-02-20 23:19:54 -08001923 struct net_device *dev = data;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001924 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925
Denis V. Lunev2aaef4e2007-12-11 04:19:54 -08001926 read_lock(&net->packet.sklist_lock);
1927 sk_for_each(sk, node, &net->packet.sklist) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928 struct packet_sock *po = pkt_sk(sk);
1929
1930 switch (msg) {
1931 case NETDEV_UNREGISTER:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932 if (po->mclist)
1933 packet_dev_mclist(dev, po->mclist, -1);
David S. Millera2efcfa2007-05-29 13:12:50 -07001934 /* fallthrough */
1935
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936 case NETDEV_DOWN:
1937 if (dev->ifindex == po->ifindex) {
1938 spin_lock(&po->bind_lock);
1939 if (po->running) {
1940 __dev_remove_pack(&po->prot_hook);
1941 __sock_put(sk);
1942 po->running = 0;
1943 sk->sk_err = ENETDOWN;
1944 if (!sock_flag(sk, SOCK_DEAD))
1945 sk->sk_error_report(sk);
1946 }
1947 if (msg == NETDEV_UNREGISTER) {
1948 po->ifindex = -1;
1949 po->prot_hook.dev = NULL;
1950 }
1951 spin_unlock(&po->bind_lock);
1952 }
1953 break;
1954 case NETDEV_UP:
1955 spin_lock(&po->bind_lock);
1956 if (dev->ifindex == po->ifindex && po->num &&
1957 !po->running) {
1958 dev_add_pack(&po->prot_hook);
1959 sock_hold(sk);
1960 po->running = 1;
1961 }
1962 spin_unlock(&po->bind_lock);
1963 break;
1964 }
1965 }
Denis V. Lunev2aaef4e2007-12-11 04:19:54 -08001966 read_unlock(&net->packet.sklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967 return NOTIFY_DONE;
1968}
1969
1970
1971static int packet_ioctl(struct socket *sock, unsigned int cmd,
1972 unsigned long arg)
1973{
1974 struct sock *sk = sock->sk;
1975
Johann Baudy69e3c752009-05-18 22:11:22 -07001976 switch (cmd) {
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00001977 case SIOCOUTQ:
1978 {
1979 int amount = sk_wmem_alloc_get(sk);
Eric Dumazet31e6d362009-06-17 19:05:41 -07001980
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00001981 return put_user(amount, (int __user *)arg);
1982 }
1983 case SIOCINQ:
1984 {
1985 struct sk_buff *skb;
1986 int amount = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00001988 spin_lock_bh(&sk->sk_receive_queue.lock);
1989 skb = skb_peek(&sk->sk_receive_queue);
1990 if (skb)
1991 amount = skb->len;
1992 spin_unlock_bh(&sk->sk_receive_queue.lock);
1993 return put_user(amount, (int __user *)arg);
1994 }
1995 case SIOCGSTAMP:
1996 return sock_get_timestamp(sk, (struct timeval __user *)arg);
1997 case SIOCGSTAMPNS:
1998 return sock_get_timestampns(sk, (struct timespec __user *)arg);
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +09001999
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000#ifdef CONFIG_INET
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00002001 case SIOCADDRT:
2002 case SIOCDELRT:
2003 case SIOCDARP:
2004 case SIOCGARP:
2005 case SIOCSARP:
2006 case SIOCGIFADDR:
2007 case SIOCSIFADDR:
2008 case SIOCGIFBRDADDR:
2009 case SIOCSIFBRDADDR:
2010 case SIOCGIFNETMASK:
2011 case SIOCSIFNETMASK:
2012 case SIOCGIFDSTADDR:
2013 case SIOCSIFDSTADDR:
2014 case SIOCSIFFLAGS:
2015 if (!net_eq(sock_net(sk), &init_net))
2016 return -ENOIOCTLCMD;
2017 return inet_dgram_ops.ioctl(sock, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002018#endif
2019
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00002020 default:
2021 return -ENOIOCTLCMD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022 }
2023 return 0;
2024}
2025
2026#ifndef CONFIG_PACKET_MMAP
2027#define packet_mmap sock_no_mmap
2028#define packet_poll datagram_poll
2029#else
2030
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00002031static unsigned int packet_poll(struct file *file, struct socket *sock,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002032 poll_table *wait)
2033{
2034 struct sock *sk = sock->sk;
2035 struct packet_sock *po = pkt_sk(sk);
2036 unsigned int mask = datagram_poll(file, sock, wait);
2037
2038 spin_lock_bh(&sk->sk_receive_queue.lock);
Johann Baudy69e3c752009-05-18 22:11:22 -07002039 if (po->rx_ring.pg_vec) {
2040 if (!packet_previous_frame(po, &po->rx_ring, TP_STATUS_KERNEL))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041 mask |= POLLIN | POLLRDNORM;
2042 }
2043 spin_unlock_bh(&sk->sk_receive_queue.lock);
Johann Baudy69e3c752009-05-18 22:11:22 -07002044 spin_lock_bh(&sk->sk_write_queue.lock);
2045 if (po->tx_ring.pg_vec) {
2046 if (packet_current_frame(po, &po->tx_ring, TP_STATUS_AVAILABLE))
2047 mask |= POLLOUT | POLLWRNORM;
2048 }
2049 spin_unlock_bh(&sk->sk_write_queue.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050 return mask;
2051}
2052
2053
2054/* Dirty? Well, I still did not learn better way to account
2055 * for user mmaps.
2056 */
2057
2058static void packet_mm_open(struct vm_area_struct *vma)
2059{
2060 struct file *file = vma->vm_file;
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00002061 struct socket *sock = file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062 struct sock *sk = sock->sk;
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +09002063
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064 if (sk)
2065 atomic_inc(&pkt_sk(sk)->mapped);
2066}
2067
2068static void packet_mm_close(struct vm_area_struct *vma)
2069{
2070 struct file *file = vma->vm_file;
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00002071 struct socket *sock = file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002072 struct sock *sk = sock->sk;
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +09002073
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074 if (sk)
2075 atomic_dec(&pkt_sk(sk)->mapped);
2076}
2077
Alexey Dobriyanf0f37e22009-09-27 22:29:37 +04002078static const struct vm_operations_struct packet_mmap_ops = {
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00002079 .open = packet_mm_open,
2080 .close = packet_mm_close,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081};
2082
David S. Miller4ebf0ae2005-12-06 16:38:35 -08002083static void free_pg_vec(char **pg_vec, unsigned int order, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002084{
2085 int i;
2086
David S. Miller4ebf0ae2005-12-06 16:38:35 -08002087 for (i = 0; i < len; i++) {
2088 if (likely(pg_vec[i]))
2089 free_pages((unsigned long) pg_vec[i], order);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002090 }
2091 kfree(pg_vec);
2092}
2093
David S. Miller4ebf0ae2005-12-06 16:38:35 -08002094static inline char *alloc_one_pg_vec_page(unsigned long order)
2095{
Eric Dumazet719bfea2009-04-15 03:39:52 -07002096 gfp_t gfp_flags = GFP_KERNEL | __GFP_COMP | __GFP_ZERO | __GFP_NOWARN;
2097
2098 return (char *) __get_free_pages(gfp_flags, order);
David S. Miller4ebf0ae2005-12-06 16:38:35 -08002099}
2100
2101static char **alloc_pg_vec(struct tpacket_req *req, int order)
2102{
2103 unsigned int block_nr = req->tp_block_nr;
2104 char **pg_vec;
2105 int i;
2106
2107 pg_vec = kzalloc(block_nr * sizeof(char *), GFP_KERNEL);
2108 if (unlikely(!pg_vec))
2109 goto out;
2110
2111 for (i = 0; i < block_nr; i++) {
2112 pg_vec[i] = alloc_one_pg_vec_page(order);
2113 if (unlikely(!pg_vec[i]))
2114 goto out_free_pgvec;
2115 }
2116
2117out:
2118 return pg_vec;
2119
2120out_free_pgvec:
2121 free_pg_vec(pg_vec, order, block_nr);
2122 pg_vec = NULL;
2123 goto out;
2124}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002125
Johann Baudy69e3c752009-05-18 22:11:22 -07002126static int packet_set_ring(struct sock *sk, struct tpacket_req *req,
2127 int closing, int tx_ring)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128{
2129 char **pg_vec = NULL;
2130 struct packet_sock *po = pkt_sk(sk);
Al Viro0e11c912006-11-08 00:26:29 -08002131 int was_running, order = 0;
Johann Baudy69e3c752009-05-18 22:11:22 -07002132 struct packet_ring_buffer *rb;
2133 struct sk_buff_head *rb_queue;
Al Viro0e11c912006-11-08 00:26:29 -08002134 __be16 num;
Johann Baudy69e3c752009-05-18 22:11:22 -07002135 int err;
2136
2137 rb = tx_ring ? &po->tx_ring : &po->rx_ring;
2138 rb_queue = tx_ring ? &sk->sk_write_queue : &sk->sk_receive_queue;
2139
2140 err = -EBUSY;
2141 if (!closing) {
2142 if (atomic_read(&po->mapped))
2143 goto out;
2144 if (atomic_read(&rb->pending))
2145 goto out;
2146 }
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +09002147
Linus Torvalds1da177e2005-04-16 15:20:36 -07002148 if (req->tp_block_nr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149 /* Sanity tests and some calculations */
Johann Baudy69e3c752009-05-18 22:11:22 -07002150 err = -EBUSY;
2151 if (unlikely(rb->pg_vec))
2152 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153
Patrick McHardybbd6ef82008-07-14 22:50:15 -07002154 switch (po->tp_version) {
2155 case TPACKET_V1:
2156 po->tp_hdrlen = TPACKET_HDRLEN;
2157 break;
2158 case TPACKET_V2:
2159 po->tp_hdrlen = TPACKET2_HDRLEN;
2160 break;
2161 }
2162
Johann Baudy69e3c752009-05-18 22:11:22 -07002163 err = -EINVAL;
David S. Miller4ebf0ae2005-12-06 16:38:35 -08002164 if (unlikely((int)req->tp_block_size <= 0))
Johann Baudy69e3c752009-05-18 22:11:22 -07002165 goto out;
David S. Miller4ebf0ae2005-12-06 16:38:35 -08002166 if (unlikely(req->tp_block_size & (PAGE_SIZE - 1)))
Johann Baudy69e3c752009-05-18 22:11:22 -07002167 goto out;
Patrick McHardy89133362008-07-18 18:05:19 -07002168 if (unlikely(req->tp_frame_size < po->tp_hdrlen +
Johann Baudy69e3c752009-05-18 22:11:22 -07002169 po->tp_reserve))
2170 goto out;
David S. Miller4ebf0ae2005-12-06 16:38:35 -08002171 if (unlikely(req->tp_frame_size & (TPACKET_ALIGNMENT - 1)))
Johann Baudy69e3c752009-05-18 22:11:22 -07002172 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002173
Johann Baudy69e3c752009-05-18 22:11:22 -07002174 rb->frames_per_block = req->tp_block_size/req->tp_frame_size;
2175 if (unlikely(rb->frames_per_block <= 0))
2176 goto out;
2177 if (unlikely((rb->frames_per_block * req->tp_block_nr) !=
2178 req->tp_frame_nr))
2179 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002180
2181 err = -ENOMEM;
David S. Miller4ebf0ae2005-12-06 16:38:35 -08002182 order = get_order(req->tp_block_size);
2183 pg_vec = alloc_pg_vec(req, order);
2184 if (unlikely(!pg_vec))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185 goto out;
Johann Baudy69e3c752009-05-18 22:11:22 -07002186 }
2187 /* Done */
2188 else {
2189 err = -EINVAL;
David S. Miller4ebf0ae2005-12-06 16:38:35 -08002190 if (unlikely(req->tp_frame_nr))
Johann Baudy69e3c752009-05-18 22:11:22 -07002191 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192 }
2193
2194 lock_sock(sk);
2195
2196 /* Detach socket from network */
2197 spin_lock(&po->bind_lock);
2198 was_running = po->running;
2199 num = po->num;
2200 if (was_running) {
2201 __dev_remove_pack(&po->prot_hook);
2202 po->num = 0;
2203 po->running = 0;
2204 __sock_put(sk);
2205 }
2206 spin_unlock(&po->bind_lock);
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +09002207
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208 synchronize_net();
2209
2210 err = -EBUSY;
Herbert Xu905db442009-01-30 14:12:06 -08002211 mutex_lock(&po->pg_vec_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002212 if (closing || atomic_read(&po->mapped) == 0) {
2213 err = 0;
2214#define XC(a, b) ({ __typeof__ ((a)) __t; __t = (a); (a) = (b); __t; })
Johann Baudy69e3c752009-05-18 22:11:22 -07002215 spin_lock_bh(&rb_queue->lock);
2216 pg_vec = XC(rb->pg_vec, pg_vec);
2217 rb->frame_max = (req->tp_frame_nr - 1);
2218 rb->head = 0;
2219 rb->frame_size = req->tp_frame_size;
2220 spin_unlock_bh(&rb_queue->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002221
Johann Baudy69e3c752009-05-18 22:11:22 -07002222 order = XC(rb->pg_vec_order, order);
2223 req->tp_block_nr = XC(rb->pg_vec_len, req->tp_block_nr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002224
Johann Baudy69e3c752009-05-18 22:11:22 -07002225 rb->pg_vec_pages = req->tp_block_size/PAGE_SIZE;
2226 po->prot_hook.func = (po->rx_ring.pg_vec) ?
2227 tpacket_rcv : packet_rcv;
2228 skb_queue_purge(rb_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002229#undef XC
2230 if (atomic_read(&po->mapped))
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00002231 pr_err("packet_mmap: vma is busy: %d\n",
2232 atomic_read(&po->mapped));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233 }
Herbert Xu905db442009-01-30 14:12:06 -08002234 mutex_unlock(&po->pg_vec_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235
2236 spin_lock(&po->bind_lock);
2237 if (was_running && !po->running) {
2238 sock_hold(sk);
2239 po->running = 1;
2240 po->num = num;
2241 dev_add_pack(&po->prot_hook);
2242 }
2243 spin_unlock(&po->bind_lock);
2244
2245 release_sock(sk);
2246
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247 if (pg_vec)
2248 free_pg_vec(pg_vec, order, req->tp_block_nr);
2249out:
2250 return err;
2251}
2252
Johann Baudy69e3c752009-05-18 22:11:22 -07002253static int packet_mmap(struct file *file, struct socket *sock,
2254 struct vm_area_struct *vma)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002255{
2256 struct sock *sk = sock->sk;
2257 struct packet_sock *po = pkt_sk(sk);
Johann Baudy69e3c752009-05-18 22:11:22 -07002258 unsigned long size, expected_size;
2259 struct packet_ring_buffer *rb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260 unsigned long start;
2261 int err = -EINVAL;
2262 int i;
2263
2264 if (vma->vm_pgoff)
2265 return -EINVAL;
2266
Herbert Xu905db442009-01-30 14:12:06 -08002267 mutex_lock(&po->pg_vec_lock);
Johann Baudy69e3c752009-05-18 22:11:22 -07002268
2269 expected_size = 0;
2270 for (rb = &po->rx_ring; rb <= &po->tx_ring; rb++) {
2271 if (rb->pg_vec) {
2272 expected_size += rb->pg_vec_len
2273 * rb->pg_vec_pages
2274 * PAGE_SIZE;
2275 }
2276 }
2277
2278 if (expected_size == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279 goto out;
Johann Baudy69e3c752009-05-18 22:11:22 -07002280
2281 size = vma->vm_end - vma->vm_start;
2282 if (size != expected_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283 goto out;
2284
Linus Torvalds1da177e2005-04-16 15:20:36 -07002285 start = vma->vm_start;
Johann Baudy69e3c752009-05-18 22:11:22 -07002286 for (rb = &po->rx_ring; rb <= &po->tx_ring; rb++) {
2287 if (rb->pg_vec == NULL)
2288 continue;
David S. Miller4ebf0ae2005-12-06 16:38:35 -08002289
Johann Baudy69e3c752009-05-18 22:11:22 -07002290 for (i = 0; i < rb->pg_vec_len; i++) {
2291 struct page *page = virt_to_page(rb->pg_vec[i]);
2292 int pg_num;
2293
2294 for (pg_num = 0; pg_num < rb->pg_vec_pages;
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00002295 pg_num++, page++) {
Johann Baudy69e3c752009-05-18 22:11:22 -07002296 err = vm_insert_page(vma, start, page);
2297 if (unlikely(err))
2298 goto out;
2299 start += PAGE_SIZE;
2300 }
David S. Miller4ebf0ae2005-12-06 16:38:35 -08002301 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002302 }
Johann Baudy69e3c752009-05-18 22:11:22 -07002303
David S. Miller4ebf0ae2005-12-06 16:38:35 -08002304 atomic_inc(&po->mapped);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002305 vma->vm_ops = &packet_mmap_ops;
2306 err = 0;
2307
2308out:
Herbert Xu905db442009-01-30 14:12:06 -08002309 mutex_unlock(&po->pg_vec_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002310 return err;
2311}
2312#endif
2313
2314
Eric Dumazet90ddc4f2005-12-22 12:49:22 -08002315static const struct proto_ops packet_ops_spkt = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002316 .family = PF_PACKET,
2317 .owner = THIS_MODULE,
2318 .release = packet_release,
2319 .bind = packet_bind_spkt,
2320 .connect = sock_no_connect,
2321 .socketpair = sock_no_socketpair,
2322 .accept = sock_no_accept,
2323 .getname = packet_getname_spkt,
2324 .poll = datagram_poll,
2325 .ioctl = packet_ioctl,
2326 .listen = sock_no_listen,
2327 .shutdown = sock_no_shutdown,
2328 .setsockopt = sock_no_setsockopt,
2329 .getsockopt = sock_no_getsockopt,
2330 .sendmsg = packet_sendmsg_spkt,
2331 .recvmsg = packet_recvmsg,
2332 .mmap = sock_no_mmap,
2333 .sendpage = sock_no_sendpage,
2334};
Linus Torvalds1da177e2005-04-16 15:20:36 -07002335
Eric Dumazet90ddc4f2005-12-22 12:49:22 -08002336static const struct proto_ops packet_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337 .family = PF_PACKET,
2338 .owner = THIS_MODULE,
2339 .release = packet_release,
2340 .bind = packet_bind,
2341 .connect = sock_no_connect,
2342 .socketpair = sock_no_socketpair,
2343 .accept = sock_no_accept,
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +09002344 .getname = packet_getname,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002345 .poll = packet_poll,
2346 .ioctl = packet_ioctl,
2347 .listen = sock_no_listen,
2348 .shutdown = sock_no_shutdown,
2349 .setsockopt = packet_setsockopt,
2350 .getsockopt = packet_getsockopt,
2351 .sendmsg = packet_sendmsg,
2352 .recvmsg = packet_recvmsg,
2353 .mmap = packet_mmap,
2354 .sendpage = sock_no_sendpage,
2355};
2356
Stephen Hemmingerec1b4cf2009-10-05 05:58:39 +00002357static const struct net_proto_family packet_family_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002358 .family = PF_PACKET,
2359 .create = packet_create,
2360 .owner = THIS_MODULE,
2361};
2362
2363static struct notifier_block packet_netdev_notifier = {
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00002364 .notifier_call = packet_notifier,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002365};
2366
2367#ifdef CONFIG_PROC_FS
Denis V. Lunevd12d01d2007-11-19 22:28:35 -08002368static inline struct sock *packet_seq_idx(struct net *net, loff_t off)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002369{
2370 struct sock *s;
2371 struct hlist_node *node;
2372
Denis V. Lunev2aaef4e2007-12-11 04:19:54 -08002373 sk_for_each(s, node, &net->packet.sklist) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002374 if (!off--)
2375 return s;
2376 }
2377 return NULL;
2378}
2379
2380static void *packet_seq_start(struct seq_file *seq, loff_t *pos)
Eric Dumazet40ccbf52008-01-07 22:39:57 -08002381 __acquires(seq_file_net(seq)->packet.sklist_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002382{
Denis V. Luneve372c412007-11-19 22:31:54 -08002383 struct net *net = seq_file_net(seq);
Denis V. Lunev2aaef4e2007-12-11 04:19:54 -08002384 read_lock(&net->packet.sklist_lock);
Denis V. Lunevd12d01d2007-11-19 22:28:35 -08002385 return *pos ? packet_seq_idx(net, *pos - 1) : SEQ_START_TOKEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002386}
2387
2388static void *packet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2389{
Herbert Xu1bf40952007-12-16 14:04:02 -08002390 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002391 ++*pos;
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +09002392 return (v == SEQ_START_TOKEN)
Denis V. Lunev2aaef4e2007-12-11 04:19:54 -08002393 ? sk_head(&net->packet.sklist)
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00002394 : sk_next((struct sock *)v) ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002395}
2396
2397static void packet_seq_stop(struct seq_file *seq, void *v)
Eric Dumazet40ccbf52008-01-07 22:39:57 -08002398 __releases(seq_file_net(seq)->packet.sklist_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002399{
Herbert Xu1bf40952007-12-16 14:04:02 -08002400 struct net *net = seq_file_net(seq);
Denis V. Lunev2aaef4e2007-12-11 04:19:54 -08002401 read_unlock(&net->packet.sklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002402}
2403
YOSHIFUJI Hideaki1ce4f282007-02-09 23:25:10 +09002404static int packet_seq_show(struct seq_file *seq, void *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002405{
2406 if (v == SEQ_START_TOKEN)
2407 seq_puts(seq, "sk RefCnt Type Proto Iface R Rmem User Inode\n");
2408 else {
2409 struct sock *s = v;
2410 const struct packet_sock *po = pkt_sk(s);
2411
2412 seq_printf(seq,
2413 "%p %-6d %-4d %04x %-5d %1d %-6u %-6u %-6lu\n",
2414 s,
2415 atomic_read(&s->sk_refcnt),
2416 s->sk_type,
2417 ntohs(po->num),
2418 po->ifindex,
2419 po->running,
2420 atomic_read(&s->sk_rmem_alloc),
2421 sock_i_uid(s),
Eric Dumazet40d4e3d2009-07-21 21:57:59 +00002422 sock_i_ino(s));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002423 }
2424
2425 return 0;
2426}
2427
Philippe De Muyter56b3d972007-07-10 23:07:31 -07002428static const struct seq_operations packet_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002429 .start = packet_seq_start,
2430 .next = packet_seq_next,
2431 .stop = packet_seq_stop,
2432 .show = packet_seq_show,
2433};
2434
2435static int packet_seq_open(struct inode *inode, struct file *file)
2436{
Denis V. Luneve372c412007-11-19 22:31:54 -08002437 return seq_open_net(inode, file, &packet_seq_ops,
2438 sizeof(struct seq_net_private));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002439}
2440
Arjan van de Venda7071d2007-02-12 00:55:36 -08002441static const struct file_operations packet_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002442 .owner = THIS_MODULE,
2443 .open = packet_seq_open,
2444 .read = seq_read,
2445 .llseek = seq_lseek,
Denis V. Luneve372c412007-11-19 22:31:54 -08002446 .release = seq_release_net,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002447};
2448
2449#endif
2450
Denis V. Lunevd12d01d2007-11-19 22:28:35 -08002451static int packet_net_init(struct net *net)
2452{
Denis V. Lunev2aaef4e2007-12-11 04:19:54 -08002453 rwlock_init(&net->packet.sklist_lock);
2454 INIT_HLIST_HEAD(&net->packet.sklist);
Denis V. Lunevd12d01d2007-11-19 22:28:35 -08002455
2456 if (!proc_net_fops_create(net, "packet", 0, &packet_seq_fops))
2457 return -ENOMEM;
2458
2459 return 0;
2460}
2461
2462static void packet_net_exit(struct net *net)
2463{
2464 proc_net_remove(net, "packet");
2465}
2466
2467static struct pernet_operations packet_net_ops = {
2468 .init = packet_net_init,
2469 .exit = packet_net_exit,
2470};
2471
2472
Linus Torvalds1da177e2005-04-16 15:20:36 -07002473static void __exit packet_exit(void)
2474{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475 unregister_netdevice_notifier(&packet_netdev_notifier);
Denis V. Lunevd12d01d2007-11-19 22:28:35 -08002476 unregister_pernet_subsys(&packet_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002477 sock_unregister(PF_PACKET);
2478 proto_unregister(&packet_proto);
2479}
2480
2481static int __init packet_init(void)
2482{
2483 int rc = proto_register(&packet_proto, 0);
2484
2485 if (rc != 0)
2486 goto out;
2487
2488 sock_register(&packet_family_ops);
Denis V. Lunevd12d01d2007-11-19 22:28:35 -08002489 register_pernet_subsys(&packet_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002490 register_netdevice_notifier(&packet_netdev_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002491out:
2492 return rc;
2493}
2494
2495module_init(packet_init);
2496module_exit(packet_exit);
2497MODULE_LICENSE("GPL");
2498MODULE_ALIAS_NETPROTO(PF_PACKET);