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(*last_cpu, cpu_online_mask); 128 if (cpu >= nr_cpu_ids) 129 cpu = cpumask_first(cpu_online_mask); 130 *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 */ 210