1/* SPDX-License-Identifier: GPL-2.0 */
  2/*
  3 * Copyright (C) 2015-2019 Jason A. Donenfeld <Jason@zx2c4.com>. All Rights Reserved.
  4 */
  5
  6#ifndef _WG_QUEUEING_H
  7#define _WG_QUEUEING_H
  8
  9#include "peer.h"
 10#include <linux/types.h>
 11#include <linux/skbuff.h>
 12#include <linux/ip.h>
 13#include <linux/ipv6.h>
 14#include <net/ip_tunnels.h>
 15
 16struct wg_device;
 17struct wg_peer;
 18struct multicore_worker;
 19struct crypt_queue;
 20struct prev_queue;
 21struct sk_buff;
 22
 23/* queueing.c APIs: */
 24int wg_packet_queue_init(struct crypt_queue *queue, work_func_t function,
 25			 unsigned int len);
 26void wg_packet_queue_free(struct crypt_queue *queue, bool purge);
 27struct multicore_worker __percpu *
 28wg_packet_percpu_multicore_worker_alloc(work_func_t function, void *ptr);
 29
 30/* receive.c APIs: */
 31void wg_packet_receive(struct wg_device *wg, struct sk_buff *skb);
 32void wg_packet_handshake_receive_worker(struct work_struct *work);
 33/* NAPI poll function: */
 34int wg_packet_rx_poll(struct napi_struct *napi, int budget);
 35/* Workqueue worker: */
 36void wg_packet_decrypt_worker(struct work_struct *work);
 37
 38/* send.c APIs: */
 39void wg_packet_send_queued_handshake_initiation(struct wg_peer *peer,
 40						bool is_retry);
 41void wg_packet_send_handshake_response(struct wg_peer *peer);
 42void wg_packet_send_handshake_cookie(struct wg_device *wg,
 43				     struct sk_buff *initiating_skb,
 44				     __le32 sender_index);
 45void wg_packet_send_keepalive(struct wg_peer *peer);
 46void wg_packet_purge_staged_packets(struct wg_peer *peer);
 47void wg_packet_send_staged_packets(struct wg_peer *peer);
 48/* Workqueue workers: */
 49void wg_packet_handshake_send_worker(struct work_struct *work);
 50void wg_packet_tx_worker(struct work_struct *work);
 51void wg_packet_encrypt_worker(struct work_struct *work);
 52
 53enum packet_state {
 54	PACKET_STATE_UNCRYPTED,
 55	PACKET_STATE_CRYPTED,
 56	PACKET_STATE_DEAD
 57};
 58
 59struct packet_cb {
 60	u64 nonce;
 61	struct noise_keypair *keypair;
 62	atomic_t state;
 63	u32 mtu;
 64	u8 ds;
 65};
 66
 67#define PACKET_CB(skb) ((struct packet_cb *)((skb)->cb))
 68#define PACKET_PEER(skb) (PACKET_CB(skb)->keypair->entry.peer)
 69
 70static inline bool wg_check_packet_protocol(struct sk_buff *skb)
 71{
 72	__be16 real_protocol = ip_tunnel_parse_protocol(skb);
 73	return real_protocol && skb->protocol == real_protocol;
 74}
 75
 76static inline void wg_reset_packet(struct sk_buff *skb, bool encapsulating)
 77{
 78	u8 l4_hash = skb->l4_hash;
 79	u8 sw_hash = skb->sw_hash;
 80	u32 hash = skb->hash;
 81	skb_scrub_packet(skb, true);
 82	memset(&skb->headers, 0, sizeof(skb->headers));
 83	if (encapsulating) {
 84		skb->l4_hash = l4_hash;
 85		skb->sw_hash = sw_hash;
 86		skb->hash = hash;
 87	}
 88	skb->queue_mapping = 0;
 89	skb->nohdr = 0;
 90	skb->peeked = 0;
 91	skb->mac_len = 0;
 92	skb->dev = NULL;
 93#ifdef CONFIG_NET_SCHED
 94	skb->tc_index = 0;
 95#endif
 96	skb_reset_redirect(skb);
 97	skb->hdr_len = skb_headroom(skb);
 98	skb_reset_mac_header(skb);
 99	skb_reset_network_header(skb);
100	skb_reset_transport_header(skb);
101	skb_probe_transport_header(skb);
102	skb_reset_inner_headers(skb);
103}
104
105static inline int wg_cpumask_choose_online(int *stored_cpu, unsigned int id)
106{
107	unsigned int cpu = *stored_cpu, cpu_index, i;
108
109	if (unlikely(cpu >= nr_cpu_ids ||
110		     !cpumask_test_cpu(cpu, cpu_online_mask))) {
111		cpu_index = id % cpumask_weight(cpu_online_mask);
112		cpu = cpumask_first(cpu_online_mask);
113		for (i = 0; i < cpu_index; ++i)
114			cpu = cpumask_next(cpu, cpu_online_mask);
115		*stored_cpu = cpu;
116	}
117	return cpu;
118}
119
120/* This function is racy, in the sense that it's called while last_cpu is
121 * unlocked, so it could return the same CPU twice. Adding locking or using
122 * atomic sequence numbers is slower though, and the consequences of racing are
123 * harmless, so live with it.
124 */
125static inline int wg_cpumask_next_online(int *last_cpu)
126{
127	int cpu = cpumask_next(READ_ONCE(*last_cpu), cpu_online_mask);
128	if (cpu >= nr_cpu_ids)
129		cpu = cpumask_first(cpu_online_mask);
130	WRITE_ONCE(*last_cpu, cpu);
131	return cpu;
132}
133
134void wg_prev_queue_init(struct prev_queue *queue);
135
136/* Multi producer */
137bool wg_prev_queue_enqueue(struct prev_queue *queue, struct sk_buff *skb);
138
139/* Single consumer */
140struct sk_buff *wg_prev_queue_dequeue(struct prev_queue *queue);
141
142/* Single consumer */
143static inline struct sk_buff *wg_prev_queue_peek(struct prev_queue *queue)
144{
145	if (queue->peeked)
146		return queue->peeked;
147	queue->peeked = wg_prev_queue_dequeue(queue);
148	return queue->peeked;
149}
150
151/* Single consumer */
152static inline void wg_prev_queue_drop_peeked(struct prev_queue *queue)
153{
154	queue->peeked = NULL;
155}
156
157static inline int wg_queue_enqueue_per_device_and_peer(
158	struct crypt_queue *device_queue, struct prev_queue *peer_queue,
159	struct sk_buff *skb, struct workqueue_struct *wq)
160{
161	int cpu;
162
163	atomic_set_release(&PACKET_CB(skb)->state, PACKET_STATE_UNCRYPTED);
164	/* We first queue this up for the peer ingestion, but the consumer
165	 * will wait for the state to change to CRYPTED or DEAD before.
166	 */
167	if (unlikely(!wg_prev_queue_enqueue(peer_queue, skb)))
168		return -ENOSPC;
169
170	/* Then we queue it up in the device queue, which consumes the
171	 * packet as soon as it can.
172	 */
173	cpu = wg_cpumask_next_online(&device_queue->last_cpu);
174	if (unlikely(ptr_ring_produce_bh(&device_queue->ring, skb)))
175		return -EPIPE;
176	queue_work_on(cpu, wq, &per_cpu_ptr(device_queue->worker, cpu)->work);
177	return 0;
178}
179
180static inline void wg_queue_enqueue_per_peer_tx(struct sk_buff *skb, enum packet_state state)
181{
182	/* We take a reference, because as soon as we call atomic_set, the
183	 * peer can be freed from below us.
184	 */
185	struct wg_peer *peer = wg_peer_get(PACKET_PEER(skb));
186
187	atomic_set_release(&PACKET_CB(skb)->state, state);
188	queue_work_on(wg_cpumask_choose_online(&peer->serial_work_cpu, peer->internal_id),
189		      peer->device->packet_crypt_wq, &peer->transmit_packet_work);
190	wg_peer_put(peer);
191}
192
193static inline void wg_queue_enqueue_per_peer_rx(struct sk_buff *skb, enum packet_state state)
194{
195	/* We take a reference, because as soon as we call atomic_set, the
196	 * peer can be freed from below us.
197	 */
198	struct wg_peer *peer = wg_peer_get(PACKET_PEER(skb));
199
200	atomic_set_release(&PACKET_CB(skb)->state, state);
201	napi_schedule(&peer->napi);
202	wg_peer_put(peer);
203}
204
205#ifdef DEBUG
206bool wg_packet_counter_selftest(void);
207#endif
208
209#endif /* _WG_QUEUEING_H */