Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * INET An implementation of the TCP/IP protocol suite for the LINUX
4 : : * operating system. INET is implemented using the BSD Socket
5 : : * interface as the means of communication with the user level.
6 : : *
7 : : * PACKET - implements raw packet sockets.
8 : : *
9 : : * Authors: Ross Biro
10 : : * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
11 : : * Alan Cox, <gw4pts@gw4pts.ampr.org>
12 : : *
13 : : * Fixes:
14 : : * Alan Cox : verify_area() now used correctly
15 : : * Alan Cox : new skbuff lists, look ma no backlogs!
16 : : * Alan Cox : tidied skbuff lists.
17 : : * Alan Cox : Now uses generic datagram routines I
18 : : * added. Also fixed the peek/read crash
19 : : * from all old Linux datagram code.
20 : : * Alan Cox : Uses the improved datagram code.
21 : : * Alan Cox : Added NULL's for socket options.
22 : : * Alan Cox : Re-commented the code.
23 : : * Alan Cox : Use new kernel side addressing
24 : : * Rob Janssen : Correct MTU usage.
25 : : * Dave Platt : Counter leaks caused by incorrect
26 : : * interrupt locking and some slightly
27 : : * dubious gcc output. Can you read
28 : : * compiler: it said _VOLATILE_
29 : : * Richard Kooijman : Timestamp fixes.
30 : : * Alan Cox : New buffers. Use sk->mac.raw.
31 : : * Alan Cox : sendmsg/recvmsg support.
32 : : * Alan Cox : Protocol setting support
33 : : * Alexey Kuznetsov : Untied from IPv4 stack.
34 : : * Cyrus Durgin : Fixed kerneld for kmod.
35 : : * Michal Ostrowski : Module initialization cleanup.
36 : : * Ulises Alonso : Frame number limit removal and
37 : : * packet_set_ring memory leak.
38 : : * Eric Biederman : Allow for > 8 byte hardware addresses.
39 : : * The convention is that longer addresses
40 : : * will simply extend the hardware address
41 : : * byte arrays at the end of sockaddr_ll
42 : : * and packet_mreq.
43 : : * Johann Baudy : Added TX RING.
44 : : * Chetan Loke : Implemented TPACKET_V3 block abstraction
45 : : * layer.
46 : : * Copyright (C) 2011, <lokec@ccs.neu.edu>
47 : : */
48 : :
49 : : #include <linux/types.h>
50 : : #include <linux/mm.h>
51 : : #include <linux/capability.h>
52 : : #include <linux/fcntl.h>
53 : : #include <linux/socket.h>
54 : : #include <linux/in.h>
55 : : #include <linux/inet.h>
56 : : #include <linux/netdevice.h>
57 : : #include <linux/if_packet.h>
58 : : #include <linux/wireless.h>
59 : : #include <linux/kernel.h>
60 : : #include <linux/kmod.h>
61 : : #include <linux/slab.h>
62 : : #include <linux/vmalloc.h>
63 : : #include <net/net_namespace.h>
64 : : #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 <linux/uaccess.h>
71 : : #include <asm/ioctls.h>
72 : : #include <asm/page.h>
73 : : #include <asm/cacheflush.h>
74 : : #include <asm/io.h>
75 : : #include <linux/proc_fs.h>
76 : : #include <linux/seq_file.h>
77 : : #include <linux/poll.h>
78 : : #include <linux/module.h>
79 : : #include <linux/init.h>
80 : : #include <linux/mutex.h>
81 : : #include <linux/if_vlan.h>
82 : : #include <linux/virtio_net.h>
83 : : #include <linux/errqueue.h>
84 : : #include <linux/net_tstamp.h>
85 : : #include <linux/percpu.h>
86 : : #ifdef CONFIG_INET
87 : : #include <net/inet_common.h>
88 : : #endif
89 : : #include <linux/bpf.h>
90 : : #include <net/compat.h>
91 : :
92 : : #include "internal.h"
93 : :
94 : : /*
95 : : Assumptions:
96 : : - if device has no dev->hard_header routine, it adds and removes ll header
97 : : inside itself. In this case ll header is invisible outside of device,
98 : : but higher levels still should reserve dev->hard_header_len.
99 : : Some devices are enough clever to reallocate skb, when header
100 : : will not fit to reserved space (tunnel), another ones are silly
101 : : (PPP).
102 : : - packet socket receives packets with pulled ll header,
103 : : so that SOCK_RAW should push it back.
104 : :
105 : : On receive:
106 : : -----------
107 : :
108 : : Incoming, dev->hard_header!=NULL
109 : : mac_header -> ll header
110 : : data -> data
111 : :
112 : : Outgoing, dev->hard_header!=NULL
113 : : mac_header -> ll header
114 : : data -> ll header
115 : :
116 : : Incoming, dev->hard_header==NULL
117 : : mac_header -> UNKNOWN position. It is very likely, that it points to ll
118 : : header. PPP makes it, that is wrong, because introduce
119 : : assymetry between rx and tx paths.
120 : : data -> data
121 : :
122 : : Outgoing, dev->hard_header==NULL
123 : : mac_header -> data. ll header is still not built!
124 : : data -> data
125 : :
126 : : Resume
127 : : If dev->hard_header==NULL we are unlikely to restore sensible ll header.
128 : :
129 : :
130 : : On transmit:
131 : : ------------
132 : :
133 : : dev->hard_header != NULL
134 : : mac_header -> ll header
135 : : data -> ll header
136 : :
137 : : dev->hard_header == NULL (ll header is added by device, we cannot control it)
138 : : mac_header -> data
139 : : data -> data
140 : :
141 : : We should set nh.raw on output to correct posistion,
142 : : packet classifier depends on it.
143 : : */
144 : :
145 : : /* Private packet socket structures. */
146 : :
147 : : /* identical to struct packet_mreq except it has
148 : : * a longer address field.
149 : : */
150 : : struct packet_mreq_max {
151 : : int mr_ifindex;
152 : : unsigned short mr_type;
153 : : unsigned short mr_alen;
154 : : unsigned char mr_address[MAX_ADDR_LEN];
155 : : };
156 : :
157 : : union tpacket_uhdr {
158 : : struct tpacket_hdr *h1;
159 : : struct tpacket2_hdr *h2;
160 : : struct tpacket3_hdr *h3;
161 : : void *raw;
162 : : };
163 : :
164 : : static int packet_set_ring(struct sock *sk, union tpacket_req_u *req_u,
165 : : int closing, int tx_ring);
166 : :
167 : : #define V3_ALIGNMENT (8)
168 : :
169 : : #define BLK_HDR_LEN (ALIGN(sizeof(struct tpacket_block_desc), V3_ALIGNMENT))
170 : :
171 : : #define BLK_PLUS_PRIV(sz_of_priv) \
172 : : (BLK_HDR_LEN + ALIGN((sz_of_priv), V3_ALIGNMENT))
173 : :
174 : : #define BLOCK_STATUS(x) ((x)->hdr.bh1.block_status)
175 : : #define BLOCK_NUM_PKTS(x) ((x)->hdr.bh1.num_pkts)
176 : : #define BLOCK_O2FP(x) ((x)->hdr.bh1.offset_to_first_pkt)
177 : : #define BLOCK_LEN(x) ((x)->hdr.bh1.blk_len)
178 : : #define BLOCK_SNUM(x) ((x)->hdr.bh1.seq_num)
179 : : #define BLOCK_O2PRIV(x) ((x)->offset_to_priv)
180 : : #define BLOCK_PRIV(x) ((void *)((char *)(x) + BLOCK_O2PRIV(x)))
181 : :
182 : : struct packet_sock;
183 : : static int tpacket_rcv(struct sk_buff *skb, struct net_device *dev,
184 : : struct packet_type *pt, struct net_device *orig_dev);
185 : :
186 : : static void *packet_previous_frame(struct packet_sock *po,
187 : : struct packet_ring_buffer *rb,
188 : : int status);
189 : : static void packet_increment_head(struct packet_ring_buffer *buff);
190 : : static int prb_curr_blk_in_use(struct tpacket_block_desc *);
191 : : static void *prb_dispatch_next_block(struct tpacket_kbdq_core *,
192 : : struct packet_sock *);
193 : : static void prb_retire_current_block(struct tpacket_kbdq_core *,
194 : : struct packet_sock *, unsigned int status);
195 : : static int prb_queue_frozen(struct tpacket_kbdq_core *);
196 : : static void prb_open_block(struct tpacket_kbdq_core *,
197 : : struct tpacket_block_desc *);
198 : : static void prb_retire_rx_blk_timer_expired(struct timer_list *);
199 : : static void _prb_refresh_rx_retire_blk_timer(struct tpacket_kbdq_core *);
200 : : static void prb_fill_rxhash(struct tpacket_kbdq_core *, struct tpacket3_hdr *);
201 : : static void prb_clear_rxhash(struct tpacket_kbdq_core *,
202 : : struct tpacket3_hdr *);
203 : : static void prb_fill_vlan_info(struct tpacket_kbdq_core *,
204 : : struct tpacket3_hdr *);
205 : : static void packet_flush_mclist(struct sock *sk);
206 : : static u16 packet_pick_tx_queue(struct sk_buff *skb);
207 : :
208 : : struct packet_skb_cb {
209 : : union {
210 : : struct sockaddr_pkt pkt;
211 : : union {
212 : : /* Trick: alias skb original length with
213 : : * ll.sll_family and ll.protocol in order
214 : : * to save room.
215 : : */
216 : : unsigned int origlen;
217 : : struct sockaddr_ll ll;
218 : : };
219 : : } sa;
220 : : };
221 : :
222 : : #define vio_le() virtio_legacy_is_little_endian()
223 : :
224 : : #define PACKET_SKB_CB(__skb) ((struct packet_skb_cb *)((__skb)->cb))
225 : :
226 : : #define GET_PBDQC_FROM_RB(x) ((struct tpacket_kbdq_core *)(&(x)->prb_bdqc))
227 : : #define GET_PBLOCK_DESC(x, bid) \
228 : : ((struct tpacket_block_desc *)((x)->pkbdq[(bid)].buffer))
229 : : #define GET_CURR_PBLOCK_DESC_FROM_CORE(x) \
230 : : ((struct tpacket_block_desc *)((x)->pkbdq[(x)->kactive_blk_num].buffer))
231 : : #define GET_NEXT_PRB_BLK_NUM(x) \
232 : : (((x)->kactive_blk_num < ((x)->knum_blocks-1)) ? \
233 : : ((x)->kactive_blk_num+1) : 0)
234 : :
235 : : static void __fanout_unlink(struct sock *sk, struct packet_sock *po);
236 : : static void __fanout_link(struct sock *sk, struct packet_sock *po);
237 : :
238 : 0 : static int packet_direct_xmit(struct sk_buff *skb)
239 : : {
240 : 0 : return dev_direct_xmit(skb, packet_pick_tx_queue(skb));
241 : : }
242 : :
243 : : static struct net_device *packet_cached_dev_get(struct packet_sock *po)
244 : : {
245 : : struct net_device *dev;
246 : :
247 : : rcu_read_lock();
248 : 3 : dev = rcu_dereference(po->cached_dev);
249 : 3 : if (likely(dev))
250 : 3 : dev_hold(dev);
251 : : rcu_read_unlock();
252 : :
253 : : return dev;
254 : : }
255 : :
256 : : static void packet_cached_dev_assign(struct packet_sock *po,
257 : : struct net_device *dev)
258 : : {
259 : 3 : rcu_assign_pointer(po->cached_dev, dev);
260 : : }
261 : :
262 : : static void packet_cached_dev_reset(struct packet_sock *po)
263 : : {
264 : : RCU_INIT_POINTER(po->cached_dev, NULL);
265 : : }
266 : :
267 : : static bool packet_use_direct_xmit(const struct packet_sock *po)
268 : : {
269 : 0 : return po->xmit == packet_direct_xmit;
270 : : }
271 : :
272 : 0 : static u16 packet_pick_tx_queue(struct sk_buff *skb)
273 : : {
274 : 0 : struct net_device *dev = skb->dev;
275 : 0 : const struct net_device_ops *ops = dev->netdev_ops;
276 : 0 : int cpu = raw_smp_processor_id();
277 : : u16 queue_index;
278 : :
279 : : #ifdef CONFIG_XPS
280 : 0 : skb->sender_cpu = cpu + 1;
281 : : #endif
282 : 0 : skb_record_rx_queue(skb, cpu % dev->real_num_tx_queues);
283 : 0 : if (ops->ndo_select_queue) {
284 : 0 : queue_index = ops->ndo_select_queue(dev, skb, NULL);
285 : 0 : queue_index = netdev_cap_txqueue(dev, queue_index);
286 : : } else {
287 : 0 : queue_index = netdev_pick_tx(dev, skb, NULL);
288 : : }
289 : :
290 : 0 : return queue_index;
291 : : }
292 : :
293 : : /* __register_prot_hook must be invoked through register_prot_hook
294 : : * or from a context in which asynchronous accesses to the packet
295 : : * socket is not possible (packet_create()).
296 : : */
297 : 3 : static void __register_prot_hook(struct sock *sk)
298 : : {
299 : : struct packet_sock *po = pkt_sk(sk);
300 : :
301 : 3 : if (!po->running) {
302 : 3 : if (po->fanout)
303 : 0 : __fanout_link(sk, po);
304 : : else
305 : 3 : dev_add_pack(&po->prot_hook);
306 : :
307 : : sock_hold(sk);
308 : 3 : po->running = 1;
309 : : }
310 : 3 : }
311 : :
312 : : static void register_prot_hook(struct sock *sk)
313 : : {
314 : : lockdep_assert_held_once(&pkt_sk(sk)->bind_lock);
315 : 3 : __register_prot_hook(sk);
316 : : }
317 : :
318 : : /* If the sync parameter is true, we will temporarily drop
319 : : * the po->bind_lock and do a synchronize_net to make sure no
320 : : * asynchronous packet processing paths still refer to the elements
321 : : * of po->prot_hook. If the sync parameter is false, it is the
322 : : * callers responsibility to take care of this.
323 : : */
324 : 3 : static void __unregister_prot_hook(struct sock *sk, bool sync)
325 : : {
326 : : struct packet_sock *po = pkt_sk(sk);
327 : :
328 : : lockdep_assert_held_once(&po->bind_lock);
329 : :
330 : 3 : po->running = 0;
331 : :
332 : 3 : if (po->fanout)
333 : 0 : __fanout_unlink(sk, po);
334 : : else
335 : 3 : __dev_remove_pack(&po->prot_hook);
336 : :
337 : : __sock_put(sk);
338 : :
339 : 3 : if (sync) {
340 : : spin_unlock(&po->bind_lock);
341 : 3 : synchronize_net();
342 : : spin_lock(&po->bind_lock);
343 : : }
344 : 3 : }
345 : :
346 : : static void unregister_prot_hook(struct sock *sk, bool sync)
347 : : {
348 : : struct packet_sock *po = pkt_sk(sk);
349 : :
350 : 3 : if (po->running)
351 : 3 : __unregister_prot_hook(sk, sync);
352 : : }
353 : :
354 : 0 : static inline struct page * __pure pgv_to_page(void *addr)
355 : : {
356 : 0 : if (is_vmalloc_addr(addr))
357 : 0 : return vmalloc_to_page(addr);
358 : 0 : return virt_to_page(addr);
359 : : }
360 : :
361 : 0 : static void __packet_set_status(struct packet_sock *po, void *frame, int status)
362 : : {
363 : : union tpacket_uhdr h;
364 : :
365 : : h.raw = frame;
366 : 0 : switch (po->tp_version) {
367 : : case TPACKET_V1:
368 : 0 : h.h1->tp_status = status;
369 : 0 : flush_dcache_page(pgv_to_page(&h.h1->tp_status));
370 : 0 : break;
371 : : case TPACKET_V2:
372 : 0 : h.h2->tp_status = status;
373 : 0 : flush_dcache_page(pgv_to_page(&h.h2->tp_status));
374 : 0 : break;
375 : : case TPACKET_V3:
376 : 0 : h.h3->tp_status = status;
377 : 0 : flush_dcache_page(pgv_to_page(&h.h3->tp_status));
378 : 0 : break;
379 : : default:
380 : 0 : WARN(1, "TPACKET version not supported.\n");
381 : 0 : BUG();
382 : : }
383 : :
384 : 0 : smp_wmb();
385 : 0 : }
386 : :
387 : 0 : static int __packet_get_status(const struct packet_sock *po, void *frame)
388 : : {
389 : : union tpacket_uhdr h;
390 : :
391 : 0 : smp_rmb();
392 : :
393 : : h.raw = frame;
394 : 0 : switch (po->tp_version) {
395 : : case TPACKET_V1:
396 : 0 : flush_dcache_page(pgv_to_page(&h.h1->tp_status));
397 : 0 : return h.h1->tp_status;
398 : : case TPACKET_V2:
399 : 0 : flush_dcache_page(pgv_to_page(&h.h2->tp_status));
400 : 0 : return h.h2->tp_status;
401 : : case TPACKET_V3:
402 : 0 : flush_dcache_page(pgv_to_page(&h.h3->tp_status));
403 : 0 : return h.h3->tp_status;
404 : : default:
405 : 0 : WARN(1, "TPACKET version not supported.\n");
406 : 0 : BUG();
407 : : return 0;
408 : : }
409 : : }
410 : :
411 : 0 : static __u32 tpacket_get_timestamp(struct sk_buff *skb, struct timespec *ts,
412 : : unsigned int flags)
413 : : {
414 : : struct skb_shared_hwtstamps *shhwtstamps = skb_hwtstamps(skb);
415 : :
416 : 0 : if (shhwtstamps &&
417 : 0 : (flags & SOF_TIMESTAMPING_RAW_HARDWARE) &&
418 : 0 : ktime_to_timespec_cond(shhwtstamps->hwtstamp, ts))
419 : : return TP_STATUS_TS_RAW_HARDWARE;
420 : :
421 : 0 : if (ktime_to_timespec_cond(skb->tstamp, ts))
422 : : return TP_STATUS_TS_SOFTWARE;
423 : :
424 : 0 : return 0;
425 : : }
426 : :
427 : 0 : static __u32 __packet_set_timestamp(struct packet_sock *po, void *frame,
428 : : struct sk_buff *skb)
429 : : {
430 : : union tpacket_uhdr h;
431 : : struct timespec ts;
432 : : __u32 ts_status;
433 : :
434 : 0 : if (!(ts_status = tpacket_get_timestamp(skb, &ts, po->tp_tstamp)))
435 : : return 0;
436 : :
437 : : h.raw = frame;
438 : 0 : switch (po->tp_version) {
439 : : case TPACKET_V1:
440 : 0 : h.h1->tp_sec = ts.tv_sec;
441 : 0 : h.h1->tp_usec = ts.tv_nsec / NSEC_PER_USEC;
442 : 0 : break;
443 : : case TPACKET_V2:
444 : 0 : h.h2->tp_sec = ts.tv_sec;
445 : 0 : h.h2->tp_nsec = ts.tv_nsec;
446 : 0 : break;
447 : : case TPACKET_V3:
448 : 0 : h.h3->tp_sec = ts.tv_sec;
449 : 0 : h.h3->tp_nsec = ts.tv_nsec;
450 : 0 : break;
451 : : default:
452 : 0 : WARN(1, "TPACKET version not supported.\n");
453 : 0 : BUG();
454 : : }
455 : :
456 : : /* one flush is safe, as both fields always lie on the same cacheline */
457 : 0 : flush_dcache_page(pgv_to_page(&h.h1->tp_sec));
458 : 0 : smp_wmb();
459 : :
460 : 0 : return ts_status;
461 : : }
462 : :
463 : 0 : static void *packet_lookup_frame(const struct packet_sock *po,
464 : : const struct packet_ring_buffer *rb,
465 : : unsigned int position,
466 : : int status)
467 : : {
468 : : unsigned int pg_vec_pos, frame_offset;
469 : : union tpacket_uhdr h;
470 : :
471 : 0 : pg_vec_pos = position / rb->frames_per_block;
472 : 0 : frame_offset = position % rb->frames_per_block;
473 : :
474 : 0 : h.raw = rb->pg_vec[pg_vec_pos].buffer +
475 : 0 : (frame_offset * rb->frame_size);
476 : :
477 : 0 : if (status != __packet_get_status(po, h.raw))
478 : : return NULL;
479 : :
480 : 0 : return h.raw;
481 : : }
482 : :
483 : : static void *packet_current_frame(struct packet_sock *po,
484 : : struct packet_ring_buffer *rb,
485 : : int status)
486 : : {
487 : 0 : return packet_lookup_frame(po, rb, rb->head, status);
488 : : }
489 : :
490 : : static void prb_del_retire_blk_timer(struct tpacket_kbdq_core *pkc)
491 : : {
492 : 0 : del_timer_sync(&pkc->retire_blk_timer);
493 : : }
494 : :
495 : 0 : static void prb_shutdown_retire_blk_timer(struct packet_sock *po,
496 : : struct sk_buff_head *rb_queue)
497 : : {
498 : : struct tpacket_kbdq_core *pkc;
499 : :
500 : : pkc = GET_PBDQC_FROM_RB(&po->rx_ring);
501 : :
502 : : spin_lock_bh(&rb_queue->lock);
503 : 0 : pkc->delete_blk_timer = 1;
504 : : spin_unlock_bh(&rb_queue->lock);
505 : :
506 : : prb_del_retire_blk_timer(pkc);
507 : 0 : }
508 : :
509 : 0 : static void prb_setup_retire_blk_timer(struct packet_sock *po)
510 : : {
511 : : struct tpacket_kbdq_core *pkc;
512 : :
513 : : pkc = GET_PBDQC_FROM_RB(&po->rx_ring);
514 : 0 : timer_setup(&pkc->retire_blk_timer, prb_retire_rx_blk_timer_expired,
515 : : 0);
516 : 0 : pkc->retire_blk_timer.expires = jiffies;
517 : 0 : }
518 : :
519 : 0 : static int prb_calc_retire_blk_tmo(struct packet_sock *po,
520 : : int blk_size_in_bytes)
521 : : {
522 : : struct net_device *dev;
523 : : unsigned int mbits = 0, msec = 0, div = 0, tmo = 0;
524 : : struct ethtool_link_ksettings ecmd;
525 : : int err;
526 : :
527 : 0 : rtnl_lock();
528 : 0 : dev = __dev_get_by_index(sock_net(&po->sk), po->ifindex);
529 : 0 : if (unlikely(!dev)) {
530 : 0 : rtnl_unlock();
531 : 0 : return DEFAULT_PRB_RETIRE_TOV;
532 : : }
533 : 0 : err = __ethtool_get_link_ksettings(dev, &ecmd);
534 : 0 : rtnl_unlock();
535 : 0 : if (!err) {
536 : : /*
537 : : * If the link speed is so slow you don't really
538 : : * need to worry about perf anyways
539 : : */
540 : 0 : if (ecmd.base.speed < SPEED_1000 ||
541 : : ecmd.base.speed == SPEED_UNKNOWN) {
542 : : return DEFAULT_PRB_RETIRE_TOV;
543 : : } else {
544 : : msec = 1;
545 : 0 : div = ecmd.base.speed / 1000;
546 : : }
547 : : } else
548 : : return DEFAULT_PRB_RETIRE_TOV;
549 : :
550 : 0 : mbits = (blk_size_in_bytes * 8) / (1024 * 1024);
551 : :
552 : 0 : if (div)
553 : 0 : mbits /= div;
554 : :
555 : : tmo = mbits * msec;
556 : :
557 : 0 : if (div)
558 : 0 : return tmo+1;
559 : 0 : return tmo;
560 : : }
561 : :
562 : : static void prb_init_ft_ops(struct tpacket_kbdq_core *p1,
563 : : union tpacket_req_u *req_u)
564 : : {
565 : 0 : p1->feature_req_word = req_u->req3.tp_feature_req_word;
566 : : }
567 : :
568 : 0 : static void init_prb_bdqc(struct packet_sock *po,
569 : : struct packet_ring_buffer *rb,
570 : : struct pgv *pg_vec,
571 : : union tpacket_req_u *req_u)
572 : : {
573 : 0 : struct tpacket_kbdq_core *p1 = GET_PBDQC_FROM_RB(rb);
574 : : struct tpacket_block_desc *pbd;
575 : :
576 : 0 : memset(p1, 0x0, sizeof(*p1));
577 : :
578 : 0 : p1->knxt_seq_num = 1;
579 : 0 : p1->pkbdq = pg_vec;
580 : 0 : pbd = (struct tpacket_block_desc *)pg_vec[0].buffer;
581 : 0 : p1->pkblk_start = pg_vec[0].buffer;
582 : 0 : p1->kblk_size = req_u->req3.tp_block_size;
583 : 0 : p1->knum_blocks = req_u->req3.tp_block_nr;
584 : 0 : p1->hdrlen = po->tp_hdrlen;
585 : 0 : p1->version = po->tp_version;
586 : 0 : p1->last_kactive_blk_num = 0;
587 : 0 : po->stats.stats3.tp_freeze_q_cnt = 0;
588 : 0 : if (req_u->req3.tp_retire_blk_tov)
589 : 0 : p1->retire_blk_tov = req_u->req3.tp_retire_blk_tov;
590 : : else
591 : 0 : p1->retire_blk_tov = prb_calc_retire_blk_tmo(po,
592 : 0 : req_u->req3.tp_block_size);
593 : 0 : p1->tov_in_jiffies = msecs_to_jiffies(p1->retire_blk_tov);
594 : 0 : p1->blk_sizeof_priv = req_u->req3.tp_sizeof_priv;
595 : :
596 : 0 : p1->max_frame_len = p1->kblk_size - BLK_PLUS_PRIV(p1->blk_sizeof_priv);
597 : : prb_init_ft_ops(p1, req_u);
598 : 0 : prb_setup_retire_blk_timer(po);
599 : 0 : prb_open_block(p1, pbd);
600 : 0 : }
601 : :
602 : : /* Do NOT update the last_blk_num first.
603 : : * Assumes sk_buff_head lock is held.
604 : : */
605 : : static void _prb_refresh_rx_retire_blk_timer(struct tpacket_kbdq_core *pkc)
606 : : {
607 : 0 : mod_timer(&pkc->retire_blk_timer,
608 : 0 : jiffies + pkc->tov_in_jiffies);
609 : 0 : pkc->last_kactive_blk_num = pkc->kactive_blk_num;
610 : : }
611 : :
612 : : /*
613 : : * Timer logic:
614 : : * 1) We refresh the timer only when we open a block.
615 : : * By doing this we don't waste cycles refreshing the timer
616 : : * on packet-by-packet basis.
617 : : *
618 : : * With a 1MB block-size, on a 1Gbps line, it will take
619 : : * i) ~8 ms to fill a block + ii) memcpy etc.
620 : : * In this cut we are not accounting for the memcpy time.
621 : : *
622 : : * So, if the user sets the 'tmo' to 10ms then the timer
623 : : * will never fire while the block is still getting filled
624 : : * (which is what we want). However, the user could choose
625 : : * to close a block early and that's fine.
626 : : *
627 : : * But when the timer does fire, we check whether or not to refresh it.
628 : : * Since the tmo granularity is in msecs, it is not too expensive
629 : : * to refresh the timer, lets say every '8' msecs.
630 : : * Either the user can set the 'tmo' or we can derive it based on
631 : : * a) line-speed and b) block-size.
632 : : * prb_calc_retire_blk_tmo() calculates the tmo.
633 : : *
634 : : */
635 : 0 : static void prb_retire_rx_blk_timer_expired(struct timer_list *t)
636 : : {
637 : : struct packet_sock *po =
638 : 0 : from_timer(po, t, rx_ring.prb_bdqc.retire_blk_timer);
639 : 0 : struct tpacket_kbdq_core *pkc = GET_PBDQC_FROM_RB(&po->rx_ring);
640 : : unsigned int frozen;
641 : : struct tpacket_block_desc *pbd;
642 : :
643 : : spin_lock(&po->sk.sk_receive_queue.lock);
644 : :
645 : : frozen = prb_queue_frozen(pkc);
646 : 0 : pbd = GET_CURR_PBLOCK_DESC_FROM_CORE(pkc);
647 : :
648 : 0 : if (unlikely(pkc->delete_blk_timer))
649 : : goto out;
650 : :
651 : : /* We only need to plug the race when the block is partially filled.
652 : : * tpacket_rcv:
653 : : * lock(); increment BLOCK_NUM_PKTS; unlock()
654 : : * copy_bits() is in progress ...
655 : : * timer fires on other cpu:
656 : : * we can't retire the current block because copy_bits
657 : : * is in progress.
658 : : *
659 : : */
660 : 0 : if (BLOCK_NUM_PKTS(pbd)) {
661 : 0 : while (atomic_read(&pkc->blk_fill_in_prog)) {
662 : : /* Waiting for skb_copy_bits to finish... */
663 : 0 : cpu_relax();
664 : : }
665 : : }
666 : :
667 : 0 : if (pkc->last_kactive_blk_num == pkc->kactive_blk_num) {
668 : 0 : if (!frozen) {
669 : 0 : if (!BLOCK_NUM_PKTS(pbd)) {
670 : : /* An empty block. Just refresh the timer. */
671 : : goto refresh_timer;
672 : : }
673 : 0 : prb_retire_current_block(pkc, po, TP_STATUS_BLK_TMO);
674 : 0 : if (!prb_dispatch_next_block(pkc, po))
675 : : goto refresh_timer;
676 : : else
677 : : goto out;
678 : : } else {
679 : : /* Case 1. Queue was frozen because user-space was
680 : : * lagging behind.
681 : : */
682 : 0 : if (prb_curr_blk_in_use(pbd)) {
683 : : /*
684 : : * Ok, user-space is still behind.
685 : : * So just refresh the timer.
686 : : */
687 : : goto refresh_timer;
688 : : } else {
689 : : /* Case 2. queue was frozen,user-space caught up,
690 : : * now the link went idle && the timer fired.
691 : : * We don't have a block to close.So we open this
692 : : * block and restart the timer.
693 : : * opening a block thaws the queue,restarts timer
694 : : * Thawing/timer-refresh is a side effect.
695 : : */
696 : 0 : prb_open_block(pkc, pbd);
697 : 0 : goto out;
698 : : }
699 : : }
700 : : }
701 : :
702 : : refresh_timer:
703 : : _prb_refresh_rx_retire_blk_timer(pkc);
704 : :
705 : : out:
706 : : spin_unlock(&po->sk.sk_receive_queue.lock);
707 : 0 : }
708 : :
709 : 0 : static void prb_flush_block(struct tpacket_kbdq_core *pkc1,
710 : : struct tpacket_block_desc *pbd1, __u32 status)
711 : : {
712 : : /* Flush everything minus the block header */
713 : :
714 : : #if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE == 1
715 : : u8 *start, *end;
716 : :
717 : : start = (u8 *)pbd1;
718 : :
719 : : /* Skip the block header(we know header WILL fit in 4K) */
720 : 0 : start += PAGE_SIZE;
721 : :
722 : 0 : end = (u8 *)PAGE_ALIGN((unsigned long)pkc1->pkblk_end);
723 : 0 : for (; start < end; start += PAGE_SIZE)
724 : 0 : flush_dcache_page(pgv_to_page(start));
725 : :
726 : 0 : smp_wmb();
727 : : #endif
728 : :
729 : : /* Now update the block status. */
730 : :
731 : 0 : BLOCK_STATUS(pbd1) = status;
732 : :
733 : : /* Flush the block header */
734 : :
735 : : #if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE == 1
736 : : start = (u8 *)pbd1;
737 : 0 : flush_dcache_page(pgv_to_page(start));
738 : :
739 : 0 : smp_wmb();
740 : : #endif
741 : 0 : }
742 : :
743 : : /*
744 : : * Side effect:
745 : : *
746 : : * 1) flush the block
747 : : * 2) Increment active_blk_num
748 : : *
749 : : * Note:We DONT refresh the timer on purpose.
750 : : * Because almost always the next block will be opened.
751 : : */
752 : 0 : static void prb_close_block(struct tpacket_kbdq_core *pkc1,
753 : : struct tpacket_block_desc *pbd1,
754 : : struct packet_sock *po, unsigned int stat)
755 : : {
756 : 0 : __u32 status = TP_STATUS_USER | stat;
757 : :
758 : : struct tpacket3_hdr *last_pkt;
759 : : struct tpacket_hdr_v1 *h1 = &pbd1->hdr.bh1;
760 : 0 : struct sock *sk = &po->sk;
761 : :
762 : 0 : if (atomic_read(&po->tp_drops))
763 : 0 : status |= TP_STATUS_LOSING;
764 : :
765 : 0 : last_pkt = (struct tpacket3_hdr *)pkc1->prev;
766 : 0 : last_pkt->tp_next_offset = 0;
767 : :
768 : : /* Get the ts of the last pkt */
769 : 0 : if (BLOCK_NUM_PKTS(pbd1)) {
770 : 0 : h1->ts_last_pkt.ts_sec = last_pkt->tp_sec;
771 : 0 : h1->ts_last_pkt.ts_nsec = last_pkt->tp_nsec;
772 : : } else {
773 : : /* Ok, we tmo'd - so get the current time.
774 : : *
775 : : * It shouldn't really happen as we don't close empty
776 : : * blocks. See prb_retire_rx_blk_timer_expired().
777 : : */
778 : : struct timespec ts;
779 : : getnstimeofday(&ts);
780 : 0 : h1->ts_last_pkt.ts_sec = ts.tv_sec;
781 : 0 : h1->ts_last_pkt.ts_nsec = ts.tv_nsec;
782 : : }
783 : :
784 : 0 : smp_wmb();
785 : :
786 : : /* Flush the block */
787 : 0 : prb_flush_block(pkc1, pbd1, status);
788 : :
789 : 0 : sk->sk_data_ready(sk);
790 : :
791 : 0 : pkc1->kactive_blk_num = GET_NEXT_PRB_BLK_NUM(pkc1);
792 : 0 : }
793 : :
794 : : static void prb_thaw_queue(struct tpacket_kbdq_core *pkc)
795 : : {
796 : 0 : pkc->reset_pending_on_curr_blk = 0;
797 : : }
798 : :
799 : : /*
800 : : * Side effect of opening a block:
801 : : *
802 : : * 1) prb_queue is thawed.
803 : : * 2) retire_blk_timer is refreshed.
804 : : *
805 : : */
806 : 0 : static void prb_open_block(struct tpacket_kbdq_core *pkc1,
807 : : struct tpacket_block_desc *pbd1)
808 : : {
809 : : struct timespec ts;
810 : : struct tpacket_hdr_v1 *h1 = &pbd1->hdr.bh1;
811 : :
812 : 0 : smp_rmb();
813 : :
814 : : /* We could have just memset this but we will lose the
815 : : * flexibility of making the priv area sticky
816 : : */
817 : :
818 : 0 : BLOCK_SNUM(pbd1) = pkc1->knxt_seq_num++;
819 : 0 : BLOCK_NUM_PKTS(pbd1) = 0;
820 : 0 : BLOCK_LEN(pbd1) = BLK_PLUS_PRIV(pkc1->blk_sizeof_priv);
821 : :
822 : : getnstimeofday(&ts);
823 : :
824 : 0 : h1->ts_first_pkt.ts_sec = ts.tv_sec;
825 : 0 : h1->ts_first_pkt.ts_nsec = ts.tv_nsec;
826 : :
827 : 0 : pkc1->pkblk_start = (char *)pbd1;
828 : 0 : pkc1->nxt_offset = pkc1->pkblk_start + BLK_PLUS_PRIV(pkc1->blk_sizeof_priv);
829 : :
830 : 0 : BLOCK_O2FP(pbd1) = (__u32)BLK_PLUS_PRIV(pkc1->blk_sizeof_priv);
831 : 0 : BLOCK_O2PRIV(pbd1) = BLK_HDR_LEN;
832 : :
833 : 0 : pbd1->version = pkc1->version;
834 : 0 : pkc1->prev = pkc1->nxt_offset;
835 : 0 : pkc1->pkblk_end = pkc1->pkblk_start + pkc1->kblk_size;
836 : :
837 : : prb_thaw_queue(pkc1);
838 : : _prb_refresh_rx_retire_blk_timer(pkc1);
839 : :
840 : 0 : smp_wmb();
841 : 0 : }
842 : :
843 : : /*
844 : : * Queue freeze logic:
845 : : * 1) Assume tp_block_nr = 8 blocks.
846 : : * 2) At time 't0', user opens Rx ring.
847 : : * 3) Some time past 't0', kernel starts filling blocks starting from 0 .. 7
848 : : * 4) user-space is either sleeping or processing block '0'.
849 : : * 5) tpacket_rcv is currently filling block '7', since there is no space left,
850 : : * it will close block-7,loop around and try to fill block '0'.
851 : : * call-flow:
852 : : * __packet_lookup_frame_in_block
853 : : * prb_retire_current_block()
854 : : * prb_dispatch_next_block()
855 : : * |->(BLOCK_STATUS == USER) evaluates to true
856 : : * 5.1) Since block-0 is currently in-use, we just freeze the queue.
857 : : * 6) Now there are two cases:
858 : : * 6.1) Link goes idle right after the queue is frozen.
859 : : * But remember, the last open_block() refreshed the timer.
860 : : * When this timer expires,it will refresh itself so that we can
861 : : * re-open block-0 in near future.
862 : : * 6.2) Link is busy and keeps on receiving packets. This is a simple
863 : : * case and __packet_lookup_frame_in_block will check if block-0
864 : : * is free and can now be re-used.
865 : : */
866 : : static void prb_freeze_queue(struct tpacket_kbdq_core *pkc,
867 : : struct packet_sock *po)
868 : : {
869 : 0 : pkc->reset_pending_on_curr_blk = 1;
870 : 0 : po->stats.stats3.tp_freeze_q_cnt++;
871 : : }
872 : :
873 : : #define TOTAL_PKT_LEN_INCL_ALIGN(length) (ALIGN((length), V3_ALIGNMENT))
874 : :
875 : : /*
876 : : * If the next block is free then we will dispatch it
877 : : * and return a good offset.
878 : : * Else, we will freeze the queue.
879 : : * So, caller must check the return value.
880 : : */
881 : 0 : static void *prb_dispatch_next_block(struct tpacket_kbdq_core *pkc,
882 : : struct packet_sock *po)
883 : : {
884 : : struct tpacket_block_desc *pbd;
885 : :
886 : 0 : smp_rmb();
887 : :
888 : : /* 1. Get current block num */
889 : 0 : pbd = GET_CURR_PBLOCK_DESC_FROM_CORE(pkc);
890 : :
891 : : /* 2. If this block is currently in_use then freeze the queue */
892 : 0 : if (TP_STATUS_USER & BLOCK_STATUS(pbd)) {
893 : : prb_freeze_queue(pkc, po);
894 : 0 : return NULL;
895 : : }
896 : :
897 : : /*
898 : : * 3.
899 : : * open this block and return the offset where the first packet
900 : : * needs to get stored.
901 : : */
902 : 0 : prb_open_block(pkc, pbd);
903 : 0 : return (void *)pkc->nxt_offset;
904 : : }
905 : :
906 : 0 : static void prb_retire_current_block(struct tpacket_kbdq_core *pkc,
907 : : struct packet_sock *po, unsigned int status)
908 : : {
909 : 0 : struct tpacket_block_desc *pbd = GET_CURR_PBLOCK_DESC_FROM_CORE(pkc);
910 : :
911 : : /* retire/close the current block */
912 : 0 : if (likely(TP_STATUS_KERNEL == BLOCK_STATUS(pbd))) {
913 : : /*
914 : : * Plug the case where copy_bits() is in progress on
915 : : * cpu-0 and tpacket_rcv() got invoked on cpu-1, didn't
916 : : * have space to copy the pkt in the current block and
917 : : * called prb_retire_current_block()
918 : : *
919 : : * We don't need to worry about the TMO case because
920 : : * the timer-handler already handled this case.
921 : : */
922 : 0 : if (!(status & TP_STATUS_BLK_TMO)) {
923 : 0 : while (atomic_read(&pkc->blk_fill_in_prog)) {
924 : : /* Waiting for skb_copy_bits to finish... */
925 : 0 : cpu_relax();
926 : : }
927 : : }
928 : 0 : prb_close_block(pkc, pbd, po, status);
929 : 0 : return;
930 : : }
931 : : }
932 : :
933 : : static int prb_curr_blk_in_use(struct tpacket_block_desc *pbd)
934 : : {
935 : 0 : return TP_STATUS_USER & BLOCK_STATUS(pbd);
936 : : }
937 : :
938 : : static int prb_queue_frozen(struct tpacket_kbdq_core *pkc)
939 : : {
940 : 0 : return pkc->reset_pending_on_curr_blk;
941 : : }
942 : :
943 : : static void prb_clear_blk_fill_status(struct packet_ring_buffer *rb)
944 : : __releases(&pkc->blk_fill_in_prog_lock)
945 : : {
946 : : struct tpacket_kbdq_core *pkc = GET_PBDQC_FROM_RB(rb);
947 : 0 : atomic_dec(&pkc->blk_fill_in_prog);
948 : : }
949 : :
950 : : static void prb_fill_rxhash(struct tpacket_kbdq_core *pkc,
951 : : struct tpacket3_hdr *ppd)
952 : : {
953 : 0 : ppd->hv1.tp_rxhash = skb_get_hash(pkc->skb);
954 : : }
955 : :
956 : : static void prb_clear_rxhash(struct tpacket_kbdq_core *pkc,
957 : : struct tpacket3_hdr *ppd)
958 : : {
959 : 0 : ppd->hv1.tp_rxhash = 0;
960 : : }
961 : :
962 : : static void prb_fill_vlan_info(struct tpacket_kbdq_core *pkc,
963 : : struct tpacket3_hdr *ppd)
964 : : {
965 : 0 : if (skb_vlan_tag_present(pkc->skb)) {
966 : 0 : ppd->hv1.tp_vlan_tci = skb_vlan_tag_get(pkc->skb);
967 : 0 : ppd->hv1.tp_vlan_tpid = ntohs(pkc->skb->vlan_proto);
968 : 0 : ppd->tp_status = TP_STATUS_VLAN_VALID | TP_STATUS_VLAN_TPID_VALID;
969 : : } else {
970 : 0 : ppd->hv1.tp_vlan_tci = 0;
971 : 0 : ppd->hv1.tp_vlan_tpid = 0;
972 : 0 : ppd->tp_status = TP_STATUS_AVAILABLE;
973 : : }
974 : : }
975 : :
976 : 0 : static void prb_run_all_ft_ops(struct tpacket_kbdq_core *pkc,
977 : : struct tpacket3_hdr *ppd)
978 : : {
979 : 0 : ppd->hv1.tp_padding = 0;
980 : : prb_fill_vlan_info(pkc, ppd);
981 : :
982 : 0 : if (pkc->feature_req_word & TP_FT_REQ_FILL_RXHASH)
983 : : prb_fill_rxhash(pkc, ppd);
984 : : else
985 : : prb_clear_rxhash(pkc, ppd);
986 : 0 : }
987 : :
988 : 0 : static void prb_fill_curr_block(char *curr,
989 : : struct tpacket_kbdq_core *pkc,
990 : : struct tpacket_block_desc *pbd,
991 : : unsigned int len)
992 : : __acquires(&pkc->blk_fill_in_prog_lock)
993 : : {
994 : : struct tpacket3_hdr *ppd;
995 : :
996 : : ppd = (struct tpacket3_hdr *)curr;
997 : 0 : ppd->tp_next_offset = TOTAL_PKT_LEN_INCL_ALIGN(len);
998 : 0 : pkc->prev = curr;
999 : 0 : pkc->nxt_offset += TOTAL_PKT_LEN_INCL_ALIGN(len);
1000 : 0 : BLOCK_LEN(pbd) += TOTAL_PKT_LEN_INCL_ALIGN(len);
1001 : 0 : BLOCK_NUM_PKTS(pbd) += 1;
1002 : 0 : atomic_inc(&pkc->blk_fill_in_prog);
1003 : 0 : prb_run_all_ft_ops(pkc, ppd);
1004 : 0 : }
1005 : :
1006 : : /* Assumes caller has the sk->rx_queue.lock */
1007 : 0 : static void *__packet_lookup_frame_in_block(struct packet_sock *po,
1008 : : struct sk_buff *skb,
1009 : : unsigned int len
1010 : : )
1011 : : {
1012 : : struct tpacket_kbdq_core *pkc;
1013 : : struct tpacket_block_desc *pbd;
1014 : : char *curr, *end;
1015 : :
1016 : 0 : pkc = GET_PBDQC_FROM_RB(&po->rx_ring);
1017 : 0 : pbd = GET_CURR_PBLOCK_DESC_FROM_CORE(pkc);
1018 : :
1019 : : /* Queue is frozen when user space is lagging behind */
1020 : 0 : if (prb_queue_frozen(pkc)) {
1021 : : /*
1022 : : * Check if that last block which caused the queue to freeze,
1023 : : * is still in_use by user-space.
1024 : : */
1025 : 0 : if (prb_curr_blk_in_use(pbd)) {
1026 : : /* Can't record this packet */
1027 : : return NULL;
1028 : : } else {
1029 : : /*
1030 : : * Ok, the block was released by user-space.
1031 : : * Now let's open that block.
1032 : : * opening a block also thaws the queue.
1033 : : * Thawing is a side effect.
1034 : : */
1035 : 0 : prb_open_block(pkc, pbd);
1036 : : }
1037 : : }
1038 : :
1039 : 0 : smp_mb();
1040 : 0 : curr = pkc->nxt_offset;
1041 : 0 : pkc->skb = skb;
1042 : 0 : end = (char *)pbd + pkc->kblk_size;
1043 : :
1044 : : /* first try the current block */
1045 : 0 : if (curr+TOTAL_PKT_LEN_INCL_ALIGN(len) < end) {
1046 : 0 : prb_fill_curr_block(curr, pkc, pbd, len);
1047 : 0 : return (void *)curr;
1048 : : }
1049 : :
1050 : : /* Ok, close the current block */
1051 : 0 : prb_retire_current_block(pkc, po, 0);
1052 : :
1053 : : /* Now, try to dispatch the next block */
1054 : 0 : curr = (char *)prb_dispatch_next_block(pkc, po);
1055 : 0 : if (curr) {
1056 : 0 : pbd = GET_CURR_PBLOCK_DESC_FROM_CORE(pkc);
1057 : 0 : prb_fill_curr_block(curr, pkc, pbd, len);
1058 : 0 : return (void *)curr;
1059 : : }
1060 : :
1061 : : /*
1062 : : * No free blocks are available.user_space hasn't caught up yet.
1063 : : * Queue was just frozen and now this packet will get dropped.
1064 : : */
1065 : : return NULL;
1066 : : }
1067 : :
1068 : 0 : static void *packet_current_rx_frame(struct packet_sock *po,
1069 : : struct sk_buff *skb,
1070 : : int status, unsigned int len)
1071 : : {
1072 : : char *curr = NULL;
1073 : 0 : switch (po->tp_version) {
1074 : : case TPACKET_V1:
1075 : : case TPACKET_V2:
1076 : 0 : curr = packet_lookup_frame(po, &po->rx_ring,
1077 : : po->rx_ring.head, status);
1078 : 0 : return curr;
1079 : : case TPACKET_V3:
1080 : 0 : return __packet_lookup_frame_in_block(po, skb, len);
1081 : : default:
1082 : 0 : WARN(1, "TPACKET version not supported\n");
1083 : 0 : BUG();
1084 : : return NULL;
1085 : : }
1086 : : }
1087 : :
1088 : : static void *prb_lookup_block(const struct packet_sock *po,
1089 : : const struct packet_ring_buffer *rb,
1090 : : unsigned int idx,
1091 : : int status)
1092 : : {
1093 : : struct tpacket_kbdq_core *pkc = GET_PBDQC_FROM_RB(rb);
1094 : 0 : struct tpacket_block_desc *pbd = GET_PBLOCK_DESC(pkc, idx);
1095 : :
1096 : 0 : if (status != BLOCK_STATUS(pbd))
1097 : : return NULL;
1098 : : return pbd;
1099 : : }
1100 : :
1101 : : static int prb_previous_blk_num(struct packet_ring_buffer *rb)
1102 : : {
1103 : : unsigned int prev;
1104 : 0 : if (rb->prb_bdqc.kactive_blk_num)
1105 : 0 : prev = rb->prb_bdqc.kactive_blk_num-1;
1106 : : else
1107 : 0 : prev = rb->prb_bdqc.knum_blocks-1;
1108 : : return prev;
1109 : : }
1110 : :
1111 : : /* Assumes caller has held the rx_queue.lock */
1112 : : static void *__prb_previous_block(struct packet_sock *po,
1113 : : struct packet_ring_buffer *rb,
1114 : : int status)
1115 : : {
1116 : : unsigned int previous = prb_previous_blk_num(rb);
1117 : : return prb_lookup_block(po, rb, previous, status);
1118 : : }
1119 : :
1120 : 0 : static void *packet_previous_rx_frame(struct packet_sock *po,
1121 : : struct packet_ring_buffer *rb,
1122 : : int status)
1123 : : {
1124 : 0 : if (po->tp_version <= TPACKET_V2)
1125 : 0 : return packet_previous_frame(po, rb, status);
1126 : :
1127 : 0 : return __prb_previous_block(po, rb, status);
1128 : : }
1129 : :
1130 : 0 : static void packet_increment_rx_head(struct packet_sock *po,
1131 : : struct packet_ring_buffer *rb)
1132 : : {
1133 : 0 : switch (po->tp_version) {
1134 : : case TPACKET_V1:
1135 : : case TPACKET_V2:
1136 : 0 : return packet_increment_head(rb);
1137 : : case TPACKET_V3:
1138 : : default:
1139 : 0 : WARN(1, "TPACKET version not supported.\n");
1140 : 0 : BUG();
1141 : : return;
1142 : : }
1143 : : }
1144 : :
1145 : : static void *packet_previous_frame(struct packet_sock *po,
1146 : : struct packet_ring_buffer *rb,
1147 : : int status)
1148 : : {
1149 : 0 : unsigned int previous = rb->head ? rb->head - 1 : rb->frame_max;
1150 : 0 : return packet_lookup_frame(po, rb, previous, status);
1151 : : }
1152 : :
1153 : : static void packet_increment_head(struct packet_ring_buffer *buff)
1154 : : {
1155 : 0 : buff->head = buff->head != buff->frame_max ? buff->head+1 : 0;
1156 : : }
1157 : :
1158 : 0 : static void packet_inc_pending(struct packet_ring_buffer *rb)
1159 : : {
1160 : 0 : this_cpu_inc(*rb->pending_refcnt);
1161 : 0 : }
1162 : :
1163 : 0 : static void packet_dec_pending(struct packet_ring_buffer *rb)
1164 : : {
1165 : 0 : this_cpu_dec(*rb->pending_refcnt);
1166 : 0 : }
1167 : :
1168 : 0 : static unsigned int packet_read_pending(const struct packet_ring_buffer *rb)
1169 : : {
1170 : : unsigned int refcnt = 0;
1171 : : int cpu;
1172 : :
1173 : : /* We don't use pending refcount in rx_ring. */
1174 : 0 : if (rb->pending_refcnt == NULL)
1175 : : return 0;
1176 : :
1177 : 0 : for_each_possible_cpu(cpu)
1178 : 0 : refcnt += *per_cpu_ptr(rb->pending_refcnt, cpu);
1179 : :
1180 : 0 : return refcnt;
1181 : : }
1182 : :
1183 : : static int packet_alloc_pending(struct packet_sock *po)
1184 : : {
1185 : 3 : po->rx_ring.pending_refcnt = NULL;
1186 : :
1187 : 3 : po->tx_ring.pending_refcnt = alloc_percpu(unsigned int);
1188 : 3 : if (unlikely(po->tx_ring.pending_refcnt == NULL))
1189 : : return -ENOBUFS;
1190 : :
1191 : : return 0;
1192 : : }
1193 : :
1194 : : static void packet_free_pending(struct packet_sock *po)
1195 : : {
1196 : 3 : free_percpu(po->tx_ring.pending_refcnt);
1197 : : }
1198 : :
1199 : : #define ROOM_POW_OFF 2
1200 : : #define ROOM_NONE 0x0
1201 : : #define ROOM_LOW 0x1
1202 : : #define ROOM_NORMAL 0x2
1203 : :
1204 : 0 : static bool __tpacket_has_room(const struct packet_sock *po, int pow_off)
1205 : : {
1206 : : int idx, len;
1207 : :
1208 : 0 : len = READ_ONCE(po->rx_ring.frame_max) + 1;
1209 : 0 : idx = READ_ONCE(po->rx_ring.head);
1210 : 0 : if (pow_off)
1211 : 0 : idx += len >> pow_off;
1212 : 0 : if (idx >= len)
1213 : 0 : idx -= len;
1214 : 0 : return packet_lookup_frame(po, &po->rx_ring, idx, TP_STATUS_KERNEL);
1215 : : }
1216 : :
1217 : 0 : static bool __tpacket_v3_has_room(const struct packet_sock *po, int pow_off)
1218 : : {
1219 : : int idx, len;
1220 : :
1221 : 0 : len = READ_ONCE(po->rx_ring.prb_bdqc.knum_blocks);
1222 : 0 : idx = READ_ONCE(po->rx_ring.prb_bdqc.kactive_blk_num);
1223 : 0 : if (pow_off)
1224 : 0 : idx += len >> pow_off;
1225 : 0 : if (idx >= len)
1226 : 0 : idx -= len;
1227 : 0 : return prb_lookup_block(po, &po->rx_ring, idx, TP_STATUS_KERNEL);
1228 : : }
1229 : :
1230 : 0 : static int __packet_rcv_has_room(const struct packet_sock *po,
1231 : : const struct sk_buff *skb)
1232 : : {
1233 : : const struct sock *sk = &po->sk;
1234 : : int ret = ROOM_NONE;
1235 : :
1236 : 0 : if (po->prot_hook.func != tpacket_rcv) {
1237 : 0 : int rcvbuf = READ_ONCE(sk->sk_rcvbuf);
1238 : 0 : int avail = rcvbuf - atomic_read(&sk->sk_rmem_alloc)
1239 : 0 : - (skb ? skb->truesize : 0);
1240 : :
1241 : 0 : if (avail > (rcvbuf >> ROOM_POW_OFF))
1242 : : return ROOM_NORMAL;
1243 : 0 : else if (avail > 0)
1244 : : return ROOM_LOW;
1245 : : else
1246 : 0 : return ROOM_NONE;
1247 : : }
1248 : :
1249 : 0 : if (po->tp_version == TPACKET_V3) {
1250 : 0 : if (__tpacket_v3_has_room(po, ROOM_POW_OFF))
1251 : : ret = ROOM_NORMAL;
1252 : 0 : else if (__tpacket_v3_has_room(po, 0))
1253 : : ret = ROOM_LOW;
1254 : : } else {
1255 : 0 : if (__tpacket_has_room(po, ROOM_POW_OFF))
1256 : : ret = ROOM_NORMAL;
1257 : 0 : else if (__tpacket_has_room(po, 0))
1258 : : ret = ROOM_LOW;
1259 : : }
1260 : :
1261 : 0 : return ret;
1262 : : }
1263 : :
1264 : : static int packet_rcv_has_room(struct packet_sock *po, struct sk_buff *skb)
1265 : : {
1266 : : int pressure, ret;
1267 : :
1268 : 0 : ret = __packet_rcv_has_room(po, skb);
1269 : 0 : pressure = ret != ROOM_NORMAL;
1270 : :
1271 : 0 : if (READ_ONCE(po->pressure) != pressure)
1272 : : WRITE_ONCE(po->pressure, pressure);
1273 : :
1274 : : return ret;
1275 : : }
1276 : :
1277 : 3 : static void packet_rcv_try_clear_pressure(struct packet_sock *po)
1278 : : {
1279 : 3 : if (READ_ONCE(po->pressure) &&
1280 : 0 : __packet_rcv_has_room(po, NULL) == ROOM_NORMAL)
1281 : : WRITE_ONCE(po->pressure, 0);
1282 : 3 : }
1283 : :
1284 : 3 : static void packet_sock_destruct(struct sock *sk)
1285 : : {
1286 : 3 : skb_queue_purge(&sk->sk_error_queue);
1287 : :
1288 : 3 : WARN_ON(atomic_read(&sk->sk_rmem_alloc));
1289 : 3 : WARN_ON(refcount_read(&sk->sk_wmem_alloc));
1290 : :
1291 : 3 : if (!sock_flag(sk, SOCK_DEAD)) {
1292 : 0 : pr_err("Attempt to release alive packet socket: %p\n", sk);
1293 : 0 : return;
1294 : : }
1295 : :
1296 : : sk_refcnt_debug_dec(sk);
1297 : : }
1298 : :
1299 : 0 : static bool fanout_flow_is_huge(struct packet_sock *po, struct sk_buff *skb)
1300 : : {
1301 : 0 : u32 *history = po->rollover->history;
1302 : : u32 victim, rxhash;
1303 : : int i, count = 0;
1304 : :
1305 : : rxhash = skb_get_hash(skb);
1306 : 0 : for (i = 0; i < ROLLOVER_HLEN; i++)
1307 : 0 : if (READ_ONCE(history[i]) == rxhash)
1308 : 0 : count++;
1309 : :
1310 : 0 : victim = prandom_u32() % ROLLOVER_HLEN;
1311 : :
1312 : : /* Avoid dirtying the cache line if possible */
1313 : 0 : if (READ_ONCE(history[victim]) != rxhash)
1314 : : WRITE_ONCE(history[victim], rxhash);
1315 : :
1316 : 0 : return count > (ROLLOVER_HLEN >> 1);
1317 : : }
1318 : :
1319 : : static unsigned int fanout_demux_hash(struct packet_fanout *f,
1320 : : struct sk_buff *skb,
1321 : : unsigned int num)
1322 : : {
1323 : 0 : return reciprocal_scale(__skb_get_hash_symmetric(skb), num);
1324 : : }
1325 : :
1326 : : static unsigned int fanout_demux_lb(struct packet_fanout *f,
1327 : : struct sk_buff *skb,
1328 : : unsigned int num)
1329 : : {
1330 : 0 : unsigned int val = atomic_inc_return(&f->rr_cur);
1331 : :
1332 : 0 : return val % num;
1333 : : }
1334 : :
1335 : : static unsigned int fanout_demux_cpu(struct packet_fanout *f,
1336 : : struct sk_buff *skb,
1337 : : unsigned int num)
1338 : : {
1339 : 0 : return smp_processor_id() % num;
1340 : : }
1341 : :
1342 : : static unsigned int fanout_demux_rnd(struct packet_fanout *f,
1343 : : struct sk_buff *skb,
1344 : : unsigned int num)
1345 : : {
1346 : : return prandom_u32_max(num);
1347 : : }
1348 : :
1349 : 0 : static unsigned int fanout_demux_rollover(struct packet_fanout *f,
1350 : : struct sk_buff *skb,
1351 : : unsigned int idx, bool try_self,
1352 : : unsigned int num)
1353 : : {
1354 : : struct packet_sock *po, *po_next, *po_skip = NULL;
1355 : : unsigned int i, j, room = ROOM_NONE;
1356 : :
1357 : 0 : po = pkt_sk(f->arr[idx]);
1358 : :
1359 : 0 : if (try_self) {
1360 : 0 : room = packet_rcv_has_room(po, skb);
1361 : 0 : if (room == ROOM_NORMAL ||
1362 : 0 : (room == ROOM_LOW && !fanout_flow_is_huge(po, skb)))
1363 : 0 : return idx;
1364 : : po_skip = po;
1365 : : }
1366 : :
1367 : 0 : i = j = min_t(int, po->rollover->sock, num - 1);
1368 : : do {
1369 : 0 : po_next = pkt_sk(f->arr[i]);
1370 : 0 : if (po_next != po_skip && !READ_ONCE(po_next->pressure) &&
1371 : : packet_rcv_has_room(po_next, skb) == ROOM_NORMAL) {
1372 : 0 : if (i != j)
1373 : 0 : po->rollover->sock = i;
1374 : 0 : atomic_long_inc(&po->rollover->num);
1375 : 0 : if (room == ROOM_LOW)
1376 : 0 : atomic_long_inc(&po->rollover->num_huge);
1377 : 0 : return i;
1378 : : }
1379 : :
1380 : 0 : if (++i == num)
1381 : : i = 0;
1382 : 0 : } while (i != j);
1383 : :
1384 : 0 : atomic_long_inc(&po->rollover->num_failed);
1385 : 0 : return idx;
1386 : : }
1387 : :
1388 : : static unsigned int fanout_demux_qm(struct packet_fanout *f,
1389 : : struct sk_buff *skb,
1390 : : unsigned int num)
1391 : : {
1392 : 0 : return skb_get_queue_mapping(skb) % num;
1393 : : }
1394 : :
1395 : 0 : static unsigned int fanout_demux_bpf(struct packet_fanout *f,
1396 : : struct sk_buff *skb,
1397 : : unsigned int num)
1398 : : {
1399 : : struct bpf_prog *prog;
1400 : : unsigned int ret = 0;
1401 : :
1402 : : rcu_read_lock();
1403 : 0 : prog = rcu_dereference(f->bpf_prog);
1404 : 0 : if (prog)
1405 : 0 : ret = bpf_prog_run_clear_cb(prog, skb) % num;
1406 : : rcu_read_unlock();
1407 : :
1408 : 0 : return ret;
1409 : : }
1410 : :
1411 : : static bool fanout_has_flag(struct packet_fanout *f, u16 flag)
1412 : : {
1413 : 0 : return f->flags & (flag >> 8);
1414 : : }
1415 : :
1416 : 0 : static int packet_rcv_fanout(struct sk_buff *skb, struct net_device *dev,
1417 : : struct packet_type *pt, struct net_device *orig_dev)
1418 : : {
1419 : 0 : struct packet_fanout *f = pt->af_packet_priv;
1420 : : unsigned int num = READ_ONCE(f->num_members);
1421 : : struct net *net = read_pnet(&f->net);
1422 : : struct packet_sock *po;
1423 : : unsigned int idx;
1424 : :
1425 : 0 : if (!net_eq(dev_net(dev), net) || !num) {
1426 : 0 : kfree_skb(skb);
1427 : 0 : return 0;
1428 : : }
1429 : :
1430 : 0 : if (fanout_has_flag(f, PACKET_FANOUT_FLAG_DEFRAG)) {
1431 : 0 : skb = ip_check_defrag(net, skb, IP_DEFRAG_AF_PACKET);
1432 : 0 : if (!skb)
1433 : : return 0;
1434 : : }
1435 : 0 : switch (f->type) {
1436 : : case PACKET_FANOUT_HASH:
1437 : : default:
1438 : : idx = fanout_demux_hash(f, skb, num);
1439 : 0 : break;
1440 : : case PACKET_FANOUT_LB:
1441 : : idx = fanout_demux_lb(f, skb, num);
1442 : 0 : break;
1443 : : case PACKET_FANOUT_CPU:
1444 : : idx = fanout_demux_cpu(f, skb, num);
1445 : 0 : break;
1446 : : case PACKET_FANOUT_RND:
1447 : : idx = fanout_demux_rnd(f, skb, num);
1448 : 0 : break;
1449 : : case PACKET_FANOUT_QM:
1450 : : idx = fanout_demux_qm(f, skb, num);
1451 : 0 : break;
1452 : : case PACKET_FANOUT_ROLLOVER:
1453 : 0 : idx = fanout_demux_rollover(f, skb, 0, false, num);
1454 : 0 : break;
1455 : : case PACKET_FANOUT_CBPF:
1456 : : case PACKET_FANOUT_EBPF:
1457 : 0 : idx = fanout_demux_bpf(f, skb, num);
1458 : 0 : break;
1459 : : }
1460 : :
1461 : 0 : if (fanout_has_flag(f, PACKET_FANOUT_FLAG_ROLLOVER))
1462 : 0 : idx = fanout_demux_rollover(f, skb, idx, true, num);
1463 : :
1464 : 0 : po = pkt_sk(f->arr[idx]);
1465 : 0 : return po->prot_hook.func(skb, dev, &po->prot_hook, orig_dev);
1466 : : }
1467 : :
1468 : : DEFINE_MUTEX(fanout_mutex);
1469 : : EXPORT_SYMBOL_GPL(fanout_mutex);
1470 : : static LIST_HEAD(fanout_list);
1471 : : static u16 fanout_next_id;
1472 : :
1473 : 0 : static void __fanout_link(struct sock *sk, struct packet_sock *po)
1474 : : {
1475 : 0 : struct packet_fanout *f = po->fanout;
1476 : :
1477 : : spin_lock(&f->lock);
1478 : 0 : f->arr[f->num_members] = sk;
1479 : 0 : smp_wmb();
1480 : 0 : f->num_members++;
1481 : 0 : if (f->num_members == 1)
1482 : 0 : dev_add_pack(&f->prot_hook);
1483 : : spin_unlock(&f->lock);
1484 : 0 : }
1485 : :
1486 : 0 : static void __fanout_unlink(struct sock *sk, struct packet_sock *po)
1487 : : {
1488 : 0 : struct packet_fanout *f = po->fanout;
1489 : : int i;
1490 : :
1491 : : spin_lock(&f->lock);
1492 : 0 : for (i = 0; i < f->num_members; i++) {
1493 : 0 : if (f->arr[i] == sk)
1494 : : break;
1495 : : }
1496 : 0 : BUG_ON(i >= f->num_members);
1497 : 0 : f->arr[i] = f->arr[f->num_members - 1];
1498 : 0 : f->num_members--;
1499 : 0 : if (f->num_members == 0)
1500 : 0 : __dev_remove_pack(&f->prot_hook);
1501 : : spin_unlock(&f->lock);
1502 : 0 : }
1503 : :
1504 : 0 : static bool match_fanout_group(struct packet_type *ptype, struct sock *sk)
1505 : : {
1506 : 0 : if (sk->sk_family != PF_PACKET)
1507 : : return false;
1508 : :
1509 : 0 : return ptype->af_packet_priv == pkt_sk(sk)->fanout;
1510 : : }
1511 : :
1512 : : static void fanout_init_data(struct packet_fanout *f)
1513 : : {
1514 : 0 : switch (f->type) {
1515 : : case PACKET_FANOUT_LB:
1516 : : atomic_set(&f->rr_cur, 0);
1517 : : break;
1518 : : case PACKET_FANOUT_CBPF:
1519 : : case PACKET_FANOUT_EBPF:
1520 : : RCU_INIT_POINTER(f->bpf_prog, NULL);
1521 : : break;
1522 : : }
1523 : : }
1524 : :
1525 : 0 : static void __fanout_set_data_bpf(struct packet_fanout *f, struct bpf_prog *new)
1526 : : {
1527 : : struct bpf_prog *old;
1528 : :
1529 : : spin_lock(&f->lock);
1530 : 0 : old = rcu_dereference_protected(f->bpf_prog, lockdep_is_held(&f->lock));
1531 : 0 : rcu_assign_pointer(f->bpf_prog, new);
1532 : : spin_unlock(&f->lock);
1533 : :
1534 : 0 : if (old) {
1535 : 0 : synchronize_net();
1536 : 0 : bpf_prog_destroy(old);
1537 : : }
1538 : 0 : }
1539 : :
1540 : 0 : static int fanout_set_data_cbpf(struct packet_sock *po, char __user *data,
1541 : : unsigned int len)
1542 : : {
1543 : : struct bpf_prog *new;
1544 : : struct sock_fprog fprog;
1545 : : int ret;
1546 : :
1547 : 0 : if (sock_flag(&po->sk, SOCK_FILTER_LOCKED))
1548 : : return -EPERM;
1549 : 0 : if (len != sizeof(fprog))
1550 : : return -EINVAL;
1551 : 0 : if (copy_from_user(&fprog, data, len))
1552 : : return -EFAULT;
1553 : :
1554 : 0 : ret = bpf_prog_create_from_user(&new, &fprog, NULL, false);
1555 : 0 : if (ret)
1556 : : return ret;
1557 : :
1558 : 0 : __fanout_set_data_bpf(po->fanout, new);
1559 : 0 : return 0;
1560 : : }
1561 : :
1562 : 0 : static int fanout_set_data_ebpf(struct packet_sock *po, char __user *data,
1563 : : unsigned int len)
1564 : : {
1565 : : struct bpf_prog *new;
1566 : : u32 fd;
1567 : :
1568 : 0 : if (sock_flag(&po->sk, SOCK_FILTER_LOCKED))
1569 : : return -EPERM;
1570 : 0 : if (len != sizeof(fd))
1571 : : return -EINVAL;
1572 : 0 : if (copy_from_user(&fd, data, len))
1573 : : return -EFAULT;
1574 : :
1575 : 0 : new = bpf_prog_get_type(fd, BPF_PROG_TYPE_SOCKET_FILTER);
1576 : 0 : if (IS_ERR(new))
1577 : 0 : return PTR_ERR(new);
1578 : :
1579 : 0 : __fanout_set_data_bpf(po->fanout, new);
1580 : 0 : return 0;
1581 : : }
1582 : :
1583 : 0 : static int fanout_set_data(struct packet_sock *po, char __user *data,
1584 : : unsigned int len)
1585 : : {
1586 : 0 : switch (po->fanout->type) {
1587 : : case PACKET_FANOUT_CBPF:
1588 : 0 : return fanout_set_data_cbpf(po, data, len);
1589 : : case PACKET_FANOUT_EBPF:
1590 : 0 : return fanout_set_data_ebpf(po, data, len);
1591 : : default:
1592 : : return -EINVAL;
1593 : : }
1594 : : }
1595 : :
1596 : 0 : static void fanout_release_data(struct packet_fanout *f)
1597 : : {
1598 : 0 : switch (f->type) {
1599 : : case PACKET_FANOUT_CBPF:
1600 : : case PACKET_FANOUT_EBPF:
1601 : 0 : __fanout_set_data_bpf(f, NULL);
1602 : : }
1603 : 0 : }
1604 : :
1605 : : static bool __fanout_id_is_free(struct sock *sk, u16 candidate_id)
1606 : : {
1607 : : struct packet_fanout *f;
1608 : :
1609 : 0 : list_for_each_entry(f, &fanout_list, list) {
1610 : 0 : if (f->id == candidate_id &&
1611 : : read_pnet(&f->net) == sock_net(sk)) {
1612 : : return false;
1613 : : }
1614 : : }
1615 : : return true;
1616 : : }
1617 : :
1618 : 0 : static bool fanout_find_new_id(struct sock *sk, u16 *new_id)
1619 : : {
1620 : 0 : u16 id = fanout_next_id;
1621 : :
1622 : : do {
1623 : 0 : if (__fanout_id_is_free(sk, id)) {
1624 : 0 : *new_id = id;
1625 : 0 : fanout_next_id = id + 1;
1626 : 0 : return true;
1627 : : }
1628 : :
1629 : 0 : id++;
1630 : 0 : } while (id != fanout_next_id);
1631 : :
1632 : : return false;
1633 : : }
1634 : :
1635 : 0 : static int fanout_add(struct sock *sk, u16 id, u16 type_flags)
1636 : : {
1637 : : struct packet_rollover *rollover = NULL;
1638 : : struct packet_sock *po = pkt_sk(sk);
1639 : : struct packet_fanout *f, *match;
1640 : 0 : u8 type = type_flags & 0xff;
1641 : 0 : u8 flags = type_flags >> 8;
1642 : : int err;
1643 : :
1644 : 0 : switch (type) {
1645 : : case PACKET_FANOUT_ROLLOVER:
1646 : 0 : if (type_flags & PACKET_FANOUT_FLAG_ROLLOVER)
1647 : : return -EINVAL;
1648 : : case PACKET_FANOUT_HASH:
1649 : : case PACKET_FANOUT_LB:
1650 : : case PACKET_FANOUT_CPU:
1651 : : case PACKET_FANOUT_RND:
1652 : : case PACKET_FANOUT_QM:
1653 : : case PACKET_FANOUT_CBPF:
1654 : : case PACKET_FANOUT_EBPF:
1655 : : break;
1656 : : default:
1657 : : return -EINVAL;
1658 : : }
1659 : :
1660 : 0 : mutex_lock(&fanout_mutex);
1661 : :
1662 : : err = -EALREADY;
1663 : 0 : if (po->fanout)
1664 : : goto out;
1665 : :
1666 : 0 : if (type == PACKET_FANOUT_ROLLOVER ||
1667 : 0 : (type_flags & PACKET_FANOUT_FLAG_ROLLOVER)) {
1668 : : err = -ENOMEM;
1669 : 0 : rollover = kzalloc(sizeof(*rollover), GFP_KERNEL);
1670 : 0 : if (!rollover)
1671 : : goto out;
1672 : : atomic_long_set(&rollover->num, 0);
1673 : : atomic_long_set(&rollover->num_huge, 0);
1674 : : atomic_long_set(&rollover->num_failed, 0);
1675 : : }
1676 : :
1677 : 0 : if (type_flags & PACKET_FANOUT_FLAG_UNIQUEID) {
1678 : 0 : if (id != 0) {
1679 : : err = -EINVAL;
1680 : : goto out;
1681 : : }
1682 : 0 : if (!fanout_find_new_id(sk, &id)) {
1683 : : err = -ENOMEM;
1684 : : goto out;
1685 : : }
1686 : : /* ephemeral flag for the first socket in the group: drop it */
1687 : 0 : flags &= ~(PACKET_FANOUT_FLAG_UNIQUEID >> 8);
1688 : : }
1689 : :
1690 : : match = NULL;
1691 : 0 : list_for_each_entry(f, &fanout_list, list) {
1692 : 0 : if (f->id == id &&
1693 : : read_pnet(&f->net) == sock_net(sk)) {
1694 : 0 : match = f;
1695 : 0 : break;
1696 : : }
1697 : : }
1698 : : err = -EINVAL;
1699 : 0 : if (match && match->flags != flags)
1700 : : goto out;
1701 : 0 : if (!match) {
1702 : : err = -ENOMEM;
1703 : 0 : match = kzalloc(sizeof(*match), GFP_KERNEL);
1704 : 0 : if (!match)
1705 : : goto out;
1706 : : write_pnet(&match->net, sock_net(sk));
1707 : 0 : match->id = id;
1708 : 0 : match->type = type;
1709 : 0 : match->flags = flags;
1710 : 0 : INIT_LIST_HEAD(&match->list);
1711 : 0 : spin_lock_init(&match->lock);
1712 : : refcount_set(&match->sk_ref, 0);
1713 : : fanout_init_data(match);
1714 : 0 : match->prot_hook.type = po->prot_hook.type;
1715 : 0 : match->prot_hook.dev = po->prot_hook.dev;
1716 : 0 : match->prot_hook.func = packet_rcv_fanout;
1717 : 0 : match->prot_hook.af_packet_priv = match;
1718 : 0 : match->prot_hook.id_match = match_fanout_group;
1719 : : list_add(&match->list, &fanout_list);
1720 : : }
1721 : : err = -EINVAL;
1722 : :
1723 : : spin_lock(&po->bind_lock);
1724 : 0 : if (po->running &&
1725 : 0 : match->type == type &&
1726 : 0 : match->prot_hook.type == po->prot_hook.type &&
1727 : 0 : match->prot_hook.dev == po->prot_hook.dev) {
1728 : : err = -ENOSPC;
1729 : 0 : if (refcount_read(&match->sk_ref) < PACKET_FANOUT_MAX) {
1730 : 0 : __dev_remove_pack(&po->prot_hook);
1731 : 0 : po->fanout = match;
1732 : 0 : po->rollover = rollover;
1733 : : rollover = NULL;
1734 : 0 : refcount_set(&match->sk_ref, refcount_read(&match->sk_ref) + 1);
1735 : 0 : __fanout_link(sk, po);
1736 : : err = 0;
1737 : : }
1738 : : }
1739 : : spin_unlock(&po->bind_lock);
1740 : :
1741 : 0 : if (err && !refcount_read(&match->sk_ref)) {
1742 : : list_del(&match->list);
1743 : 0 : kfree(match);
1744 : : }
1745 : :
1746 : : out:
1747 : 0 : kfree(rollover);
1748 : 0 : mutex_unlock(&fanout_mutex);
1749 : 0 : return err;
1750 : : }
1751 : :
1752 : : /* If pkt_sk(sk)->fanout->sk_ref is zero, this function removes
1753 : : * pkt_sk(sk)->fanout from fanout_list and returns pkt_sk(sk)->fanout.
1754 : : * It is the responsibility of the caller to call fanout_release_data() and
1755 : : * free the returned packet_fanout (after synchronize_net())
1756 : : */
1757 : 3 : static struct packet_fanout *fanout_release(struct sock *sk)
1758 : : {
1759 : : struct packet_sock *po = pkt_sk(sk);
1760 : : struct packet_fanout *f;
1761 : :
1762 : 3 : mutex_lock(&fanout_mutex);
1763 : 3 : f = po->fanout;
1764 : 3 : if (f) {
1765 : 0 : po->fanout = NULL;
1766 : :
1767 : 0 : if (refcount_dec_and_test(&f->sk_ref))
1768 : : list_del(&f->list);
1769 : : else
1770 : : f = NULL;
1771 : : }
1772 : 3 : mutex_unlock(&fanout_mutex);
1773 : :
1774 : 3 : return f;
1775 : : }
1776 : :
1777 : : static bool packet_extra_vlan_len_allowed(const struct net_device *dev,
1778 : : struct sk_buff *skb)
1779 : : {
1780 : : /* Earlier code assumed this would be a VLAN pkt, double-check
1781 : : * this now that we have the actual packet in hand. We can only
1782 : : * do this check on Ethernet devices.
1783 : : */
1784 : 0 : if (unlikely(dev->type != ARPHRD_ETHER))
1785 : : return false;
1786 : :
1787 : : skb_reset_mac_header(skb);
1788 : 0 : return likely(eth_hdr(skb)->h_proto == htons(ETH_P_8021Q));
1789 : : }
1790 : :
1791 : : static const struct proto_ops packet_ops;
1792 : :
1793 : : static const struct proto_ops packet_ops_spkt;
1794 : :
1795 : 0 : static int packet_rcv_spkt(struct sk_buff *skb, struct net_device *dev,
1796 : : struct packet_type *pt, struct net_device *orig_dev)
1797 : : {
1798 : : struct sock *sk;
1799 : : struct sockaddr_pkt *spkt;
1800 : :
1801 : : /*
1802 : : * When we registered the protocol we saved the socket in the data
1803 : : * field for just this event.
1804 : : */
1805 : :
1806 : 0 : sk = pt->af_packet_priv;
1807 : :
1808 : : /*
1809 : : * Yank back the headers [hope the device set this
1810 : : * right or kerboom...]
1811 : : *
1812 : : * Incoming packets have ll header pulled,
1813 : : * push it back.
1814 : : *
1815 : : * For outgoing ones skb->data == skb_mac_header(skb)
1816 : : * so that this procedure is noop.
1817 : : */
1818 : :
1819 : 0 : if (skb->pkt_type == PACKET_LOOPBACK)
1820 : : goto out;
1821 : :
1822 : 0 : if (!net_eq(dev_net(dev), sock_net(sk)))
1823 : : goto out;
1824 : :
1825 : 0 : skb = skb_share_check(skb, GFP_ATOMIC);
1826 : 0 : if (skb == NULL)
1827 : : goto oom;
1828 : :
1829 : : /* drop any routing info */
1830 : 0 : skb_dst_drop(skb);
1831 : :
1832 : : /* drop conntrack reference */
1833 : : nf_reset_ct(skb);
1834 : :
1835 : : spkt = &PACKET_SKB_CB(skb)->sa.pkt;
1836 : :
1837 : 0 : skb_push(skb, skb->data - skb_mac_header(skb));
1838 : :
1839 : : /*
1840 : : * The SOCK_PACKET socket receives _all_ frames.
1841 : : */
1842 : :
1843 : 0 : spkt->spkt_family = dev->type;
1844 : 0 : strlcpy(spkt->spkt_device, dev->name, sizeof(spkt->spkt_device));
1845 : 0 : spkt->spkt_protocol = skb->protocol;
1846 : :
1847 : : /*
1848 : : * Charge the memory to the socket. This is done specifically
1849 : : * to prevent sockets using all the memory up.
1850 : : */
1851 : :
1852 : 0 : if (sock_queue_rcv_skb(sk, skb) == 0)
1853 : : return 0;
1854 : :
1855 : : out:
1856 : 0 : kfree_skb(skb);
1857 : : oom:
1858 : : return 0;
1859 : : }
1860 : :
1861 : 3 : static void packet_parse_headers(struct sk_buff *skb, struct socket *sock)
1862 : : {
1863 : 3 : if ((!skb->protocol || skb->protocol == htons(ETH_P_ALL)) &&
1864 : 3 : sock->type == SOCK_RAW) {
1865 : : skb_reset_mac_header(skb);
1866 : 3 : skb->protocol = dev_parse_header_protocol(skb);
1867 : : }
1868 : :
1869 : 3 : skb_probe_transport_header(skb);
1870 : 3 : }
1871 : :
1872 : : /*
1873 : : * Output a raw packet to a device layer. This bypasses all the other
1874 : : * protocol layers and you must therefore supply it with a complete frame
1875 : : */
1876 : :
1877 : 0 : static int packet_sendmsg_spkt(struct socket *sock, struct msghdr *msg,
1878 : : size_t len)
1879 : : {
1880 : 0 : struct sock *sk = sock->sk;
1881 : 0 : DECLARE_SOCKADDR(struct sockaddr_pkt *, saddr, msg->msg_name);
1882 : : struct sk_buff *skb = NULL;
1883 : : struct net_device *dev;
1884 : : struct sockcm_cookie sockc;
1885 : : __be16 proto = 0;
1886 : : int err;
1887 : : int extra_len = 0;
1888 : :
1889 : : /*
1890 : : * Get and verify the address.
1891 : : */
1892 : :
1893 : 0 : if (saddr) {
1894 : 0 : if (msg->msg_namelen < sizeof(struct sockaddr))
1895 : : return -EINVAL;
1896 : 0 : if (msg->msg_namelen == sizeof(struct sockaddr_pkt))
1897 : 0 : proto = saddr->spkt_protocol;
1898 : : } else
1899 : : return -ENOTCONN; /* SOCK_PACKET must be sent giving an address */
1900 : :
1901 : : /*
1902 : : * Find the device first to size check it
1903 : : */
1904 : :
1905 : 0 : saddr->spkt_device[sizeof(saddr->spkt_device) - 1] = 0;
1906 : : retry:
1907 : : rcu_read_lock();
1908 : 0 : dev = dev_get_by_name_rcu(sock_net(sk), saddr->spkt_device);
1909 : : err = -ENODEV;
1910 : 0 : if (dev == NULL)
1911 : : goto out_unlock;
1912 : :
1913 : : err = -ENETDOWN;
1914 : 0 : if (!(dev->flags & IFF_UP))
1915 : : goto out_unlock;
1916 : :
1917 : : /*
1918 : : * You may not queue a frame bigger than the mtu. This is the lowest level
1919 : : * raw protocol and you must do your own fragmentation at this level.
1920 : : */
1921 : :
1922 : 0 : if (unlikely(sock_flag(sk, SOCK_NOFCS))) {
1923 : 0 : if (!netif_supports_nofcs(dev)) {
1924 : : err = -EPROTONOSUPPORT;
1925 : : goto out_unlock;
1926 : : }
1927 : : extra_len = 4; /* We're doing our own CRC */
1928 : : }
1929 : :
1930 : : err = -EMSGSIZE;
1931 : 0 : if (len > dev->mtu + dev->hard_header_len + VLAN_HLEN + extra_len)
1932 : : goto out_unlock;
1933 : :
1934 : 0 : if (!skb) {
1935 : 0 : size_t reserved = LL_RESERVED_SPACE(dev);
1936 : 0 : int tlen = dev->needed_tailroom;
1937 : 0 : unsigned int hhlen = dev->header_ops ? dev->hard_header_len : 0;
1938 : :
1939 : : rcu_read_unlock();
1940 : 0 : skb = sock_wmalloc(sk, len + reserved + tlen, 0, GFP_KERNEL);
1941 : 0 : if (skb == NULL)
1942 : : return -ENOBUFS;
1943 : : /* FIXME: Save some space for broken drivers that write a hard
1944 : : * header at transmission time by themselves. PPP is the notable
1945 : : * one here. This should really be fixed at the driver level.
1946 : : */
1947 : : skb_reserve(skb, reserved);
1948 : : skb_reset_network_header(skb);
1949 : :
1950 : : /* Try to align data part correctly */
1951 : 0 : if (hhlen) {
1952 : 0 : skb->data -= hhlen;
1953 : 0 : skb->tail -= hhlen;
1954 : 0 : if (len < hhlen)
1955 : : skb_reset_network_header(skb);
1956 : : }
1957 : 0 : err = memcpy_from_msg(skb_put(skb, len), msg, len);
1958 : 0 : if (err)
1959 : : goto out_free;
1960 : : goto retry;
1961 : : }
1962 : :
1963 : 0 : if (!dev_validate_header(dev, skb->data, len)) {
1964 : : err = -EINVAL;
1965 : : goto out_unlock;
1966 : : }
1967 : 0 : if (len > (dev->mtu + dev->hard_header_len + extra_len) &&
1968 : : !packet_extra_vlan_len_allowed(dev, skb)) {
1969 : : err = -EMSGSIZE;
1970 : : goto out_unlock;
1971 : : }
1972 : :
1973 : : sockcm_init(&sockc, sk);
1974 : 0 : if (msg->msg_controllen) {
1975 : 0 : err = sock_cmsg_send(sk, msg, &sockc);
1976 : 0 : if (unlikely(err))
1977 : : goto out_unlock;
1978 : : }
1979 : :
1980 : 0 : skb->protocol = proto;
1981 : 0 : skb->dev = dev;
1982 : 0 : skb->priority = sk->sk_priority;
1983 : 0 : skb->mark = sk->sk_mark;
1984 : 0 : skb->tstamp = sockc.transmit_time;
1985 : :
1986 : 0 : skb_setup_tx_timestamp(skb, sockc.tsflags);
1987 : :
1988 : 0 : if (unlikely(extra_len == 4))
1989 : 0 : skb->no_fcs = 1;
1990 : :
1991 : 0 : packet_parse_headers(skb, sock);
1992 : :
1993 : 0 : dev_queue_xmit(skb);
1994 : : rcu_read_unlock();
1995 : 0 : return len;
1996 : :
1997 : : out_unlock:
1998 : : rcu_read_unlock();
1999 : : out_free:
2000 : 0 : kfree_skb(skb);
2001 : 0 : return err;
2002 : : }
2003 : :
2004 : 3 : static unsigned int run_filter(struct sk_buff *skb,
2005 : : const struct sock *sk,
2006 : : unsigned int res)
2007 : : {
2008 : : struct sk_filter *filter;
2009 : :
2010 : : rcu_read_lock();
2011 : 3 : filter = rcu_dereference(sk->sk_filter);
2012 : 3 : if (filter != NULL)
2013 : 3 : res = bpf_prog_run_clear_cb(filter->prog, skb);
2014 : : rcu_read_unlock();
2015 : :
2016 : 3 : return res;
2017 : : }
2018 : :
2019 : 0 : static int packet_rcv_vnet(struct msghdr *msg, const struct sk_buff *skb,
2020 : : size_t *len)
2021 : : {
2022 : : struct virtio_net_hdr vnet_hdr;
2023 : :
2024 : 0 : if (*len < sizeof(vnet_hdr))
2025 : : return -EINVAL;
2026 : 0 : *len -= sizeof(vnet_hdr);
2027 : :
2028 : 0 : if (virtio_net_hdr_from_skb(skb, &vnet_hdr, vio_le(), true, 0))
2029 : : return -EINVAL;
2030 : :
2031 : 0 : return memcpy_to_msg(msg, (void *)&vnet_hdr, sizeof(vnet_hdr));
2032 : : }
2033 : :
2034 : : /*
2035 : : * This function makes lazy skb cloning in hope that most of packets
2036 : : * are discarded by BPF.
2037 : : *
2038 : : * Note tricky part: we DO mangle shared skb! skb->data, skb->len
2039 : : * and skb->cb are mangled. It works because (and until) packets
2040 : : * falling here are owned by current CPU. Output packets are cloned
2041 : : * by dev_queue_xmit_nit(), input packets are processed by net_bh
2042 : : * sequencially, so that if we return skb to original state on exit,
2043 : : * we will not harm anyone.
2044 : : */
2045 : :
2046 : 3 : static int packet_rcv(struct sk_buff *skb, struct net_device *dev,
2047 : : struct packet_type *pt, struct net_device *orig_dev)
2048 : : {
2049 : : struct sock *sk;
2050 : : struct sockaddr_ll *sll;
2051 : : struct packet_sock *po;
2052 : 3 : u8 *skb_head = skb->data;
2053 : 3 : int skb_len = skb->len;
2054 : : unsigned int snaplen, res;
2055 : : bool is_drop_n_account = false;
2056 : :
2057 : 3 : if (skb->pkt_type == PACKET_LOOPBACK)
2058 : : goto drop;
2059 : :
2060 : 3 : sk = pt->af_packet_priv;
2061 : : po = pkt_sk(sk);
2062 : :
2063 : 3 : if (!net_eq(dev_net(dev), sock_net(sk)))
2064 : : goto drop;
2065 : :
2066 : 3 : skb->dev = dev;
2067 : :
2068 : 3 : if (dev->header_ops) {
2069 : : /* The device has an explicit notion of ll header,
2070 : : * exported to higher levels.
2071 : : *
2072 : : * Otherwise, the device hides details of its frame
2073 : : * structure, so that corresponding packet head is
2074 : : * never delivered to user.
2075 : : */
2076 : 3 : if (sk->sk_type != SOCK_DGRAM)
2077 : 3 : skb_push(skb, skb->data - skb_mac_header(skb));
2078 : 0 : else if (skb->pkt_type == PACKET_OUTGOING) {
2079 : : /* Special case: outgoing packets have ll header at head */
2080 : 0 : skb_pull(skb, skb_network_offset(skb));
2081 : : }
2082 : : }
2083 : :
2084 : 3 : snaplen = skb->len;
2085 : :
2086 : 3 : res = run_filter(skb, sk, snaplen);
2087 : 3 : if (!res)
2088 : : goto drop_n_restore;
2089 : 3 : if (snaplen > res)
2090 : : snaplen = res;
2091 : :
2092 : 3 : if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
2093 : : goto drop_n_acct;
2094 : :
2095 : 3 : if (skb_shared(skb)) {
2096 : 3 : struct sk_buff *nskb = skb_clone(skb, GFP_ATOMIC);
2097 : 3 : if (nskb == NULL)
2098 : : goto drop_n_acct;
2099 : :
2100 : 3 : if (skb_head != skb->data) {
2101 : 3 : skb->data = skb_head;
2102 : 3 : skb->len = skb_len;
2103 : : }
2104 : 3 : consume_skb(skb);
2105 : : skb = nskb;
2106 : : }
2107 : :
2108 : : sock_skb_cb_check_size(sizeof(*PACKET_SKB_CB(skb)) + MAX_ADDR_LEN - 8);
2109 : :
2110 : : sll = &PACKET_SKB_CB(skb)->sa.ll;
2111 : 3 : sll->sll_hatype = dev->type;
2112 : 3 : sll->sll_pkttype = skb->pkt_type;
2113 : 3 : if (unlikely(po->origdev))
2114 : 0 : sll->sll_ifindex = orig_dev->ifindex;
2115 : : else
2116 : 3 : sll->sll_ifindex = dev->ifindex;
2117 : :
2118 : 3 : sll->sll_halen = dev_parse_header(skb, sll->sll_addr);
2119 : :
2120 : : /* sll->sll_family and sll->sll_protocol are set in packet_recvmsg().
2121 : : * Use their space for storing the original skb length.
2122 : : */
2123 : 3 : PACKET_SKB_CB(skb)->sa.origlen = skb->len;
2124 : :
2125 : 3 : if (pskb_trim(skb, snaplen))
2126 : : goto drop_n_acct;
2127 : :
2128 : 3 : skb_set_owner_r(skb, sk);
2129 : 3 : skb->dev = NULL;
2130 : 3 : skb_dst_drop(skb);
2131 : :
2132 : : /* drop conntrack reference */
2133 : : nf_reset_ct(skb);
2134 : :
2135 : : spin_lock(&sk->sk_receive_queue.lock);
2136 : 3 : po->stats.stats1.tp_packets++;
2137 : : sock_skb_set_dropcount(sk, skb);
2138 : 3 : __skb_queue_tail(&sk->sk_receive_queue, skb);
2139 : : spin_unlock(&sk->sk_receive_queue.lock);
2140 : 3 : sk->sk_data_ready(sk);
2141 : 3 : return 0;
2142 : :
2143 : : drop_n_acct:
2144 : : is_drop_n_account = true;
2145 : 0 : atomic_inc(&po->tp_drops);
2146 : 0 : atomic_inc(&sk->sk_drops);
2147 : :
2148 : : drop_n_restore:
2149 : 3 : if (skb_head != skb->data && skb_shared(skb)) {
2150 : 3 : skb->data = skb_head;
2151 : 3 : skb->len = skb_len;
2152 : : }
2153 : : drop:
2154 : 3 : if (!is_drop_n_account)
2155 : 3 : consume_skb(skb);
2156 : : else
2157 : 0 : kfree_skb(skb);
2158 : : return 0;
2159 : : }
2160 : :
2161 : 0 : static int tpacket_rcv(struct sk_buff *skb, struct net_device *dev,
2162 : : struct packet_type *pt, struct net_device *orig_dev)
2163 : : {
2164 : : struct sock *sk;
2165 : : struct packet_sock *po;
2166 : : struct sockaddr_ll *sll;
2167 : : union tpacket_uhdr h;
2168 : 0 : u8 *skb_head = skb->data;
2169 : 0 : int skb_len = skb->len;
2170 : : unsigned int snaplen, res;
2171 : : unsigned long status = TP_STATUS_USER;
2172 : : unsigned short macoff, netoff, hdrlen;
2173 : : struct sk_buff *copy_skb = NULL;
2174 : : struct timespec ts;
2175 : : __u32 ts_status;
2176 : : bool is_drop_n_account = false;
2177 : : unsigned int slot_id = 0;
2178 : : bool do_vnet = false;
2179 : :
2180 : : /* struct tpacket{2,3}_hdr is aligned to a multiple of TPACKET_ALIGNMENT.
2181 : : * We may add members to them until current aligned size without forcing
2182 : : * userspace to call getsockopt(..., PACKET_HDRLEN, ...).
2183 : : */
2184 : : BUILD_BUG_ON(TPACKET_ALIGN(sizeof(*h.h2)) != 32);
2185 : : BUILD_BUG_ON(TPACKET_ALIGN(sizeof(*h.h3)) != 48);
2186 : :
2187 : 0 : if (skb->pkt_type == PACKET_LOOPBACK)
2188 : : goto drop;
2189 : :
2190 : 0 : sk = pt->af_packet_priv;
2191 : : po = pkt_sk(sk);
2192 : :
2193 : 0 : if (!net_eq(dev_net(dev), sock_net(sk)))
2194 : : goto drop;
2195 : :
2196 : 0 : if (dev->header_ops) {
2197 : 0 : if (sk->sk_type != SOCK_DGRAM)
2198 : 0 : skb_push(skb, skb->data - skb_mac_header(skb));
2199 : 0 : else if (skb->pkt_type == PACKET_OUTGOING) {
2200 : : /* Special case: outgoing packets have ll header at head */
2201 : 0 : skb_pull(skb, skb_network_offset(skb));
2202 : : }
2203 : : }
2204 : :
2205 : 0 : snaplen = skb->len;
2206 : :
2207 : 0 : res = run_filter(skb, sk, snaplen);
2208 : 0 : if (!res)
2209 : : goto drop_n_restore;
2210 : :
2211 : : /* If we are flooded, just give up */
2212 : 0 : if (__packet_rcv_has_room(po, skb) == ROOM_NONE) {
2213 : 0 : atomic_inc(&po->tp_drops);
2214 : : goto drop_n_restore;
2215 : : }
2216 : :
2217 : 0 : if (skb->ip_summed == CHECKSUM_PARTIAL)
2218 : : status |= TP_STATUS_CSUMNOTREADY;
2219 : 0 : else if (skb->pkt_type != PACKET_OUTGOING &&
2220 : 0 : (skb->ip_summed == CHECKSUM_COMPLETE ||
2221 : 0 : skb_csum_unnecessary(skb)))
2222 : : status |= TP_STATUS_CSUM_VALID;
2223 : :
2224 : 0 : if (snaplen > res)
2225 : : snaplen = res;
2226 : :
2227 : 0 : if (sk->sk_type == SOCK_DGRAM) {
2228 : 0 : macoff = netoff = TPACKET_ALIGN(po->tp_hdrlen) + 16 +
2229 : 0 : po->tp_reserve;
2230 : : } else {
2231 : 0 : unsigned int maclen = skb_network_offset(skb);
2232 : 0 : netoff = TPACKET_ALIGN(po->tp_hdrlen +
2233 : : (maclen < 16 ? 16 : maclen)) +
2234 : 0 : po->tp_reserve;
2235 : 0 : if (po->has_vnet_hdr) {
2236 : 0 : netoff += sizeof(struct virtio_net_hdr);
2237 : : do_vnet = true;
2238 : : }
2239 : 0 : macoff = netoff - maclen;
2240 : : }
2241 : 0 : if (po->tp_version <= TPACKET_V2) {
2242 : 0 : if (macoff + snaplen > po->rx_ring.frame_size) {
2243 : 0 : if (po->copy_thresh &&
2244 : 0 : atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf) {
2245 : 0 : if (skb_shared(skb)) {
2246 : 0 : copy_skb = skb_clone(skb, GFP_ATOMIC);
2247 : : } else {
2248 : : copy_skb = skb_get(skb);
2249 : 0 : skb_head = skb->data;
2250 : : }
2251 : 0 : if (copy_skb)
2252 : 0 : skb_set_owner_r(copy_skb, sk);
2253 : : }
2254 : 0 : snaplen = po->rx_ring.frame_size - macoff;
2255 : 0 : if ((int)snaplen < 0) {
2256 : : snaplen = 0;
2257 : : do_vnet = false;
2258 : : }
2259 : : }
2260 : 0 : } else if (unlikely(macoff + snaplen >
2261 : : GET_PBDQC_FROM_RB(&po->rx_ring)->max_frame_len)) {
2262 : : u32 nval;
2263 : :
2264 : 0 : nval = GET_PBDQC_FROM_RB(&po->rx_ring)->max_frame_len - macoff;
2265 : 0 : pr_err_once("tpacket_rcv: packet too big, clamped from %u to %u. macoff=%u\n",
2266 : : snaplen, nval, macoff);
2267 : : snaplen = nval;
2268 : 0 : if (unlikely((int)snaplen < 0)) {
2269 : : snaplen = 0;
2270 : 0 : macoff = GET_PBDQC_FROM_RB(&po->rx_ring)->max_frame_len;
2271 : : do_vnet = false;
2272 : : }
2273 : : }
2274 : : spin_lock(&sk->sk_receive_queue.lock);
2275 : 0 : h.raw = packet_current_rx_frame(po, skb,
2276 : : TP_STATUS_KERNEL, (macoff+snaplen));
2277 : 0 : if (!h.raw)
2278 : : goto drop_n_account;
2279 : :
2280 : 0 : if (po->tp_version <= TPACKET_V2) {
2281 : 0 : slot_id = po->rx_ring.head;
2282 : 0 : if (test_bit(slot_id, po->rx_ring.rx_owner_map))
2283 : : goto drop_n_account;
2284 : : __set_bit(slot_id, po->rx_ring.rx_owner_map);
2285 : : }
2286 : :
2287 : 0 : if (do_vnet &&
2288 : 0 : virtio_net_hdr_from_skb(skb, h.raw + macoff -
2289 : : sizeof(struct virtio_net_hdr),
2290 : : vio_le(), true, 0)) {
2291 : 0 : if (po->tp_version == TPACKET_V3)
2292 : : prb_clear_blk_fill_status(&po->rx_ring);
2293 : : goto drop_n_account;
2294 : : }
2295 : :
2296 : 0 : if (po->tp_version <= TPACKET_V2) {
2297 : 0 : packet_increment_rx_head(po, &po->rx_ring);
2298 : : /*
2299 : : * LOSING will be reported till you read the stats,
2300 : : * because it's COR - Clear On Read.
2301 : : * Anyways, moving it for V1/V2 only as V3 doesn't need this
2302 : : * at packet level.
2303 : : */
2304 : 0 : if (atomic_read(&po->tp_drops))
2305 : 0 : status |= TP_STATUS_LOSING;
2306 : : }
2307 : :
2308 : 0 : po->stats.stats1.tp_packets++;
2309 : 0 : if (copy_skb) {
2310 : 0 : status |= TP_STATUS_COPY;
2311 : 0 : __skb_queue_tail(&sk->sk_receive_queue, copy_skb);
2312 : : }
2313 : : spin_unlock(&sk->sk_receive_queue.lock);
2314 : :
2315 : 0 : skb_copy_bits(skb, 0, h.raw + macoff, snaplen);
2316 : :
2317 : 0 : if (!(ts_status = tpacket_get_timestamp(skb, &ts, po->tp_tstamp)))
2318 : : getnstimeofday(&ts);
2319 : :
2320 : 0 : status |= ts_status;
2321 : :
2322 : 0 : switch (po->tp_version) {
2323 : : case TPACKET_V1:
2324 : 0 : h.h1->tp_len = skb->len;
2325 : 0 : h.h1->tp_snaplen = snaplen;
2326 : 0 : h.h1->tp_mac = macoff;
2327 : 0 : h.h1->tp_net = netoff;
2328 : 0 : h.h1->tp_sec = ts.tv_sec;
2329 : 0 : h.h1->tp_usec = ts.tv_nsec / NSEC_PER_USEC;
2330 : : hdrlen = sizeof(*h.h1);
2331 : 0 : break;
2332 : : case TPACKET_V2:
2333 : 0 : h.h2->tp_len = skb->len;
2334 : 0 : h.h2->tp_snaplen = snaplen;
2335 : 0 : h.h2->tp_mac = macoff;
2336 : 0 : h.h2->tp_net = netoff;
2337 : 0 : h.h2->tp_sec = ts.tv_sec;
2338 : 0 : h.h2->tp_nsec = ts.tv_nsec;
2339 : 0 : if (skb_vlan_tag_present(skb)) {
2340 : 0 : h.h2->tp_vlan_tci = skb_vlan_tag_get(skb);
2341 : 0 : h.h2->tp_vlan_tpid = ntohs(skb->vlan_proto);
2342 : 0 : status |= TP_STATUS_VLAN_VALID | TP_STATUS_VLAN_TPID_VALID;
2343 : : } else {
2344 : 0 : h.h2->tp_vlan_tci = 0;
2345 : 0 : h.h2->tp_vlan_tpid = 0;
2346 : : }
2347 : 0 : memset(h.h2->tp_padding, 0, sizeof(h.h2->tp_padding));
2348 : : hdrlen = sizeof(*h.h2);
2349 : 0 : break;
2350 : : case TPACKET_V3:
2351 : : /* tp_nxt_offset,vlan are already populated above.
2352 : : * So DONT clear those fields here
2353 : : */
2354 : 0 : h.h3->tp_status |= status;
2355 : 0 : h.h3->tp_len = skb->len;
2356 : 0 : h.h3->tp_snaplen = snaplen;
2357 : 0 : h.h3->tp_mac = macoff;
2358 : 0 : h.h3->tp_net = netoff;
2359 : 0 : h.h3->tp_sec = ts.tv_sec;
2360 : 0 : h.h3->tp_nsec = ts.tv_nsec;
2361 : 0 : memset(h.h3->tp_padding, 0, sizeof(h.h3->tp_padding));
2362 : : hdrlen = sizeof(*h.h3);
2363 : 0 : break;
2364 : : default:
2365 : 0 : BUG();
2366 : : }
2367 : :
2368 : 0 : sll = h.raw + TPACKET_ALIGN(hdrlen);
2369 : 0 : sll->sll_halen = dev_parse_header(skb, sll->sll_addr);
2370 : 0 : sll->sll_family = AF_PACKET;
2371 : 0 : sll->sll_hatype = dev->type;
2372 : 0 : sll->sll_protocol = skb->protocol;
2373 : 0 : sll->sll_pkttype = skb->pkt_type;
2374 : 0 : if (unlikely(po->origdev))
2375 : 0 : sll->sll_ifindex = orig_dev->ifindex;
2376 : : else
2377 : 0 : sll->sll_ifindex = dev->ifindex;
2378 : :
2379 : 0 : smp_mb();
2380 : :
2381 : : #if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE == 1
2382 : 0 : if (po->tp_version <= TPACKET_V2) {
2383 : : u8 *start, *end;
2384 : :
2385 : 0 : end = (u8 *) PAGE_ALIGN((unsigned long) h.raw +
2386 : : macoff + snaplen);
2387 : :
2388 : 0 : for (start = h.raw; start < end; start += PAGE_SIZE)
2389 : 0 : flush_dcache_page(pgv_to_page(start));
2390 : : }
2391 : 0 : smp_wmb();
2392 : : #endif
2393 : :
2394 : 0 : if (po->tp_version <= TPACKET_V2) {
2395 : : spin_lock(&sk->sk_receive_queue.lock);
2396 : 0 : __packet_set_status(po, h.raw, status);
2397 : 0 : __clear_bit(slot_id, po->rx_ring.rx_owner_map);
2398 : : spin_unlock(&sk->sk_receive_queue.lock);
2399 : 0 : sk->sk_data_ready(sk);
2400 : 0 : } else if (po->tp_version == TPACKET_V3) {
2401 : : prb_clear_blk_fill_status(&po->rx_ring);
2402 : : }
2403 : :
2404 : : drop_n_restore:
2405 : 0 : if (skb_head != skb->data && skb_shared(skb)) {
2406 : 0 : skb->data = skb_head;
2407 : 0 : skb->len = skb_len;
2408 : : }
2409 : : drop:
2410 : 0 : if (!is_drop_n_account)
2411 : 0 : consume_skb(skb);
2412 : : else
2413 : 0 : kfree_skb(skb);
2414 : 0 : return 0;
2415 : :
2416 : : drop_n_account:
2417 : : spin_unlock(&sk->sk_receive_queue.lock);
2418 : 0 : atomic_inc(&po->tp_drops);
2419 : : is_drop_n_account = true;
2420 : :
2421 : 0 : sk->sk_data_ready(sk);
2422 : 0 : kfree_skb(copy_skb);
2423 : 0 : goto drop_n_restore;
2424 : : }
2425 : :
2426 : 0 : static void tpacket_destruct_skb(struct sk_buff *skb)
2427 : : {
2428 : 0 : struct packet_sock *po = pkt_sk(skb->sk);
2429 : :
2430 : 0 : if (likely(po->tx_ring.pg_vec)) {
2431 : : void *ph;
2432 : : __u32 ts;
2433 : :
2434 : : ph = skb_zcopy_get_nouarg(skb);
2435 : 0 : packet_dec_pending(&po->tx_ring);
2436 : :
2437 : 0 : ts = __packet_set_timestamp(po, ph, skb);
2438 : 0 : __packet_set_status(po, ph, TP_STATUS_AVAILABLE | ts);
2439 : :
2440 : 0 : if (!packet_read_pending(&po->tx_ring))
2441 : 0 : complete(&po->skb_completion);
2442 : : }
2443 : :
2444 : 0 : sock_wfree(skb);
2445 : 0 : }
2446 : :
2447 : : static int __packet_snd_vnet_parse(struct virtio_net_hdr *vnet_hdr, size_t len)
2448 : : {
2449 : 0 : if ((vnet_hdr->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) &&
2450 : 0 : (__virtio16_to_cpu(vio_le(), vnet_hdr->csum_start) +
2451 : 0 : __virtio16_to_cpu(vio_le(), vnet_hdr->csum_offset) + 2 >
2452 : 0 : __virtio16_to_cpu(vio_le(), vnet_hdr->hdr_len)))
2453 : 0 : vnet_hdr->hdr_len = __cpu_to_virtio16(vio_le(),
2454 : : __virtio16_to_cpu(vio_le(), vnet_hdr->csum_start) +
2455 : : __virtio16_to_cpu(vio_le(), vnet_hdr->csum_offset) + 2);
2456 : :
2457 : 0 : if (__virtio16_to_cpu(vio_le(), vnet_hdr->hdr_len) > len)
2458 : : return -EINVAL;
2459 : :
2460 : : return 0;
2461 : : }
2462 : :
2463 : 0 : static int packet_snd_vnet_parse(struct msghdr *msg, size_t *len,
2464 : : struct virtio_net_hdr *vnet_hdr)
2465 : : {
2466 : 0 : if (*len < sizeof(*vnet_hdr))
2467 : : return -EINVAL;
2468 : 0 : *len -= sizeof(*vnet_hdr);
2469 : :
2470 : 0 : if (!copy_from_iter_full(vnet_hdr, sizeof(*vnet_hdr), &msg->msg_iter))
2471 : : return -EFAULT;
2472 : :
2473 : 0 : return __packet_snd_vnet_parse(vnet_hdr, *len);
2474 : : }
2475 : :
2476 : 0 : static int tpacket_fill_skb(struct packet_sock *po, struct sk_buff *skb,
2477 : : void *frame, struct net_device *dev, void *data, int tp_len,
2478 : : __be16 proto, unsigned char *addr, int hlen, int copylen,
2479 : : const struct sockcm_cookie *sockc)
2480 : : {
2481 : : union tpacket_uhdr ph;
2482 : : int to_write, offset, len, nr_frags, len_max;
2483 : 0 : struct socket *sock = po->sk.sk_socket;
2484 : : struct page *page;
2485 : : int err;
2486 : :
2487 : : ph.raw = frame;
2488 : :
2489 : 0 : skb->protocol = proto;
2490 : 0 : skb->dev = dev;
2491 : 0 : skb->priority = po->sk.sk_priority;
2492 : 0 : skb->mark = po->sk.sk_mark;
2493 : 0 : skb->tstamp = sockc->transmit_time;
2494 : 0 : skb_setup_tx_timestamp(skb, sockc->tsflags);
2495 : : skb_zcopy_set_nouarg(skb, ph.raw);
2496 : :
2497 : : skb_reserve(skb, hlen);
2498 : : skb_reset_network_header(skb);
2499 : :
2500 : : to_write = tp_len;
2501 : :
2502 : 0 : if (sock->type == SOCK_DGRAM) {
2503 : 0 : err = dev_hard_header(skb, dev, ntohs(proto), addr,
2504 : : NULL, tp_len);
2505 : 0 : if (unlikely(err < 0))
2506 : : return -EINVAL;
2507 : 0 : } else if (copylen) {
2508 : 0 : int hdrlen = min_t(int, copylen, tp_len);
2509 : :
2510 : 0 : skb_push(skb, dev->hard_header_len);
2511 : 0 : skb_put(skb, copylen - dev->hard_header_len);
2512 : 0 : err = skb_store_bits(skb, 0, data, hdrlen);
2513 : 0 : if (unlikely(err))
2514 : : return err;
2515 : 0 : if (!dev_validate_header(dev, skb->data, hdrlen))
2516 : : return -EINVAL;
2517 : :
2518 : 0 : data += hdrlen;
2519 : 0 : to_write -= hdrlen;
2520 : : }
2521 : :
2522 : 0 : offset = offset_in_page(data);
2523 : 0 : len_max = PAGE_SIZE - offset;
2524 : 0 : len = ((to_write > len_max) ? len_max : to_write);
2525 : :
2526 : 0 : skb->data_len = to_write;
2527 : 0 : skb->len += to_write;
2528 : 0 : skb->truesize += to_write;
2529 : 0 : refcount_add(to_write, &po->sk.sk_wmem_alloc);
2530 : :
2531 : 0 : while (likely(to_write)) {
2532 : 0 : nr_frags = skb_shinfo(skb)->nr_frags;
2533 : :
2534 : 0 : if (unlikely(nr_frags >= MAX_SKB_FRAGS)) {
2535 : 0 : pr_err("Packet exceed the number of skb frags(%lu)\n",
2536 : : MAX_SKB_FRAGS);
2537 : 0 : return -EFAULT;
2538 : : }
2539 : :
2540 : 0 : page = pgv_to_page(data);
2541 : 0 : data += len;
2542 : 0 : flush_dcache_page(page);
2543 : 0 : get_page(page);
2544 : : skb_fill_page_desc(skb, nr_frags, page, offset, len);
2545 : 0 : to_write -= len;
2546 : : offset = 0;
2547 : : len_max = PAGE_SIZE;
2548 : 0 : len = ((to_write > len_max) ? len_max : to_write);
2549 : : }
2550 : :
2551 : 0 : packet_parse_headers(skb, sock);
2552 : :
2553 : 0 : return tp_len;
2554 : : }
2555 : :
2556 : 0 : static int tpacket_parse_header(struct packet_sock *po, void *frame,
2557 : : int size_max, void **data)
2558 : : {
2559 : : union tpacket_uhdr ph;
2560 : : int tp_len, off;
2561 : :
2562 : : ph.raw = frame;
2563 : :
2564 : 0 : switch (po->tp_version) {
2565 : : case TPACKET_V3:
2566 : 0 : if (ph.h3->tp_next_offset != 0) {
2567 : 0 : pr_warn_once("variable sized slot not supported");
2568 : : return -EINVAL;
2569 : : }
2570 : 0 : tp_len = ph.h3->tp_len;
2571 : 0 : break;
2572 : : case TPACKET_V2:
2573 : 0 : tp_len = ph.h2->tp_len;
2574 : 0 : break;
2575 : : default:
2576 : 0 : tp_len = ph.h1->tp_len;
2577 : 0 : break;
2578 : : }
2579 : 0 : if (unlikely(tp_len > size_max)) {
2580 : 0 : pr_err("packet size is too long (%d > %d)\n", tp_len, size_max);
2581 : 0 : return -EMSGSIZE;
2582 : : }
2583 : :
2584 : 0 : if (unlikely(po->tp_tx_has_off)) {
2585 : : int off_min, off_max;
2586 : :
2587 : 0 : off_min = po->tp_hdrlen - sizeof(struct sockaddr_ll);
2588 : 0 : off_max = po->tx_ring.frame_size - tp_len;
2589 : 0 : if (po->sk.sk_type == SOCK_DGRAM) {
2590 : 0 : switch (po->tp_version) {
2591 : : case TPACKET_V3:
2592 : 0 : off = ph.h3->tp_net;
2593 : 0 : break;
2594 : : case TPACKET_V2:
2595 : 0 : off = ph.h2->tp_net;
2596 : 0 : break;
2597 : : default:
2598 : 0 : off = ph.h1->tp_net;
2599 : 0 : break;
2600 : : }
2601 : : } else {
2602 : 0 : switch (po->tp_version) {
2603 : : case TPACKET_V3:
2604 : 0 : off = ph.h3->tp_mac;
2605 : 0 : break;
2606 : : case TPACKET_V2:
2607 : 0 : off = ph.h2->tp_mac;
2608 : 0 : break;
2609 : : default:
2610 : 0 : off = ph.h1->tp_mac;
2611 : 0 : break;
2612 : : }
2613 : : }
2614 : 0 : if (unlikely((off < off_min) || (off_max < off)))
2615 : : return -EINVAL;
2616 : : } else {
2617 : 0 : off = po->tp_hdrlen - sizeof(struct sockaddr_ll);
2618 : : }
2619 : :
2620 : 0 : *data = frame + off;
2621 : 0 : return tp_len;
2622 : : }
2623 : :
2624 : 0 : static int tpacket_snd(struct packet_sock *po, struct msghdr *msg)
2625 : : {
2626 : : struct sk_buff *skb = NULL;
2627 : : struct net_device *dev;
2628 : : struct virtio_net_hdr *vnet_hdr = NULL;
2629 : : struct sockcm_cookie sockc;
2630 : : __be16 proto;
2631 : : int err, reserve = 0;
2632 : : void *ph;
2633 : 0 : DECLARE_SOCKADDR(struct sockaddr_ll *, saddr, msg->msg_name);
2634 : 0 : bool need_wait = !(msg->msg_flags & MSG_DONTWAIT);
2635 : : unsigned char *addr = NULL;
2636 : : int tp_len, size_max;
2637 : : void *data;
2638 : : int len_sum = 0;
2639 : : int status = TP_STATUS_AVAILABLE;
2640 : : int hlen, tlen, copylen = 0;
2641 : : long timeo = 0;
2642 : :
2643 : 0 : mutex_lock(&po->pg_vec_lock);
2644 : :
2645 : : /* packet_sendmsg() check on tx_ring.pg_vec was lockless,
2646 : : * we need to confirm it under protection of pg_vec_lock.
2647 : : */
2648 : 0 : if (unlikely(!po->tx_ring.pg_vec)) {
2649 : 0 : err = -EBUSY;
2650 : 0 : goto out;
2651 : : }
2652 : 0 : if (likely(saddr == NULL)) {
2653 : : dev = packet_cached_dev_get(po);
2654 : 0 : proto = po->num;
2655 : : } else {
2656 : 0 : err = -EINVAL;
2657 : 0 : if (msg->msg_namelen < sizeof(struct sockaddr_ll))
2658 : : goto out;
2659 : 0 : if (msg->msg_namelen < (saddr->sll_halen
2660 : 0 : + offsetof(struct sockaddr_ll,
2661 : : sll_addr)))
2662 : : goto out;
2663 : 0 : proto = saddr->sll_protocol;
2664 : 0 : dev = dev_get_by_index(sock_net(&po->sk), saddr->sll_ifindex);
2665 : 0 : if (po->sk.sk_socket->type == SOCK_DGRAM) {
2666 : 0 : if (dev && msg->msg_namelen < dev->addr_len +
2667 : : offsetof(struct sockaddr_ll, sll_addr))
2668 : : goto out_put;
2669 : 0 : addr = saddr->sll_addr;
2670 : : }
2671 : : }
2672 : :
2673 : 0 : err = -ENXIO;
2674 : 0 : if (unlikely(dev == NULL))
2675 : : goto out;
2676 : 0 : err = -ENETDOWN;
2677 : 0 : if (unlikely(!(dev->flags & IFF_UP)))
2678 : : goto out_put;
2679 : :
2680 : : sockcm_init(&sockc, &po->sk);
2681 : 0 : if (msg->msg_controllen) {
2682 : 0 : err = sock_cmsg_send(&po->sk, msg, &sockc);
2683 : 0 : if (unlikely(err))
2684 : : goto out_put;
2685 : : }
2686 : :
2687 : 0 : if (po->sk.sk_socket->type == SOCK_RAW)
2688 : 0 : reserve = dev->hard_header_len;
2689 : 0 : size_max = po->tx_ring.frame_size
2690 : 0 : - (po->tp_hdrlen - sizeof(struct sockaddr_ll));
2691 : :
2692 : 0 : if ((size_max > dev->mtu + reserve + VLAN_HLEN) && !po->has_vnet_hdr)
2693 : 0 : size_max = dev->mtu + reserve + VLAN_HLEN;
2694 : :
2695 : : reinit_completion(&po->skb_completion);
2696 : :
2697 : : do {
2698 : 0 : ph = packet_current_frame(po, &po->tx_ring,
2699 : : TP_STATUS_SEND_REQUEST);
2700 : 0 : if (unlikely(ph == NULL)) {
2701 : 0 : if (need_wait && skb) {
2702 : 0 : timeo = sock_sndtimeo(&po->sk, msg->msg_flags & MSG_DONTWAIT);
2703 : 0 : timeo = wait_for_completion_interruptible_timeout(&po->skb_completion, timeo);
2704 : 0 : if (timeo <= 0) {
2705 : 0 : err = !timeo ? -ETIMEDOUT : -ERESTARTSYS;
2706 : 0 : goto out_put;
2707 : : }
2708 : : }
2709 : : /* check for additional frames */
2710 : 0 : continue;
2711 : : }
2712 : :
2713 : : skb = NULL;
2714 : 0 : tp_len = tpacket_parse_header(po, ph, size_max, &data);
2715 : 0 : if (tp_len < 0)
2716 : : goto tpacket_error;
2717 : :
2718 : : status = TP_STATUS_SEND_REQUEST;
2719 : 0 : hlen = LL_RESERVED_SPACE(dev);
2720 : 0 : tlen = dev->needed_tailroom;
2721 : 0 : if (po->has_vnet_hdr) {
2722 : 0 : vnet_hdr = data;
2723 : 0 : data += sizeof(*vnet_hdr);
2724 : 0 : tp_len -= sizeof(*vnet_hdr);
2725 : 0 : if (tp_len < 0 ||
2726 : : __packet_snd_vnet_parse(vnet_hdr, tp_len)) {
2727 : : tp_len = -EINVAL;
2728 : : goto tpacket_error;
2729 : : }
2730 : 0 : copylen = __virtio16_to_cpu(vio_le(),
2731 : : vnet_hdr->hdr_len);
2732 : : }
2733 : 0 : copylen = max_t(int, copylen, dev->hard_header_len);
2734 : 0 : skb = sock_alloc_send_skb(&po->sk,
2735 : 0 : hlen + tlen + sizeof(struct sockaddr_ll) +
2736 : 0 : (copylen - dev->hard_header_len),
2737 : 0 : !need_wait, &err);
2738 : :
2739 : 0 : if (unlikely(skb == NULL)) {
2740 : : /* we assume the socket was initially writeable ... */
2741 : 0 : if (likely(len_sum > 0))
2742 : 0 : err = len_sum;
2743 : : goto out_status;
2744 : : }
2745 : 0 : tp_len = tpacket_fill_skb(po, skb, ph, dev, data, tp_len, proto,
2746 : : addr, hlen, copylen, &sockc);
2747 : 0 : if (likely(tp_len >= 0) &&
2748 : 0 : tp_len > dev->mtu + reserve &&
2749 : 0 : !po->has_vnet_hdr &&
2750 : : !packet_extra_vlan_len_allowed(dev, skb))
2751 : : tp_len = -EMSGSIZE;
2752 : :
2753 : 0 : if (unlikely(tp_len < 0)) {
2754 : : tpacket_error:
2755 : 0 : if (po->tp_loss) {
2756 : 0 : __packet_set_status(po, ph,
2757 : : TP_STATUS_AVAILABLE);
2758 : : packet_increment_head(&po->tx_ring);
2759 : 0 : kfree_skb(skb);
2760 : 0 : continue;
2761 : : } else {
2762 : : status = TP_STATUS_WRONG_FORMAT;
2763 : 0 : err = tp_len;
2764 : 0 : goto out_status;
2765 : : }
2766 : : }
2767 : :
2768 : 0 : if (po->has_vnet_hdr) {
2769 : 0 : if (virtio_net_hdr_to_skb(skb, vnet_hdr, vio_le())) {
2770 : : tp_len = -EINVAL;
2771 : : goto tpacket_error;
2772 : : }
2773 : : virtio_net_hdr_set_proto(skb, vnet_hdr);
2774 : : }
2775 : :
2776 : 0 : skb->destructor = tpacket_destruct_skb;
2777 : 0 : __packet_set_status(po, ph, TP_STATUS_SENDING);
2778 : 0 : packet_inc_pending(&po->tx_ring);
2779 : :
2780 : : status = TP_STATUS_SEND_REQUEST;
2781 : 0 : err = po->xmit(skb);
2782 : 0 : if (unlikely(err > 0)) {
2783 : 0 : err = net_xmit_errno(err);
2784 : 0 : if (err && __packet_get_status(po, ph) ==
2785 : : TP_STATUS_AVAILABLE) {
2786 : : /* skb was destructed already */
2787 : : skb = NULL;
2788 : : goto out_status;
2789 : : }
2790 : : /*
2791 : : * skb was dropped but not destructed yet;
2792 : : * let's treat it like congestion or err < 0
2793 : : */
2794 : 0 : err = 0;
2795 : : }
2796 : : packet_increment_head(&po->tx_ring);
2797 : 0 : len_sum += tp_len;
2798 : 0 : } while (likely((ph != NULL) ||
2799 : : /* Note: packet_read_pending() might be slow if we have
2800 : : * to call it as it's per_cpu variable, but in fast-path
2801 : : * we already short-circuit the loop with the first
2802 : : * condition, and luckily don't have to go that path
2803 : : * anyway.
2804 : : */
2805 : : (need_wait && packet_read_pending(&po->tx_ring))));
2806 : :
2807 : 0 : err = len_sum;
2808 : 0 : goto out_put;
2809 : :
2810 : : out_status:
2811 : 0 : __packet_set_status(po, ph, status);
2812 : 0 : kfree_skb(skb);
2813 : : out_put:
2814 : 0 : dev_put(dev);
2815 : : out:
2816 : 0 : mutex_unlock(&po->pg_vec_lock);
2817 : 0 : return err;
2818 : : }
2819 : :
2820 : 3 : static struct sk_buff *packet_alloc_skb(struct sock *sk, size_t prepad,
2821 : : size_t reserve, size_t len,
2822 : : size_t linear, int noblock,
2823 : : int *err)
2824 : : {
2825 : : struct sk_buff *skb;
2826 : :
2827 : : /* Under a page? Don't bother with paged skb. */
2828 : 3 : if (prepad + len < PAGE_SIZE || !linear)
2829 : : linear = len;
2830 : :
2831 : 3 : skb = sock_alloc_send_pskb(sk, prepad + linear, len - linear, noblock,
2832 : : err, 0);
2833 : 3 : if (!skb)
2834 : : return NULL;
2835 : :
2836 : : skb_reserve(skb, reserve);
2837 : 3 : skb_put(skb, linear);
2838 : 3 : skb->data_len = len - linear;
2839 : 3 : skb->len += len - linear;
2840 : :
2841 : 3 : return skb;
2842 : : }
2843 : :
2844 : 3 : static int packet_snd(struct socket *sock, struct msghdr *msg, size_t len)
2845 : : {
2846 : 3 : struct sock *sk = sock->sk;
2847 : 3 : DECLARE_SOCKADDR(struct sockaddr_ll *, saddr, msg->msg_name);
2848 : : struct sk_buff *skb;
2849 : : struct net_device *dev;
2850 : : __be16 proto;
2851 : : unsigned char *addr = NULL;
2852 : : int err, reserve = 0;
2853 : : struct sockcm_cookie sockc;
2854 : 3 : struct virtio_net_hdr vnet_hdr = { 0 };
2855 : : int offset = 0;
2856 : : struct packet_sock *po = pkt_sk(sk);
2857 : : bool has_vnet_hdr = false;
2858 : : int hlen, tlen, linear;
2859 : : int extra_len = 0;
2860 : :
2861 : : /*
2862 : : * Get and verify the address.
2863 : : */
2864 : :
2865 : 3 : if (likely(saddr == NULL)) {
2866 : : dev = packet_cached_dev_get(po);
2867 : 3 : proto = po->num;
2868 : : } else {
2869 : 0 : err = -EINVAL;
2870 : 0 : if (msg->msg_namelen < sizeof(struct sockaddr_ll))
2871 : : goto out;
2872 : 0 : if (msg->msg_namelen < (saddr->sll_halen + offsetof(struct sockaddr_ll, sll_addr)))
2873 : : goto out;
2874 : 0 : proto = saddr->sll_protocol;
2875 : 0 : dev = dev_get_by_index(sock_net(sk), saddr->sll_ifindex);
2876 : 0 : if (sock->type == SOCK_DGRAM) {
2877 : 0 : if (dev && msg->msg_namelen < dev->addr_len +
2878 : : offsetof(struct sockaddr_ll, sll_addr))
2879 : : goto out_unlock;
2880 : 0 : addr = saddr->sll_addr;
2881 : : }
2882 : : }
2883 : :
2884 : 3 : err = -ENXIO;
2885 : 3 : if (unlikely(dev == NULL))
2886 : : goto out_unlock;
2887 : 3 : err = -ENETDOWN;
2888 : 3 : if (unlikely(!(dev->flags & IFF_UP)))
2889 : : goto out_unlock;
2890 : :
2891 : : sockcm_init(&sockc, sk);
2892 : 3 : sockc.mark = sk->sk_mark;
2893 : 3 : if (msg->msg_controllen) {
2894 : 0 : err = sock_cmsg_send(sk, msg, &sockc);
2895 : 0 : if (unlikely(err))
2896 : : goto out_unlock;
2897 : : }
2898 : :
2899 : 3 : if (sock->type == SOCK_RAW)
2900 : 3 : reserve = dev->hard_header_len;
2901 : 3 : if (po->has_vnet_hdr) {
2902 : 0 : err = packet_snd_vnet_parse(msg, &len, &vnet_hdr);
2903 : 0 : if (err)
2904 : : goto out_unlock;
2905 : : has_vnet_hdr = true;
2906 : : }
2907 : :
2908 : 3 : if (unlikely(sock_flag(sk, SOCK_NOFCS))) {
2909 : 0 : if (!netif_supports_nofcs(dev)) {
2910 : 0 : err = -EPROTONOSUPPORT;
2911 : 0 : goto out_unlock;
2912 : : }
2913 : : extra_len = 4; /* We're doing our own CRC */
2914 : : }
2915 : :
2916 : 3 : err = -EMSGSIZE;
2917 : 3 : if (!vnet_hdr.gso_type &&
2918 : 3 : (len > dev->mtu + reserve + VLAN_HLEN + extra_len))
2919 : : goto out_unlock;
2920 : :
2921 : 3 : err = -ENOBUFS;
2922 : 3 : hlen = LL_RESERVED_SPACE(dev);
2923 : 3 : tlen = dev->needed_tailroom;
2924 : 3 : linear = __virtio16_to_cpu(vio_le(), vnet_hdr.hdr_len);
2925 : 3 : linear = max(linear, min_t(int, len, dev->hard_header_len));
2926 : 3 : skb = packet_alloc_skb(sk, hlen + tlen, hlen, len, linear,
2927 : 3 : msg->msg_flags & MSG_DONTWAIT, &err);
2928 : 3 : if (skb == NULL)
2929 : : goto out_unlock;
2930 : :
2931 : : skb_reset_network_header(skb);
2932 : :
2933 : 3 : err = -EINVAL;
2934 : 3 : if (sock->type == SOCK_DGRAM) {
2935 : 0 : offset = dev_hard_header(skb, dev, ntohs(proto), addr, NULL, len);
2936 : 0 : if (unlikely(offset < 0))
2937 : : goto out_free;
2938 : 3 : } else if (reserve) {
2939 : 3 : skb_reserve(skb, -reserve);
2940 : 3 : if (len < reserve + sizeof(struct ipv6hdr) &&
2941 : 3 : dev->min_header_len != dev->hard_header_len)
2942 : : skb_reset_network_header(skb);
2943 : : }
2944 : :
2945 : : /* Returns -EFAULT on error */
2946 : 3 : err = skb_copy_datagram_from_iter(skb, offset, &msg->msg_iter, len);
2947 : 3 : if (err)
2948 : : goto out_free;
2949 : :
2950 : 3 : if (sock->type == SOCK_RAW &&
2951 : 3 : !dev_validate_header(dev, skb->data, len)) {
2952 : 0 : err = -EINVAL;
2953 : 0 : goto out_free;
2954 : : }
2955 : :
2956 : 3 : skb_setup_tx_timestamp(skb, sockc.tsflags);
2957 : :
2958 : 3 : if (!vnet_hdr.gso_type && (len > dev->mtu + reserve + extra_len) &&
2959 : : !packet_extra_vlan_len_allowed(dev, skb)) {
2960 : 0 : err = -EMSGSIZE;
2961 : 0 : goto out_free;
2962 : : }
2963 : :
2964 : 3 : skb->protocol = proto;
2965 : 3 : skb->dev = dev;
2966 : 3 : skb->priority = sk->sk_priority;
2967 : 3 : skb->mark = sockc.mark;
2968 : 3 : skb->tstamp = sockc.transmit_time;
2969 : :
2970 : 3 : if (has_vnet_hdr) {
2971 : 0 : err = virtio_net_hdr_to_skb(skb, &vnet_hdr, vio_le());
2972 : 0 : if (err)
2973 : : goto out_free;
2974 : 0 : len += sizeof(vnet_hdr);
2975 : : virtio_net_hdr_set_proto(skb, &vnet_hdr);
2976 : : }
2977 : :
2978 : 3 : packet_parse_headers(skb, sock);
2979 : :
2980 : 3 : if (unlikely(extra_len == 4))
2981 : 0 : skb->no_fcs = 1;
2982 : :
2983 : 3 : err = po->xmit(skb);
2984 : 3 : if (err > 0 && (err = net_xmit_errno(err)) != 0)
2985 : : goto out_unlock;
2986 : :
2987 : 3 : dev_put(dev);
2988 : :
2989 : 3 : return len;
2990 : :
2991 : : out_free:
2992 : 0 : kfree_skb(skb);
2993 : : out_unlock:
2994 : 0 : if (dev)
2995 : 0 : dev_put(dev);
2996 : : out:
2997 : 0 : return err;
2998 : : }
2999 : :
3000 : 3 : static int packet_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
3001 : : {
3002 : 3 : struct sock *sk = sock->sk;
3003 : : struct packet_sock *po = pkt_sk(sk);
3004 : :
3005 : 3 : if (po->tx_ring.pg_vec)
3006 : 0 : return tpacket_snd(po, msg);
3007 : : else
3008 : 3 : return packet_snd(sock, msg, len);
3009 : : }
3010 : :
3011 : : /*
3012 : : * Close a PACKET socket. This is fairly simple. We immediately go
3013 : : * to 'closed' state and remove our protocol entry in the device list.
3014 : : */
3015 : :
3016 : 3 : static int packet_release(struct socket *sock)
3017 : : {
3018 : 3 : struct sock *sk = sock->sk;
3019 : : struct packet_sock *po;
3020 : : struct packet_fanout *f;
3021 : : struct net *net;
3022 : : union tpacket_req_u req_u;
3023 : :
3024 : 3 : if (!sk)
3025 : : return 0;
3026 : :
3027 : : net = sock_net(sk);
3028 : : po = pkt_sk(sk);
3029 : :
3030 : 3 : mutex_lock(&net->packet.sklist_lock);
3031 : 3 : sk_del_node_init_rcu(sk);
3032 : 3 : mutex_unlock(&net->packet.sklist_lock);
3033 : :
3034 : 3 : preempt_disable();
3035 : 3 : sock_prot_inuse_add(net, sk->sk_prot, -1);
3036 : 3 : preempt_enable();
3037 : :
3038 : : spin_lock(&po->bind_lock);
3039 : : unregister_prot_hook(sk, false);
3040 : : packet_cached_dev_reset(po);
3041 : :
3042 : 3 : if (po->prot_hook.dev) {
3043 : 3 : dev_put(po->prot_hook.dev);
3044 : 3 : po->prot_hook.dev = NULL;
3045 : : }
3046 : : spin_unlock(&po->bind_lock);
3047 : :
3048 : 3 : packet_flush_mclist(sk);
3049 : :
3050 : : lock_sock(sk);
3051 : 3 : if (po->rx_ring.pg_vec) {
3052 : 0 : memset(&req_u, 0, sizeof(req_u));
3053 : 0 : packet_set_ring(sk, &req_u, 1, 0);
3054 : : }
3055 : :
3056 : 3 : if (po->tx_ring.pg_vec) {
3057 : 0 : memset(&req_u, 0, sizeof(req_u));
3058 : 0 : packet_set_ring(sk, &req_u, 1, 1);
3059 : : }
3060 : 3 : release_sock(sk);
3061 : :
3062 : 3 : f = fanout_release(sk);
3063 : :
3064 : 3 : synchronize_net();
3065 : :
3066 : 3 : kfree(po->rollover);
3067 : 3 : if (f) {
3068 : 0 : fanout_release_data(f);
3069 : 0 : kfree(f);
3070 : : }
3071 : : /*
3072 : : * Now the socket is dead. No more input will appear.
3073 : : */
3074 : 3 : sock_orphan(sk);
3075 : 3 : sock->sk = NULL;
3076 : :
3077 : : /* Purge queues */
3078 : :
3079 : 3 : skb_queue_purge(&sk->sk_receive_queue);
3080 : : packet_free_pending(po);
3081 : : sk_refcnt_debug_release(sk);
3082 : :
3083 : 3 : sock_put(sk);
3084 : 3 : return 0;
3085 : : }
3086 : :
3087 : : /*
3088 : : * Attach a packet hook.
3089 : : */
3090 : :
3091 : 3 : static int packet_do_bind(struct sock *sk, const char *name, int ifindex,
3092 : : __be16 proto)
3093 : : {
3094 : : struct packet_sock *po = pkt_sk(sk);
3095 : : struct net_device *dev_curr;
3096 : : __be16 proto_curr;
3097 : : bool need_rehook;
3098 : : struct net_device *dev = NULL;
3099 : : int ret = 0;
3100 : : bool unlisted = false;
3101 : :
3102 : : lock_sock(sk);
3103 : : spin_lock(&po->bind_lock);
3104 : : rcu_read_lock();
3105 : :
3106 : 3 : if (po->fanout) {
3107 : : ret = -EINVAL;
3108 : : goto out_unlock;
3109 : : }
3110 : :
3111 : 3 : if (name) {
3112 : 0 : dev = dev_get_by_name_rcu(sock_net(sk), name);
3113 : 0 : if (!dev) {
3114 : : ret = -ENODEV;
3115 : : goto out_unlock;
3116 : : }
3117 : 3 : } else if (ifindex) {
3118 : 3 : dev = dev_get_by_index_rcu(sock_net(sk), ifindex);
3119 : 3 : if (!dev) {
3120 : : ret = -ENODEV;
3121 : : goto out_unlock;
3122 : : }
3123 : : }
3124 : :
3125 : 3 : if (dev)
3126 : 3 : dev_hold(dev);
3127 : :
3128 : 3 : proto_curr = po->prot_hook.type;
3129 : 3 : dev_curr = po->prot_hook.dev;
3130 : :
3131 : 3 : need_rehook = proto_curr != proto || dev_curr != dev;
3132 : :
3133 : 3 : if (need_rehook) {
3134 : 3 : if (po->running) {
3135 : : rcu_read_unlock();
3136 : : /* prevents packet_notifier() from calling
3137 : : * register_prot_hook()
3138 : : */
3139 : 3 : po->num = 0;
3140 : 3 : __unregister_prot_hook(sk, true);
3141 : : rcu_read_lock();
3142 : 3 : dev_curr = po->prot_hook.dev;
3143 : 3 : if (dev)
3144 : 3 : unlisted = !dev_get_by_index_rcu(sock_net(sk),
3145 : : dev->ifindex);
3146 : : }
3147 : :
3148 : 3 : BUG_ON(po->running);
3149 : 3 : po->num = proto;
3150 : 3 : po->prot_hook.type = proto;
3151 : :
3152 : 3 : if (unlikely(unlisted)) {
3153 : 0 : dev_put(dev);
3154 : 0 : po->prot_hook.dev = NULL;
3155 : 0 : po->ifindex = -1;
3156 : : packet_cached_dev_reset(po);
3157 : : } else {
3158 : 3 : po->prot_hook.dev = dev;
3159 : 3 : po->ifindex = dev ? dev->ifindex : 0;
3160 : : packet_cached_dev_assign(po, dev);
3161 : : }
3162 : : }
3163 : 3 : if (dev_curr)
3164 : 0 : dev_put(dev_curr);
3165 : :
3166 : 3 : if (proto == 0 || !need_rehook)
3167 : : goto out_unlock;
3168 : :
3169 : 3 : if (!unlisted && (!dev || (dev->flags & IFF_UP))) {
3170 : : register_prot_hook(sk);
3171 : : } else {
3172 : 0 : sk->sk_err = ENETDOWN;
3173 : 0 : if (!sock_flag(sk, SOCK_DEAD))
3174 : 0 : sk->sk_error_report(sk);
3175 : : }
3176 : :
3177 : : out_unlock:
3178 : : rcu_read_unlock();
3179 : : spin_unlock(&po->bind_lock);
3180 : 3 : release_sock(sk);
3181 : 3 : return ret;
3182 : : }
3183 : :
3184 : : /*
3185 : : * Bind a packet socket to a device
3186 : : */
3187 : :
3188 : 0 : static int packet_bind_spkt(struct socket *sock, struct sockaddr *uaddr,
3189 : : int addr_len)
3190 : : {
3191 : 0 : struct sock *sk = sock->sk;
3192 : : char name[sizeof(uaddr->sa_data) + 1];
3193 : :
3194 : : /*
3195 : : * Check legality
3196 : : */
3197 : :
3198 : 0 : if (addr_len != sizeof(struct sockaddr))
3199 : : return -EINVAL;
3200 : : /* uaddr->sa_data comes from the userspace, it's not guaranteed to be
3201 : : * zero-terminated.
3202 : : */
3203 : 0 : memcpy(name, uaddr->sa_data, sizeof(uaddr->sa_data));
3204 : 0 : name[sizeof(uaddr->sa_data)] = 0;
3205 : :
3206 : 0 : return packet_do_bind(sk, name, 0, pkt_sk(sk)->num);
3207 : : }
3208 : :
3209 : 3 : static int packet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
3210 : : {
3211 : : struct sockaddr_ll *sll = (struct sockaddr_ll *)uaddr;
3212 : 3 : struct sock *sk = sock->sk;
3213 : :
3214 : : /*
3215 : : * Check legality
3216 : : */
3217 : :
3218 : 3 : if (addr_len < sizeof(struct sockaddr_ll))
3219 : : return -EINVAL;
3220 : 3 : if (sll->sll_family != AF_PACKET)
3221 : : return -EINVAL;
3222 : :
3223 : 3 : return packet_do_bind(sk, NULL, sll->sll_ifindex,
3224 : 3 : sll->sll_protocol ? : pkt_sk(sk)->num);
3225 : : }
3226 : :
3227 : : static struct proto packet_proto = {
3228 : : .name = "PACKET",
3229 : : .owner = THIS_MODULE,
3230 : : .obj_size = sizeof(struct packet_sock),
3231 : : };
3232 : :
3233 : : /*
3234 : : * Create a packet of type SOCK_PACKET.
3235 : : */
3236 : :
3237 : 3 : static int packet_create(struct net *net, struct socket *sock, int protocol,
3238 : : int kern)
3239 : : {
3240 : : struct sock *sk;
3241 : : struct packet_sock *po;
3242 : 3 : __be16 proto = (__force __be16)protocol; /* weird, but documented */
3243 : : int err;
3244 : :
3245 : 3 : if (!ns_capable(net->user_ns, CAP_NET_RAW))
3246 : : return -EPERM;
3247 : 3 : if (sock->type != SOCK_DGRAM && sock->type != SOCK_RAW &&
3248 : : sock->type != SOCK_PACKET)
3249 : : return -ESOCKTNOSUPPORT;
3250 : :
3251 : 3 : sock->state = SS_UNCONNECTED;
3252 : :
3253 : : err = -ENOBUFS;
3254 : 3 : sk = sk_alloc(net, PF_PACKET, GFP_KERNEL, &packet_proto, kern);
3255 : 3 : if (sk == NULL)
3256 : : goto out;
3257 : :
3258 : 3 : sock->ops = &packet_ops;
3259 : 3 : if (sock->type == SOCK_PACKET)
3260 : 0 : sock->ops = &packet_ops_spkt;
3261 : :
3262 : 3 : sock_init_data(sock, sk);
3263 : :
3264 : : po = pkt_sk(sk);
3265 : : init_completion(&po->skb_completion);
3266 : 3 : sk->sk_family = PF_PACKET;
3267 : 3 : po->num = proto;
3268 : 3 : po->xmit = dev_queue_xmit;
3269 : :
3270 : : err = packet_alloc_pending(po);
3271 : 3 : if (err)
3272 : : goto out2;
3273 : :
3274 : : packet_cached_dev_reset(po);
3275 : :
3276 : 3 : sk->sk_destruct = packet_sock_destruct;
3277 : : sk_refcnt_debug_inc(sk);
3278 : :
3279 : : /*
3280 : : * Attach a protocol block
3281 : : */
3282 : :
3283 : 3 : spin_lock_init(&po->bind_lock);
3284 : 3 : mutex_init(&po->pg_vec_lock);
3285 : 3 : po->rollover = NULL;
3286 : 3 : po->prot_hook.func = packet_rcv;
3287 : :
3288 : 3 : if (sock->type == SOCK_PACKET)
3289 : 0 : po->prot_hook.func = packet_rcv_spkt;
3290 : :
3291 : 3 : po->prot_hook.af_packet_priv = sk;
3292 : :
3293 : 3 : if (proto) {
3294 : 3 : po->prot_hook.type = proto;
3295 : 3 : __register_prot_hook(sk);
3296 : : }
3297 : :
3298 : 3 : mutex_lock(&net->packet.sklist_lock);
3299 : 3 : sk_add_node_tail_rcu(sk, &net->packet.sklist);
3300 : 3 : mutex_unlock(&net->packet.sklist_lock);
3301 : :
3302 : 3 : preempt_disable();
3303 : 3 : sock_prot_inuse_add(net, &packet_proto, 1);
3304 : 3 : preempt_enable();
3305 : :
3306 : 3 : return 0;
3307 : : out2:
3308 : 0 : sk_free(sk);
3309 : : out:
3310 : 0 : return err;
3311 : : }
3312 : :
3313 : : /*
3314 : : * Pull a packet from our receive queue and hand it to the user.
3315 : : * If necessary we block.
3316 : : */
3317 : :
3318 : 3 : static int packet_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
3319 : : int flags)
3320 : : {
3321 : 3 : struct sock *sk = sock->sk;
3322 : : struct sk_buff *skb;
3323 : : int copied, err;
3324 : : int vnet_hdr_len = 0;
3325 : : unsigned int origlen = 0;
3326 : :
3327 : 3 : err = -EINVAL;
3328 : 3 : if (flags & ~(MSG_PEEK|MSG_DONTWAIT|MSG_TRUNC|MSG_CMSG_COMPAT|MSG_ERRQUEUE))
3329 : : goto out;
3330 : :
3331 : : #if 0
3332 : : /* What error should we return now? EUNATTACH? */
3333 : : if (pkt_sk(sk)->ifindex < 0)
3334 : : return -ENODEV;
3335 : : #endif
3336 : :
3337 : 3 : if (flags & MSG_ERRQUEUE) {
3338 : 0 : err = sock_recv_errqueue(sk, msg, len,
3339 : : SOL_PACKET, PACKET_TX_TIMESTAMP);
3340 : 0 : goto out;
3341 : : }
3342 : :
3343 : : /*
3344 : : * Call the generic datagram receiver. This handles all sorts
3345 : : * of horrible races and re-entrancy so we can forget about it
3346 : : * in the protocol layers.
3347 : : *
3348 : : * Now it will return ENETDOWN, if device have just gone down,
3349 : : * but then it will block.
3350 : : */
3351 : :
3352 : 3 : skb = skb_recv_datagram(sk, flags, flags & MSG_DONTWAIT, &err);
3353 : :
3354 : : /*
3355 : : * An error occurred so return it. Because skb_recv_datagram()
3356 : : * handles the blocking we don't see and worry about blocking
3357 : : * retries.
3358 : : */
3359 : :
3360 : 3 : if (skb == NULL)
3361 : : goto out;
3362 : :
3363 : 3 : packet_rcv_try_clear_pressure(pkt_sk(sk));
3364 : :
3365 : 3 : if (pkt_sk(sk)->has_vnet_hdr) {
3366 : 0 : err = packet_rcv_vnet(msg, skb, &len);
3367 : 0 : if (err)
3368 : : goto out_free;
3369 : : vnet_hdr_len = sizeof(struct virtio_net_hdr);
3370 : : }
3371 : :
3372 : : /* You lose any data beyond the buffer you gave. If it worries
3373 : : * a user program they can ask the device for its MTU
3374 : : * anyway.
3375 : : */
3376 : 3 : copied = skb->len;
3377 : 3 : if (copied > len) {
3378 : 0 : copied = len;
3379 : 0 : msg->msg_flags |= MSG_TRUNC;
3380 : : }
3381 : :
3382 : 3 : err = skb_copy_datagram_msg(skb, 0, msg, copied);
3383 : 3 : if (err)
3384 : : goto out_free;
3385 : :
3386 : 3 : if (sock->type != SOCK_PACKET) {
3387 : : struct sockaddr_ll *sll = &PACKET_SKB_CB(skb)->sa.ll;
3388 : :
3389 : : /* Original length was stored in sockaddr_ll fields */
3390 : 3 : origlen = PACKET_SKB_CB(skb)->sa.origlen;
3391 : 3 : sll->sll_family = AF_PACKET;
3392 : 3 : sll->sll_protocol = skb->protocol;
3393 : : }
3394 : :
3395 : 3 : sock_recv_ts_and_drops(msg, sk, skb);
3396 : :
3397 : 3 : if (msg->msg_name) {
3398 : : int copy_len;
3399 : :
3400 : : /* If the address length field is there to be filled
3401 : : * in, we fill it in now.
3402 : : */
3403 : 3 : if (sock->type == SOCK_PACKET) {
3404 : : __sockaddr_check_size(sizeof(struct sockaddr_pkt));
3405 : 0 : msg->msg_namelen = sizeof(struct sockaddr_pkt);
3406 : : copy_len = msg->msg_namelen;
3407 : : } else {
3408 : : struct sockaddr_ll *sll = &PACKET_SKB_CB(skb)->sa.ll;
3409 : :
3410 : 3 : msg->msg_namelen = sll->sll_halen +
3411 : : offsetof(struct sockaddr_ll, sll_addr);
3412 : : copy_len = msg->msg_namelen;
3413 : 3 : if (msg->msg_namelen < sizeof(struct sockaddr_ll)) {
3414 : 3 : memset(msg->msg_name +
3415 : : offsetof(struct sockaddr_ll, sll_addr),
3416 : : 0, sizeof(sll->sll_addr));
3417 : 3 : msg->msg_namelen = sizeof(struct sockaddr_ll);
3418 : : }
3419 : : }
3420 : 3 : memcpy(msg->msg_name, &PACKET_SKB_CB(skb)->sa, copy_len);
3421 : : }
3422 : :
3423 : 3 : if (pkt_sk(sk)->auxdata) {
3424 : : struct tpacket_auxdata aux;
3425 : :
3426 : 3 : aux.tp_status = TP_STATUS_USER;
3427 : 3 : if (skb->ip_summed == CHECKSUM_PARTIAL)
3428 : 0 : aux.tp_status |= TP_STATUS_CSUMNOTREADY;
3429 : 3 : else if (skb->pkt_type != PACKET_OUTGOING &&
3430 : 1 : (skb->ip_summed == CHECKSUM_COMPLETE ||
3431 : 1 : skb_csum_unnecessary(skb)))
3432 : 2 : aux.tp_status |= TP_STATUS_CSUM_VALID;
3433 : :
3434 : 3 : aux.tp_len = origlen;
3435 : 3 : aux.tp_snaplen = skb->len;
3436 : 3 : aux.tp_mac = 0;
3437 : 3 : aux.tp_net = skb_network_offset(skb);
3438 : 3 : if (skb_vlan_tag_present(skb)) {
3439 : 0 : aux.tp_vlan_tci = skb_vlan_tag_get(skb);
3440 : 0 : aux.tp_vlan_tpid = ntohs(skb->vlan_proto);
3441 : 0 : aux.tp_status |= TP_STATUS_VLAN_VALID | TP_STATUS_VLAN_TPID_VALID;
3442 : : } else {
3443 : 3 : aux.tp_vlan_tci = 0;
3444 : 3 : aux.tp_vlan_tpid = 0;
3445 : : }
3446 : 3 : put_cmsg(msg, SOL_PACKET, PACKET_AUXDATA, sizeof(aux), &aux);
3447 : : }
3448 : :
3449 : : /*
3450 : : * Free or return the buffer as appropriate. Again this
3451 : : * hides all the races and re-entrancy issues from us.
3452 : : */
3453 : 3 : err = vnet_hdr_len + ((flags&MSG_TRUNC) ? skb->len : copied);
3454 : :
3455 : : out_free:
3456 : 3 : skb_free_datagram(sk, skb);
3457 : : out:
3458 : 3 : return err;
3459 : : }
3460 : :
3461 : 0 : static int packet_getname_spkt(struct socket *sock, struct sockaddr *uaddr,
3462 : : int peer)
3463 : : {
3464 : : struct net_device *dev;
3465 : 0 : struct sock *sk = sock->sk;
3466 : :
3467 : 0 : if (peer)
3468 : : return -EOPNOTSUPP;
3469 : :
3470 : 0 : uaddr->sa_family = AF_PACKET;
3471 : 0 : memset(uaddr->sa_data, 0, sizeof(uaddr->sa_data));
3472 : : rcu_read_lock();
3473 : 0 : dev = dev_get_by_index_rcu(sock_net(sk), pkt_sk(sk)->ifindex);
3474 : 0 : if (dev)
3475 : 0 : strlcpy(uaddr->sa_data, dev->name, sizeof(uaddr->sa_data));
3476 : : rcu_read_unlock();
3477 : :
3478 : 0 : return sizeof(*uaddr);
3479 : : }
3480 : :
3481 : 0 : static int packet_getname(struct socket *sock, struct sockaddr *uaddr,
3482 : : int peer)
3483 : : {
3484 : : struct net_device *dev;
3485 : 0 : struct sock *sk = sock->sk;
3486 : : struct packet_sock *po = pkt_sk(sk);
3487 : : DECLARE_SOCKADDR(struct sockaddr_ll *, sll, uaddr);
3488 : :
3489 : 0 : if (peer)
3490 : : return -EOPNOTSUPP;
3491 : :
3492 : 0 : sll->sll_family = AF_PACKET;
3493 : 0 : sll->sll_ifindex = po->ifindex;
3494 : 0 : sll->sll_protocol = po->num;
3495 : 0 : sll->sll_pkttype = 0;
3496 : : rcu_read_lock();
3497 : 0 : dev = dev_get_by_index_rcu(sock_net(sk), po->ifindex);
3498 : 0 : if (dev) {
3499 : 0 : sll->sll_hatype = dev->type;
3500 : 0 : sll->sll_halen = dev->addr_len;
3501 : 0 : memcpy(sll->sll_addr, dev->dev_addr, dev->addr_len);
3502 : : } else {
3503 : 0 : sll->sll_hatype = 0; /* Bad: we have no ARPHRD_UNSPEC */
3504 : 0 : sll->sll_halen = 0;
3505 : : }
3506 : : rcu_read_unlock();
3507 : :
3508 : 0 : return offsetof(struct sockaddr_ll, sll_addr) + sll->sll_halen;
3509 : : }
3510 : :
3511 : 0 : static int packet_dev_mc(struct net_device *dev, struct packet_mclist *i,
3512 : : int what)
3513 : : {
3514 : 0 : switch (i->type) {
3515 : : case PACKET_MR_MULTICAST:
3516 : 0 : if (i->alen != dev->addr_len)
3517 : : return -EINVAL;
3518 : 0 : if (what > 0)
3519 : 0 : return dev_mc_add(dev, i->addr);
3520 : : else
3521 : 0 : return dev_mc_del(dev, i->addr);
3522 : : break;
3523 : : case PACKET_MR_PROMISC:
3524 : 0 : return dev_set_promiscuity(dev, what);
3525 : : case PACKET_MR_ALLMULTI:
3526 : 0 : return dev_set_allmulti(dev, what);
3527 : : case PACKET_MR_UNICAST:
3528 : 0 : if (i->alen != dev->addr_len)
3529 : : return -EINVAL;
3530 : 0 : if (what > 0)
3531 : 0 : return dev_uc_add(dev, i->addr);
3532 : : else
3533 : 0 : return dev_uc_del(dev, i->addr);
3534 : : break;
3535 : : default:
3536 : : break;
3537 : : }
3538 : : return 0;
3539 : : }
3540 : :
3541 : 0 : static void packet_dev_mclist_delete(struct net_device *dev,
3542 : : struct packet_mclist **mlp)
3543 : : {
3544 : : struct packet_mclist *ml;
3545 : :
3546 : 0 : while ((ml = *mlp) != NULL) {
3547 : 0 : if (ml->ifindex == dev->ifindex) {
3548 : 0 : packet_dev_mc(dev, ml, -1);
3549 : 0 : *mlp = ml->next;
3550 : 0 : kfree(ml);
3551 : : } else
3552 : 0 : mlp = &ml->next;
3553 : : }
3554 : 0 : }
3555 : :
3556 : 0 : static int packet_mc_add(struct sock *sk, struct packet_mreq_max *mreq)
3557 : : {
3558 : : struct packet_sock *po = pkt_sk(sk);
3559 : : struct packet_mclist *ml, *i;
3560 : : struct net_device *dev;
3561 : : int err;
3562 : :
3563 : 0 : rtnl_lock();
3564 : :
3565 : : err = -ENODEV;
3566 : 0 : dev = __dev_get_by_index(sock_net(sk), mreq->mr_ifindex);
3567 : 0 : if (!dev)
3568 : : goto done;
3569 : :
3570 : : err = -EINVAL;
3571 : 0 : if (mreq->mr_alen > dev->addr_len)
3572 : : goto done;
3573 : :
3574 : : err = -ENOBUFS;
3575 : : i = kmalloc(sizeof(*i), GFP_KERNEL);
3576 : 0 : if (i == NULL)
3577 : : goto done;
3578 : :
3579 : : err = 0;
3580 : 0 : for (ml = po->mclist; ml; ml = ml->next) {
3581 : 0 : if (ml->ifindex == mreq->mr_ifindex &&
3582 : 0 : ml->type == mreq->mr_type &&
3583 : 0 : ml->alen == mreq->mr_alen &&
3584 : 0 : memcmp(ml->addr, mreq->mr_address, ml->alen) == 0) {
3585 : 0 : ml->count++;
3586 : : /* Free the new element ... */
3587 : 0 : kfree(i);
3588 : 0 : goto done;
3589 : : }
3590 : : }
3591 : :
3592 : 0 : i->type = mreq->mr_type;
3593 : 0 : i->ifindex = mreq->mr_ifindex;
3594 : 0 : i->alen = mreq->mr_alen;
3595 : 0 : memcpy(i->addr, mreq->mr_address, i->alen);
3596 : 0 : memset(i->addr + i->alen, 0, sizeof(i->addr) - i->alen);
3597 : 0 : i->count = 1;
3598 : 0 : i->next = po->mclist;
3599 : 0 : po->mclist = i;
3600 : 0 : err = packet_dev_mc(dev, i, 1);
3601 : 0 : if (err) {
3602 : 0 : po->mclist = i->next;
3603 : 0 : kfree(i);
3604 : : }
3605 : :
3606 : : done:
3607 : 0 : rtnl_unlock();
3608 : 0 : return err;
3609 : : }
3610 : :
3611 : 0 : static int packet_mc_drop(struct sock *sk, struct packet_mreq_max *mreq)
3612 : : {
3613 : : struct packet_mclist *ml, **mlp;
3614 : :
3615 : 0 : rtnl_lock();
3616 : :
3617 : 0 : for (mlp = &pkt_sk(sk)->mclist; (ml = *mlp) != NULL; mlp = &ml->next) {
3618 : 0 : if (ml->ifindex == mreq->mr_ifindex &&
3619 : 0 : ml->type == mreq->mr_type &&
3620 : 0 : ml->alen == mreq->mr_alen &&
3621 : 0 : memcmp(ml->addr, mreq->mr_address, ml->alen) == 0) {
3622 : 0 : if (--ml->count == 0) {
3623 : : struct net_device *dev;
3624 : 0 : *mlp = ml->next;
3625 : 0 : dev = __dev_get_by_index(sock_net(sk), ml->ifindex);
3626 : 0 : if (dev)
3627 : 0 : packet_dev_mc(dev, ml, -1);
3628 : 0 : kfree(ml);
3629 : : }
3630 : : break;
3631 : : }
3632 : : }
3633 : 0 : rtnl_unlock();
3634 : 0 : return 0;
3635 : : }
3636 : :
3637 : 3 : static void packet_flush_mclist(struct sock *sk)
3638 : : {
3639 : : struct packet_sock *po = pkt_sk(sk);
3640 : : struct packet_mclist *ml;
3641 : :
3642 : 3 : if (!po->mclist)
3643 : 3 : return;
3644 : :
3645 : 0 : rtnl_lock();
3646 : 0 : while ((ml = po->mclist) != NULL) {
3647 : : struct net_device *dev;
3648 : :
3649 : 0 : po->mclist = ml->next;
3650 : 0 : dev = __dev_get_by_index(sock_net(sk), ml->ifindex);
3651 : 0 : if (dev != NULL)
3652 : 0 : packet_dev_mc(dev, ml, -1);
3653 : 0 : kfree(ml);
3654 : : }
3655 : 0 : rtnl_unlock();
3656 : : }
3657 : :
3658 : : static int
3659 : 3 : packet_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
3660 : : {
3661 : 3 : struct sock *sk = sock->sk;
3662 : : struct packet_sock *po = pkt_sk(sk);
3663 : : int ret;
3664 : :
3665 : 3 : if (level != SOL_PACKET)
3666 : : return -ENOPROTOOPT;
3667 : :
3668 : 3 : switch (optname) {
3669 : : case PACKET_ADD_MEMBERSHIP:
3670 : : case PACKET_DROP_MEMBERSHIP:
3671 : : {
3672 : : struct packet_mreq_max mreq;
3673 : 0 : int len = optlen;
3674 : 0 : memset(&mreq, 0, sizeof(mreq));
3675 : 0 : if (len < sizeof(struct packet_mreq))
3676 : : return -EINVAL;
3677 : 0 : if (len > sizeof(mreq))
3678 : : len = sizeof(mreq);
3679 : 0 : if (copy_from_user(&mreq, optval, len))
3680 : : return -EFAULT;
3681 : 0 : if (len < (mreq.mr_alen + offsetof(struct packet_mreq, mr_address)))
3682 : : return -EINVAL;
3683 : 0 : if (optname == PACKET_ADD_MEMBERSHIP)
3684 : 0 : ret = packet_mc_add(sk, &mreq);
3685 : : else
3686 : 0 : ret = packet_mc_drop(sk, &mreq);
3687 : 0 : return ret;
3688 : : }
3689 : :
3690 : : case PACKET_RX_RING:
3691 : : case PACKET_TX_RING:
3692 : : {
3693 : : union tpacket_req_u req_u;
3694 : : int len;
3695 : :
3696 : : lock_sock(sk);
3697 : 0 : switch (po->tp_version) {
3698 : : case TPACKET_V1:
3699 : : case TPACKET_V2:
3700 : : len = sizeof(req_u.req);
3701 : : break;
3702 : : case TPACKET_V3:
3703 : : default:
3704 : : len = sizeof(req_u.req3);
3705 : 0 : break;
3706 : : }
3707 : 0 : if (optlen < len) {
3708 : : ret = -EINVAL;
3709 : : } else {
3710 : 0 : if (copy_from_user(&req_u.req, optval, len))
3711 : : ret = -EFAULT;
3712 : : else
3713 : 0 : ret = packet_set_ring(sk, &req_u, 0,
3714 : : optname == PACKET_TX_RING);
3715 : : }
3716 : 0 : release_sock(sk);
3717 : : return ret;
3718 : : }
3719 : : case PACKET_COPY_THRESH:
3720 : : {
3721 : : int val;
3722 : :
3723 : 0 : if (optlen != sizeof(val))
3724 : : return -EINVAL;
3725 : 0 : if (copy_from_user(&val, optval, sizeof(val)))
3726 : : return -EFAULT;
3727 : :
3728 : 0 : pkt_sk(sk)->copy_thresh = val;
3729 : 0 : return 0;
3730 : : }
3731 : : case PACKET_VERSION:
3732 : : {
3733 : : int val;
3734 : :
3735 : 0 : if (optlen != sizeof(val))
3736 : : return -EINVAL;
3737 : 0 : if (copy_from_user(&val, optval, sizeof(val)))
3738 : : return -EFAULT;
3739 : 0 : switch (val) {
3740 : : case TPACKET_V1:
3741 : : case TPACKET_V2:
3742 : : case TPACKET_V3:
3743 : : break;
3744 : : default:
3745 : : return -EINVAL;
3746 : : }
3747 : : lock_sock(sk);
3748 : 0 : if (po->rx_ring.pg_vec || po->tx_ring.pg_vec) {
3749 : : ret = -EBUSY;
3750 : : } else {
3751 : 0 : po->tp_version = val;
3752 : : ret = 0;
3753 : : }
3754 : 0 : release_sock(sk);
3755 : 0 : return ret;
3756 : : }
3757 : : case PACKET_RESERVE:
3758 : : {
3759 : : unsigned int val;
3760 : :
3761 : 0 : if (optlen != sizeof(val))
3762 : : return -EINVAL;
3763 : 0 : if (copy_from_user(&val, optval, sizeof(val)))
3764 : : return -EFAULT;
3765 : 0 : if (val > INT_MAX)
3766 : : return -EINVAL;
3767 : : lock_sock(sk);
3768 : 0 : if (po->rx_ring.pg_vec || po->tx_ring.pg_vec) {
3769 : : ret = -EBUSY;
3770 : : } else {
3771 : 0 : po->tp_reserve = val;
3772 : : ret = 0;
3773 : : }
3774 : 0 : release_sock(sk);
3775 : 0 : return ret;
3776 : : }
3777 : : case PACKET_LOSS:
3778 : : {
3779 : : unsigned int val;
3780 : :
3781 : 0 : if (optlen != sizeof(val))
3782 : : return -EINVAL;
3783 : 0 : if (copy_from_user(&val, optval, sizeof(val)))
3784 : : return -EFAULT;
3785 : :
3786 : : lock_sock(sk);
3787 : 0 : if (po->rx_ring.pg_vec || po->tx_ring.pg_vec) {
3788 : : ret = -EBUSY;
3789 : : } else {
3790 : 0 : po->tp_loss = !!val;
3791 : : ret = 0;
3792 : : }
3793 : 0 : release_sock(sk);
3794 : 0 : return ret;
3795 : : }
3796 : : case PACKET_AUXDATA:
3797 : : {
3798 : : int val;
3799 : :
3800 : 3 : if (optlen < sizeof(val))
3801 : : return -EINVAL;
3802 : 3 : if (copy_from_user(&val, optval, sizeof(val)))
3803 : : return -EFAULT;
3804 : :
3805 : : lock_sock(sk);
3806 : 3 : po->auxdata = !!val;
3807 : 3 : release_sock(sk);
3808 : 3 : return 0;
3809 : : }
3810 : : case PACKET_ORIGDEV:
3811 : : {
3812 : : int val;
3813 : :
3814 : 0 : if (optlen < sizeof(val))
3815 : : return -EINVAL;
3816 : 0 : if (copy_from_user(&val, optval, sizeof(val)))
3817 : : return -EFAULT;
3818 : :
3819 : : lock_sock(sk);
3820 : 0 : po->origdev = !!val;
3821 : 0 : release_sock(sk);
3822 : 0 : return 0;
3823 : : }
3824 : : case PACKET_VNET_HDR:
3825 : : {
3826 : : int val;
3827 : :
3828 : 0 : if (sock->type != SOCK_RAW)
3829 : : return -EINVAL;
3830 : 0 : if (optlen < sizeof(val))
3831 : : return -EINVAL;
3832 : 0 : if (copy_from_user(&val, optval, sizeof(val)))
3833 : : return -EFAULT;
3834 : :
3835 : : lock_sock(sk);
3836 : 0 : if (po->rx_ring.pg_vec || po->tx_ring.pg_vec) {
3837 : : ret = -EBUSY;
3838 : : } else {
3839 : 0 : po->has_vnet_hdr = !!val;
3840 : : ret = 0;
3841 : : }
3842 : 0 : release_sock(sk);
3843 : 0 : return ret;
3844 : : }
3845 : : case PACKET_TIMESTAMP:
3846 : : {
3847 : : int val;
3848 : :
3849 : 0 : if (optlen != sizeof(val))
3850 : : return -EINVAL;
3851 : 0 : if (copy_from_user(&val, optval, sizeof(val)))
3852 : : return -EFAULT;
3853 : :
3854 : 0 : po->tp_tstamp = val;
3855 : 0 : return 0;
3856 : : }
3857 : : case PACKET_FANOUT:
3858 : : {
3859 : : int val;
3860 : :
3861 : 0 : if (optlen != sizeof(val))
3862 : : return -EINVAL;
3863 : 0 : if (copy_from_user(&val, optval, sizeof(val)))
3864 : : return -EFAULT;
3865 : :
3866 : 0 : return fanout_add(sk, val & 0xffff, val >> 16);
3867 : : }
3868 : : case PACKET_FANOUT_DATA:
3869 : : {
3870 : 0 : if (!po->fanout)
3871 : : return -EINVAL;
3872 : :
3873 : 0 : return fanout_set_data(po, optval, optlen);
3874 : : }
3875 : : case PACKET_IGNORE_OUTGOING:
3876 : : {
3877 : : int val;
3878 : :
3879 : 0 : if (optlen != sizeof(val))
3880 : : return -EINVAL;
3881 : 0 : if (copy_from_user(&val, optval, sizeof(val)))
3882 : : return -EFAULT;
3883 : 0 : if (val < 0 || val > 1)
3884 : : return -EINVAL;
3885 : :
3886 : 0 : po->prot_hook.ignore_outgoing = !!val;
3887 : 0 : return 0;
3888 : : }
3889 : : case PACKET_TX_HAS_OFF:
3890 : : {
3891 : : unsigned int val;
3892 : :
3893 : 0 : if (optlen != sizeof(val))
3894 : : return -EINVAL;
3895 : 0 : if (copy_from_user(&val, optval, sizeof(val)))
3896 : : return -EFAULT;
3897 : :
3898 : : lock_sock(sk);
3899 : 0 : if (po->rx_ring.pg_vec || po->tx_ring.pg_vec) {
3900 : : ret = -EBUSY;
3901 : : } else {
3902 : 0 : po->tp_tx_has_off = !!val;
3903 : : ret = 0;
3904 : : }
3905 : 0 : release_sock(sk);
3906 : 0 : return 0;
3907 : : }
3908 : : case PACKET_QDISC_BYPASS:
3909 : : {
3910 : : int val;
3911 : :
3912 : 0 : if (optlen != sizeof(val))
3913 : : return -EINVAL;
3914 : 0 : if (copy_from_user(&val, optval, sizeof(val)))
3915 : : return -EFAULT;
3916 : :
3917 : 0 : po->xmit = val ? packet_direct_xmit : dev_queue_xmit;
3918 : 0 : return 0;
3919 : : }
3920 : : default:
3921 : : return -ENOPROTOOPT;
3922 : : }
3923 : : }
3924 : :
3925 : 0 : static int packet_getsockopt(struct socket *sock, int level, int optname,
3926 : : char __user *optval, int __user *optlen)
3927 : : {
3928 : : int len;
3929 : : int val, lv = sizeof(val);
3930 : 0 : struct sock *sk = sock->sk;
3931 : : struct packet_sock *po = pkt_sk(sk);
3932 : : void *data = &val;
3933 : : union tpacket_stats_u st;
3934 : : struct tpacket_rollover_stats rstats;
3935 : : int drops;
3936 : :
3937 : 0 : if (level != SOL_PACKET)
3938 : : return -ENOPROTOOPT;
3939 : :
3940 : 0 : if (get_user(len, optlen))
3941 : : return -EFAULT;
3942 : :
3943 : 0 : if (len < 0)
3944 : : return -EINVAL;
3945 : :
3946 : 0 : switch (optname) {
3947 : : case PACKET_STATISTICS:
3948 : : spin_lock_bh(&sk->sk_receive_queue.lock);
3949 : 0 : memcpy(&st, &po->stats, sizeof(st));
3950 : 0 : memset(&po->stats, 0, sizeof(po->stats));
3951 : : spin_unlock_bh(&sk->sk_receive_queue.lock);
3952 : 0 : drops = atomic_xchg(&po->tp_drops, 0);
3953 : :
3954 : 0 : if (po->tp_version == TPACKET_V3) {
3955 : : lv = sizeof(struct tpacket_stats_v3);
3956 : 0 : st.stats3.tp_drops = drops;
3957 : 0 : st.stats3.tp_packets += drops;
3958 : : data = &st.stats3;
3959 : : } else {
3960 : : lv = sizeof(struct tpacket_stats);
3961 : 0 : st.stats1.tp_drops = drops;
3962 : 0 : st.stats1.tp_packets += drops;
3963 : : data = &st.stats1;
3964 : : }
3965 : :
3966 : : break;
3967 : : case PACKET_AUXDATA:
3968 : 0 : val = po->auxdata;
3969 : 0 : break;
3970 : : case PACKET_ORIGDEV:
3971 : 0 : val = po->origdev;
3972 : 0 : break;
3973 : : case PACKET_VNET_HDR:
3974 : 0 : val = po->has_vnet_hdr;
3975 : 0 : break;
3976 : : case PACKET_VERSION:
3977 : 0 : val = po->tp_version;
3978 : 0 : break;
3979 : : case PACKET_HDRLEN:
3980 : 0 : if (len > sizeof(int))
3981 : : len = sizeof(int);
3982 : 0 : if (len < sizeof(int))
3983 : : return -EINVAL;
3984 : 0 : if (copy_from_user(&val, optval, len))
3985 : : return -EFAULT;
3986 : 0 : switch (val) {
3987 : : case TPACKET_V1:
3988 : 0 : val = sizeof(struct tpacket_hdr);
3989 : 0 : break;
3990 : : case TPACKET_V2:
3991 : 0 : val = sizeof(struct tpacket2_hdr);
3992 : 0 : break;
3993 : : case TPACKET_V3:
3994 : 0 : val = sizeof(struct tpacket3_hdr);
3995 : 0 : break;
3996 : : default:
3997 : : return -EINVAL;
3998 : : }
3999 : : break;
4000 : : case PACKET_RESERVE:
4001 : 0 : val = po->tp_reserve;
4002 : 0 : break;
4003 : : case PACKET_LOSS:
4004 : 0 : val = po->tp_loss;
4005 : 0 : break;
4006 : : case PACKET_TIMESTAMP:
4007 : 0 : val = po->tp_tstamp;
4008 : 0 : break;
4009 : : case PACKET_FANOUT:
4010 : 0 : val = (po->fanout ?
4011 : 0 : ((u32)po->fanout->id |
4012 : 0 : ((u32)po->fanout->type << 16) |
4013 : 0 : ((u32)po->fanout->flags << 24)) :
4014 : : 0);
4015 : 0 : break;
4016 : : case PACKET_IGNORE_OUTGOING:
4017 : 0 : val = po->prot_hook.ignore_outgoing;
4018 : 0 : break;
4019 : : case PACKET_ROLLOVER_STATS:
4020 : 0 : if (!po->rollover)
4021 : : return -EINVAL;
4022 : 0 : rstats.tp_all = atomic_long_read(&po->rollover->num);
4023 : 0 : rstats.tp_huge = atomic_long_read(&po->rollover->num_huge);
4024 : 0 : rstats.tp_failed = atomic_long_read(&po->rollover->num_failed);
4025 : : data = &rstats;
4026 : : lv = sizeof(rstats);
4027 : 0 : break;
4028 : : case PACKET_TX_HAS_OFF:
4029 : 0 : val = po->tp_tx_has_off;
4030 : 0 : break;
4031 : : case PACKET_QDISC_BYPASS:
4032 : 0 : val = packet_use_direct_xmit(po);
4033 : 0 : break;
4034 : : default:
4035 : : return -ENOPROTOOPT;
4036 : : }
4037 : :
4038 : 0 : if (len > lv)
4039 : : len = lv;
4040 : 0 : if (put_user(len, optlen))
4041 : : return -EFAULT;
4042 : 0 : if (copy_to_user(optval, data, len))
4043 : : return -EFAULT;
4044 : 0 : return 0;
4045 : : }
4046 : :
4047 : :
4048 : : #ifdef CONFIG_COMPAT
4049 : : static int compat_packet_setsockopt(struct socket *sock, int level, int optname,
4050 : : char __user *optval, unsigned int optlen)
4051 : : {
4052 : : struct packet_sock *po = pkt_sk(sock->sk);
4053 : :
4054 : : if (level != SOL_PACKET)
4055 : : return -ENOPROTOOPT;
4056 : :
4057 : : if (optname == PACKET_FANOUT_DATA &&
4058 : : po->fanout && po->fanout->type == PACKET_FANOUT_CBPF) {
4059 : : optval = (char __user *)get_compat_bpf_fprog(optval);
4060 : : if (!optval)
4061 : : return -EFAULT;
4062 : : optlen = sizeof(struct sock_fprog);
4063 : : }
4064 : :
4065 : : return packet_setsockopt(sock, level, optname, optval, optlen);
4066 : : }
4067 : : #endif
4068 : :
4069 : 3 : static int packet_notifier(struct notifier_block *this,
4070 : : unsigned long msg, void *ptr)
4071 : : {
4072 : : struct sock *sk;
4073 : : struct net_device *dev = netdev_notifier_info_to_dev(ptr);
4074 : : struct net *net = dev_net(dev);
4075 : :
4076 : : rcu_read_lock();
4077 : 3 : sk_for_each_rcu(sk, &net->packet.sklist) {
4078 : : struct packet_sock *po = pkt_sk(sk);
4079 : :
4080 : 2 : switch (msg) {
4081 : : case NETDEV_UNREGISTER:
4082 : 0 : if (po->mclist)
4083 : 0 : packet_dev_mclist_delete(dev, &po->mclist);
4084 : : /* fallthrough */
4085 : :
4086 : : case NETDEV_DOWN:
4087 : 0 : if (dev->ifindex == po->ifindex) {
4088 : : spin_lock(&po->bind_lock);
4089 : 0 : if (po->running) {
4090 : 0 : __unregister_prot_hook(sk, false);
4091 : 0 : sk->sk_err = ENETDOWN;
4092 : 0 : if (!sock_flag(sk, SOCK_DEAD))
4093 : 0 : sk->sk_error_report(sk);
4094 : : }
4095 : 0 : if (msg == NETDEV_UNREGISTER) {
4096 : : packet_cached_dev_reset(po);
4097 : 0 : po->ifindex = -1;
4098 : 0 : if (po->prot_hook.dev)
4099 : 0 : dev_put(po->prot_hook.dev);
4100 : 0 : po->prot_hook.dev = NULL;
4101 : : }
4102 : : spin_unlock(&po->bind_lock);
4103 : : }
4104 : : break;
4105 : : case NETDEV_UP:
4106 : 0 : if (dev->ifindex == po->ifindex) {
4107 : : spin_lock(&po->bind_lock);
4108 : 0 : if (po->num)
4109 : : register_prot_hook(sk);
4110 : : spin_unlock(&po->bind_lock);
4111 : : }
4112 : : break;
4113 : : }
4114 : : }
4115 : : rcu_read_unlock();
4116 : 3 : return NOTIFY_DONE;
4117 : : }
4118 : :
4119 : :
4120 : 0 : static int packet_ioctl(struct socket *sock, unsigned int cmd,
4121 : : unsigned long arg)
4122 : : {
4123 : 0 : struct sock *sk = sock->sk;
4124 : :
4125 : 0 : switch (cmd) {
4126 : : case SIOCOUTQ:
4127 : : {
4128 : : int amount = sk_wmem_alloc_get(sk);
4129 : :
4130 : 0 : return put_user(amount, (int __user *)arg);
4131 : : }
4132 : : case SIOCINQ:
4133 : : {
4134 : : struct sk_buff *skb;
4135 : : int amount = 0;
4136 : :
4137 : : spin_lock_bh(&sk->sk_receive_queue.lock);
4138 : 0 : skb = skb_peek(&sk->sk_receive_queue);
4139 : 0 : if (skb)
4140 : 0 : amount = skb->len;
4141 : : spin_unlock_bh(&sk->sk_receive_queue.lock);
4142 : 0 : return put_user(amount, (int __user *)arg);
4143 : : }
4144 : : #ifdef CONFIG_INET
4145 : : case SIOCADDRT:
4146 : : case SIOCDELRT:
4147 : : case SIOCDARP:
4148 : : case SIOCGARP:
4149 : : case SIOCSARP:
4150 : : case SIOCGIFADDR:
4151 : : case SIOCSIFADDR:
4152 : : case SIOCGIFBRDADDR:
4153 : : case SIOCSIFBRDADDR:
4154 : : case SIOCGIFNETMASK:
4155 : : case SIOCSIFNETMASK:
4156 : : case SIOCGIFDSTADDR:
4157 : : case SIOCSIFDSTADDR:
4158 : : case SIOCSIFFLAGS:
4159 : 0 : return inet_dgram_ops.ioctl(sock, cmd, arg);
4160 : : #endif
4161 : :
4162 : : default:
4163 : : return -ENOIOCTLCMD;
4164 : : }
4165 : : return 0;
4166 : : }
4167 : :
4168 : 3 : static __poll_t packet_poll(struct file *file, struct socket *sock,
4169 : : poll_table *wait)
4170 : : {
4171 : 3 : struct sock *sk = sock->sk;
4172 : : struct packet_sock *po = pkt_sk(sk);
4173 : 3 : __poll_t mask = datagram_poll(file, sock, wait);
4174 : :
4175 : : spin_lock_bh(&sk->sk_receive_queue.lock);
4176 : 3 : if (po->rx_ring.pg_vec) {
4177 : 0 : if (!packet_previous_rx_frame(po, &po->rx_ring,
4178 : : TP_STATUS_KERNEL))
4179 : 0 : mask |= EPOLLIN | EPOLLRDNORM;
4180 : : }
4181 : 3 : packet_rcv_try_clear_pressure(po);
4182 : : spin_unlock_bh(&sk->sk_receive_queue.lock);
4183 : : spin_lock_bh(&sk->sk_write_queue.lock);
4184 : 3 : if (po->tx_ring.pg_vec) {
4185 : 0 : if (packet_current_frame(po, &po->tx_ring, TP_STATUS_AVAILABLE))
4186 : 0 : mask |= EPOLLOUT | EPOLLWRNORM;
4187 : : }
4188 : : spin_unlock_bh(&sk->sk_write_queue.lock);
4189 : 3 : return mask;
4190 : : }
4191 : :
4192 : :
4193 : : /* Dirty? Well, I still did not learn better way to account
4194 : : * for user mmaps.
4195 : : */
4196 : :
4197 : 0 : static void packet_mm_open(struct vm_area_struct *vma)
4198 : : {
4199 : 0 : struct file *file = vma->vm_file;
4200 : 0 : struct socket *sock = file->private_data;
4201 : 0 : struct sock *sk = sock->sk;
4202 : :
4203 : 0 : if (sk)
4204 : 0 : atomic_inc(&pkt_sk(sk)->mapped);
4205 : 0 : }
4206 : :
4207 : 0 : static void packet_mm_close(struct vm_area_struct *vma)
4208 : : {
4209 : 0 : struct file *file = vma->vm_file;
4210 : 0 : struct socket *sock = file->private_data;
4211 : 0 : struct sock *sk = sock->sk;
4212 : :
4213 : 0 : if (sk)
4214 : 0 : atomic_dec(&pkt_sk(sk)->mapped);
4215 : 0 : }
4216 : :
4217 : : static const struct vm_operations_struct packet_mmap_ops = {
4218 : : .open = packet_mm_open,
4219 : : .close = packet_mm_close,
4220 : : };
4221 : :
4222 : 0 : static void free_pg_vec(struct pgv *pg_vec, unsigned int order,
4223 : : unsigned int len)
4224 : : {
4225 : : int i;
4226 : :
4227 : 0 : for (i = 0; i < len; i++) {
4228 : 0 : if (likely(pg_vec[i].buffer)) {
4229 : 0 : if (is_vmalloc_addr(pg_vec[i].buffer))
4230 : 0 : vfree(pg_vec[i].buffer);
4231 : : else
4232 : 0 : free_pages((unsigned long)pg_vec[i].buffer,
4233 : : order);
4234 : 0 : pg_vec[i].buffer = NULL;
4235 : : }
4236 : : }
4237 : 0 : kfree(pg_vec);
4238 : 0 : }
4239 : :
4240 : 0 : static char *alloc_one_pg_vec_page(unsigned long order)
4241 : : {
4242 : : char *buffer;
4243 : : gfp_t gfp_flags = GFP_KERNEL | __GFP_COMP |
4244 : : __GFP_ZERO | __GFP_NOWARN | __GFP_NORETRY;
4245 : :
4246 : 0 : buffer = (char *) __get_free_pages(gfp_flags, order);
4247 : 0 : if (buffer)
4248 : : return buffer;
4249 : :
4250 : : /* __get_free_pages failed, fall back to vmalloc */
4251 : 0 : buffer = vzalloc(array_size((1 << order), PAGE_SIZE));
4252 : 0 : if (buffer)
4253 : : return buffer;
4254 : :
4255 : : /* vmalloc failed, lets dig into swap here */
4256 : : gfp_flags &= ~__GFP_NORETRY;
4257 : 0 : buffer = (char *) __get_free_pages(gfp_flags, order);
4258 : 0 : if (buffer)
4259 : 0 : return buffer;
4260 : :
4261 : : /* complete and utter failure */
4262 : : return NULL;
4263 : : }
4264 : :
4265 : 0 : static struct pgv *alloc_pg_vec(struct tpacket_req *req, int order)
4266 : : {
4267 : 0 : unsigned int block_nr = req->tp_block_nr;
4268 : : struct pgv *pg_vec;
4269 : : int i;
4270 : :
4271 : : pg_vec = kcalloc(block_nr, sizeof(struct pgv), GFP_KERNEL | __GFP_NOWARN);
4272 : 0 : if (unlikely(!pg_vec))
4273 : : goto out;
4274 : :
4275 : 0 : for (i = 0; i < block_nr; i++) {
4276 : 0 : pg_vec[i].buffer = alloc_one_pg_vec_page(order);
4277 : 0 : if (unlikely(!pg_vec[i].buffer))
4278 : : goto out_free_pgvec;
4279 : : }
4280 : :
4281 : : out:
4282 : 0 : return pg_vec;
4283 : :
4284 : : out_free_pgvec:
4285 : 0 : free_pg_vec(pg_vec, order, block_nr);
4286 : : pg_vec = NULL;
4287 : 0 : goto out;
4288 : : }
4289 : :
4290 : 0 : static int packet_set_ring(struct sock *sk, union tpacket_req_u *req_u,
4291 : : int closing, int tx_ring)
4292 : : {
4293 : : struct pgv *pg_vec = NULL;
4294 : : struct packet_sock *po = pkt_sk(sk);
4295 : : unsigned long *rx_owner_map = NULL;
4296 : : int was_running, order = 0;
4297 : : struct packet_ring_buffer *rb;
4298 : : struct sk_buff_head *rb_queue;
4299 : : __be16 num;
4300 : : int err = -EINVAL;
4301 : : /* Added to avoid minimal code churn */
4302 : 0 : struct tpacket_req *req = &req_u->req;
4303 : :
4304 : 0 : rb = tx_ring ? &po->tx_ring : &po->rx_ring;
4305 : 0 : rb_queue = tx_ring ? &sk->sk_write_queue : &sk->sk_receive_queue;
4306 : :
4307 : : err = -EBUSY;
4308 : 0 : if (!closing) {
4309 : 0 : if (atomic_read(&po->mapped))
4310 : : goto out;
4311 : 0 : if (packet_read_pending(rb))
4312 : : goto out;
4313 : : }
4314 : :
4315 : 0 : if (req->tp_block_nr) {
4316 : : unsigned int min_frame_size;
4317 : :
4318 : : /* Sanity tests and some calculations */
4319 : : err = -EBUSY;
4320 : 0 : if (unlikely(rb->pg_vec))
4321 : : goto out;
4322 : :
4323 : 0 : switch (po->tp_version) {
4324 : : case TPACKET_V1:
4325 : 0 : po->tp_hdrlen = TPACKET_HDRLEN;
4326 : 0 : break;
4327 : : case TPACKET_V2:
4328 : 0 : po->tp_hdrlen = TPACKET2_HDRLEN;
4329 : 0 : break;
4330 : : case TPACKET_V3:
4331 : 0 : po->tp_hdrlen = TPACKET3_HDRLEN;
4332 : 0 : break;
4333 : : }
4334 : :
4335 : : err = -EINVAL;
4336 : 0 : if (unlikely((int)req->tp_block_size <= 0))
4337 : : goto out;
4338 : 0 : if (unlikely(!PAGE_ALIGNED(req->tp_block_size)))
4339 : : goto out;
4340 : 0 : min_frame_size = po->tp_hdrlen + po->tp_reserve;
4341 : 0 : if (po->tp_version >= TPACKET_V3 &&
4342 : 0 : req->tp_block_size <
4343 : 0 : BLK_PLUS_PRIV((u64)req_u->req3.tp_sizeof_priv) + min_frame_size)
4344 : : goto out;
4345 : 0 : if (unlikely(req->tp_frame_size < min_frame_size))
4346 : : goto out;
4347 : 0 : if (unlikely(req->tp_frame_size & (TPACKET_ALIGNMENT - 1)))
4348 : : goto out;
4349 : :
4350 : 0 : rb->frames_per_block = req->tp_block_size / req->tp_frame_size;
4351 : 0 : if (unlikely(rb->frames_per_block == 0))
4352 : : goto out;
4353 : 0 : if (unlikely(rb->frames_per_block > UINT_MAX / req->tp_block_nr))
4354 : : goto out;
4355 : 0 : if (unlikely((rb->frames_per_block * req->tp_block_nr) !=
4356 : : req->tp_frame_nr))
4357 : : goto out;
4358 : :
4359 : : err = -ENOMEM;
4360 : 0 : order = get_order(req->tp_block_size);
4361 : 0 : pg_vec = alloc_pg_vec(req, order);
4362 : 0 : if (unlikely(!pg_vec))
4363 : : goto out;
4364 : 0 : switch (po->tp_version) {
4365 : : case TPACKET_V3:
4366 : : /* Block transmit is not supported yet */
4367 : 0 : if (!tx_ring) {
4368 : 0 : init_prb_bdqc(po, rb, pg_vec, req_u);
4369 : : } else {
4370 : : struct tpacket_req3 *req3 = &req_u->req3;
4371 : :
4372 : 0 : if (req3->tp_retire_blk_tov ||
4373 : 0 : req3->tp_sizeof_priv ||
4374 : 0 : req3->tp_feature_req_word) {
4375 : : err = -EINVAL;
4376 : : goto out_free_pg_vec;
4377 : : }
4378 : : }
4379 : : break;
4380 : : default:
4381 : 0 : if (!tx_ring) {
4382 : 0 : rx_owner_map = bitmap_alloc(req->tp_frame_nr,
4383 : : GFP_KERNEL | __GFP_NOWARN | __GFP_ZERO);
4384 : 0 : if (!rx_owner_map)
4385 : : goto out_free_pg_vec;
4386 : : }
4387 : : break;
4388 : : }
4389 : : }
4390 : : /* Done */
4391 : : else {
4392 : : err = -EINVAL;
4393 : 0 : if (unlikely(req->tp_frame_nr))
4394 : : goto out;
4395 : : }
4396 : :
4397 : :
4398 : : /* Detach socket from network */
4399 : : spin_lock(&po->bind_lock);
4400 : 0 : was_running = po->running;
4401 : 0 : num = po->num;
4402 : 0 : if (was_running) {
4403 : 0 : po->num = 0;
4404 : 0 : __unregister_prot_hook(sk, false);
4405 : : }
4406 : : spin_unlock(&po->bind_lock);
4407 : :
4408 : 0 : synchronize_net();
4409 : :
4410 : : err = -EBUSY;
4411 : 0 : mutex_lock(&po->pg_vec_lock);
4412 : 0 : if (closing || atomic_read(&po->mapped) == 0) {
4413 : : err = 0;
4414 : : spin_lock_bh(&rb_queue->lock);
4415 : 0 : swap(rb->pg_vec, pg_vec);
4416 : 0 : if (po->tp_version <= TPACKET_V2)
4417 : 0 : swap(rb->rx_owner_map, rx_owner_map);
4418 : 0 : rb->frame_max = (req->tp_frame_nr - 1);
4419 : 0 : rb->head = 0;
4420 : 0 : rb->frame_size = req->tp_frame_size;
4421 : : spin_unlock_bh(&rb_queue->lock);
4422 : :
4423 : 0 : swap(rb->pg_vec_order, order);
4424 : 0 : swap(rb->pg_vec_len, req->tp_block_nr);
4425 : :
4426 : 0 : rb->pg_vec_pages = req->tp_block_size/PAGE_SIZE;
4427 : 0 : po->prot_hook.func = (po->rx_ring.pg_vec) ?
4428 : 0 : tpacket_rcv : packet_rcv;
4429 : 0 : skb_queue_purge(rb_queue);
4430 : 0 : if (atomic_read(&po->mapped))
4431 : 0 : pr_err("packet_mmap: vma is busy: %d\n",
4432 : : atomic_read(&po->mapped));
4433 : : }
4434 : 0 : mutex_unlock(&po->pg_vec_lock);
4435 : :
4436 : : spin_lock(&po->bind_lock);
4437 : 0 : if (was_running) {
4438 : 0 : po->num = num;
4439 : : register_prot_hook(sk);
4440 : : }
4441 : : spin_unlock(&po->bind_lock);
4442 : 0 : if (pg_vec && (po->tp_version > TPACKET_V2)) {
4443 : : /* Because we don't support block-based V3 on tx-ring */
4444 : 0 : if (!tx_ring)
4445 : 0 : prb_shutdown_retire_blk_timer(po, rb_queue);
4446 : : }
4447 : :
4448 : : out_free_pg_vec:
4449 : 0 : bitmap_free(rx_owner_map);
4450 : 0 : if (pg_vec)
4451 : 0 : free_pg_vec(pg_vec, order, req->tp_block_nr);
4452 : : out:
4453 : 0 : return err;
4454 : : }
4455 : :
4456 : 0 : static int packet_mmap(struct file *file, struct socket *sock,
4457 : : struct vm_area_struct *vma)
4458 : : {
4459 : 0 : struct sock *sk = sock->sk;
4460 : : struct packet_sock *po = pkt_sk(sk);
4461 : : unsigned long size, expected_size;
4462 : : struct packet_ring_buffer *rb;
4463 : : unsigned long start;
4464 : : int err = -EINVAL;
4465 : : int i;
4466 : :
4467 : 0 : if (vma->vm_pgoff)
4468 : : return -EINVAL;
4469 : :
4470 : 0 : mutex_lock(&po->pg_vec_lock);
4471 : :
4472 : : expected_size = 0;
4473 : 0 : for (rb = &po->rx_ring; rb <= &po->tx_ring; rb++) {
4474 : 0 : if (rb->pg_vec) {
4475 : 0 : expected_size += rb->pg_vec_len
4476 : 0 : * rb->pg_vec_pages
4477 : 0 : * PAGE_SIZE;
4478 : : }
4479 : : }
4480 : :
4481 : 0 : if (expected_size == 0)
4482 : : goto out;
4483 : :
4484 : 0 : size = vma->vm_end - vma->vm_start;
4485 : 0 : if (size != expected_size)
4486 : : goto out;
4487 : :
4488 : : start = vma->vm_start;
4489 : 0 : for (rb = &po->rx_ring; rb <= &po->tx_ring; rb++) {
4490 : 0 : if (rb->pg_vec == NULL)
4491 : 0 : continue;
4492 : :
4493 : 0 : for (i = 0; i < rb->pg_vec_len; i++) {
4494 : : struct page *page;
4495 : 0 : void *kaddr = rb->pg_vec[i].buffer;
4496 : : int pg_num;
4497 : :
4498 : 0 : for (pg_num = 0; pg_num < rb->pg_vec_pages; pg_num++) {
4499 : 0 : page = pgv_to_page(kaddr);
4500 : 0 : err = vm_insert_page(vma, start, page);
4501 : 0 : if (unlikely(err))
4502 : : goto out;
4503 : 0 : start += PAGE_SIZE;
4504 : 0 : kaddr += PAGE_SIZE;
4505 : : }
4506 : : }
4507 : : }
4508 : :
4509 : 0 : atomic_inc(&po->mapped);
4510 : 0 : vma->vm_ops = &packet_mmap_ops;
4511 : : err = 0;
4512 : :
4513 : : out:
4514 : 0 : mutex_unlock(&po->pg_vec_lock);
4515 : 0 : return err;
4516 : : }
4517 : :
4518 : : static const struct proto_ops packet_ops_spkt = {
4519 : : .family = PF_PACKET,
4520 : : .owner = THIS_MODULE,
4521 : : .release = packet_release,
4522 : : .bind = packet_bind_spkt,
4523 : : .connect = sock_no_connect,
4524 : : .socketpair = sock_no_socketpair,
4525 : : .accept = sock_no_accept,
4526 : : .getname = packet_getname_spkt,
4527 : : .poll = datagram_poll,
4528 : : .ioctl = packet_ioctl,
4529 : : .gettstamp = sock_gettstamp,
4530 : : .listen = sock_no_listen,
4531 : : .shutdown = sock_no_shutdown,
4532 : : .setsockopt = sock_no_setsockopt,
4533 : : .getsockopt = sock_no_getsockopt,
4534 : : .sendmsg = packet_sendmsg_spkt,
4535 : : .recvmsg = packet_recvmsg,
4536 : : .mmap = sock_no_mmap,
4537 : : .sendpage = sock_no_sendpage,
4538 : : };
4539 : :
4540 : : static const struct proto_ops packet_ops = {
4541 : : .family = PF_PACKET,
4542 : : .owner = THIS_MODULE,
4543 : : .release = packet_release,
4544 : : .bind = packet_bind,
4545 : : .connect = sock_no_connect,
4546 : : .socketpair = sock_no_socketpair,
4547 : : .accept = sock_no_accept,
4548 : : .getname = packet_getname,
4549 : : .poll = packet_poll,
4550 : : .ioctl = packet_ioctl,
4551 : : .gettstamp = sock_gettstamp,
4552 : : .listen = sock_no_listen,
4553 : : .shutdown = sock_no_shutdown,
4554 : : .setsockopt = packet_setsockopt,
4555 : : .getsockopt = packet_getsockopt,
4556 : : #ifdef CONFIG_COMPAT
4557 : : .compat_setsockopt = compat_packet_setsockopt,
4558 : : #endif
4559 : : .sendmsg = packet_sendmsg,
4560 : : .recvmsg = packet_recvmsg,
4561 : : .mmap = packet_mmap,
4562 : : .sendpage = sock_no_sendpage,
4563 : : };
4564 : :
4565 : : static const struct net_proto_family packet_family_ops = {
4566 : : .family = PF_PACKET,
4567 : : .create = packet_create,
4568 : : .owner = THIS_MODULE,
4569 : : };
4570 : :
4571 : : static struct notifier_block packet_netdev_notifier = {
4572 : : .notifier_call = packet_notifier,
4573 : : };
4574 : :
4575 : : #ifdef CONFIG_PROC_FS
4576 : :
4577 : 0 : static void *packet_seq_start(struct seq_file *seq, loff_t *pos)
4578 : : __acquires(RCU)
4579 : : {
4580 : : struct net *net = seq_file_net(seq);
4581 : :
4582 : : rcu_read_lock();
4583 : 0 : return seq_hlist_start_head_rcu(&net->packet.sklist, *pos);
4584 : : }
4585 : :
4586 : 0 : static void *packet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
4587 : : {
4588 : : struct net *net = seq_file_net(seq);
4589 : 0 : return seq_hlist_next_rcu(v, &net->packet.sklist, pos);
4590 : : }
4591 : :
4592 : 0 : static void packet_seq_stop(struct seq_file *seq, void *v)
4593 : : __releases(RCU)
4594 : : {
4595 : : rcu_read_unlock();
4596 : 0 : }
4597 : :
4598 : 0 : static int packet_seq_show(struct seq_file *seq, void *v)
4599 : : {
4600 : 0 : if (v == SEQ_START_TOKEN)
4601 : 0 : seq_puts(seq, "sk RefCnt Type Proto Iface R Rmem User Inode\n");
4602 : : else {
4603 : : struct sock *s = sk_entry(v);
4604 : : const struct packet_sock *po = pkt_sk(s);
4605 : :
4606 : 0 : seq_printf(seq,
4607 : : "%pK %-6d %-4d %04x %-5d %1d %-6u %-6u %-6lu\n",
4608 : : s,
4609 : : refcount_read(&s->sk_refcnt),
4610 : 0 : s->sk_type,
4611 : 0 : ntohs(po->num),
4612 : : po->ifindex,
4613 : : po->running,
4614 : 0 : atomic_read(&s->sk_rmem_alloc),
4615 : : from_kuid_munged(seq_user_ns(seq), sock_i_uid(s)),
4616 : : sock_i_ino(s));
4617 : : }
4618 : :
4619 : 0 : return 0;
4620 : : }
4621 : :
4622 : : static const struct seq_operations packet_seq_ops = {
4623 : : .start = packet_seq_start,
4624 : : .next = packet_seq_next,
4625 : : .stop = packet_seq_stop,
4626 : : .show = packet_seq_show,
4627 : : };
4628 : : #endif
4629 : :
4630 : 3 : static int __net_init packet_net_init(struct net *net)
4631 : : {
4632 : 3 : mutex_init(&net->packet.sklist_lock);
4633 : 3 : INIT_HLIST_HEAD(&net->packet.sklist);
4634 : :
4635 : 3 : if (!proc_create_net("packet", 0, net->proc_net, &packet_seq_ops,
4636 : : sizeof(struct seq_net_private)))
4637 : : return -ENOMEM;
4638 : :
4639 : 3 : return 0;
4640 : : }
4641 : :
4642 : 1 : static void __net_exit packet_net_exit(struct net *net)
4643 : : {
4644 : 1 : remove_proc_entry("packet", net->proc_net);
4645 : 1 : WARN_ON_ONCE(!hlist_empty(&net->packet.sklist));
4646 : 1 : }
4647 : :
4648 : : static struct pernet_operations packet_net_ops = {
4649 : : .init = packet_net_init,
4650 : : .exit = packet_net_exit,
4651 : : };
4652 : :
4653 : :
4654 : 0 : static void __exit packet_exit(void)
4655 : : {
4656 : 0 : unregister_netdevice_notifier(&packet_netdev_notifier);
4657 : 0 : unregister_pernet_subsys(&packet_net_ops);
4658 : 0 : sock_unregister(PF_PACKET);
4659 : 0 : proto_unregister(&packet_proto);
4660 : 0 : }
4661 : :
4662 : 3 : static int __init packet_init(void)
4663 : : {
4664 : : int rc;
4665 : :
4666 : 3 : rc = proto_register(&packet_proto, 0);
4667 : 3 : if (rc)
4668 : : goto out;
4669 : 3 : rc = sock_register(&packet_family_ops);
4670 : 3 : if (rc)
4671 : : goto out_proto;
4672 : 3 : rc = register_pernet_subsys(&packet_net_ops);
4673 : 3 : if (rc)
4674 : : goto out_sock;
4675 : 3 : rc = register_netdevice_notifier(&packet_netdev_notifier);
4676 : 3 : if (rc)
4677 : : goto out_pernet;
4678 : :
4679 : : return 0;
4680 : :
4681 : : out_pernet:
4682 : 0 : unregister_pernet_subsys(&packet_net_ops);
4683 : : out_sock:
4684 : 0 : sock_unregister(PF_PACKET);
4685 : : out_proto:
4686 : 0 : proto_unregister(&packet_proto);
4687 : : out:
4688 : 0 : return rc;
4689 : : }
4690 : :
4691 : : module_init(packet_init);
4692 : : module_exit(packet_exit);
4693 : : MODULE_LICENSE("GPL");
4694 : : MODULE_ALIAS_NETPROTO(PF_PACKET);
|
