1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Pluggable TCP upper layer protocol support. 4 * 5 * Copyright (c) 2016-2017, Mellanox Technologies. All rights reserved. 6 * Copyright (c) 2016-2017, Dave Watson <davejwatson@fb.com>. All rights reserved. 7 * 8 */ 9 10 #include <linux/module.h> 11 #include <linux/mm.h> 12 #include <linux/types.h> 13 #include <linux/list.h> 14 #include <linux/gfp.h> 15 #include <net/tcp.h> 16 17 static DEFINE_SPINLOCK(tcp_ulp_list_lock); 18 static LIST_HEAD(tcp_ulp_list); 19 20 /* Simple linear search, don't expect many entries! */ 21 static struct tcp_ulp_ops *tcp_ulp_find(const char *name) 22 { 23 struct tcp_ulp_ops *e; 24 25 list_for_each_entry_rcu(e, &tcp_ulp_list, list, 26 lockdep_is_held(&tcp_ulp_list_lock)) { 27 if (strcmp(e->name, name) == 0) 28 return e; 29 } 30 31 return NULL; 32 } 33 34 static const struct tcp_ulp_ops *__tcp_ulp_find_autoload(const char *name) 35 { 36 const struct tcp_ulp_ops *ulp = NULL; 37 38 rcu_read_lock(); 39 ulp = tcp_ulp_find(name); 40 41 #ifdef CONFIG_MODULES 42 if (!ulp && capable(CAP_NET_ADMIN)) { 43 rcu_read_unlock(); 44 request_module("tcp-ulp-%s", name); 45 rcu_read_lock(); 46 ulp = tcp_ulp_find(name); 47 } 48 #endif 49 if (!ulp || !try_module_get(ulp->owner)) 50 ulp = NULL; 51 52 rcu_read_unlock(); 53 return ulp; 54 } 55 56 /* Attach new upper layer protocol to the list 57 * of available protocols. 58 */ 59 int tcp_register_ulp(struct tcp_ulp_ops *ulp) 60 { 61 int ret = 0; 62 63 spin_lock(&tcp_ulp_list_lock); 64 if (tcp_ulp_find(ulp->name)) 65 ret = -EEXIST; 66 else 67 list_add_tail_rcu(&ulp->list, &tcp_ulp_list); 68 spin_unlock(&tcp_ulp_list_lock); 69 70 return ret; 71 } 72 EXPORT_SYMBOL_GPL(tcp_register_ulp); 73 74 void tcp_unregister_ulp(struct tcp_ulp_ops *ulp) 75 { 76 spin_lock(&tcp_ulp_list_lock); 77 list_del_rcu(&ulp->list); 78 spin_unlock(&tcp_ulp_list_lock); 79 80 synchronize_rcu(); 81 } 82 EXPORT_SYMBOL_GPL(tcp_unregister_ulp); 83 84 /* Build string with list of available upper layer protocl values */ 85 void tcp_get_available_ulp(char *buf, size_t maxlen) 86 { 87 struct tcp_ulp_ops *ulp_ops; 88 size_t offs = 0; 89 90 *buf = '\0'; 91 rcu_read_lock(); 92 list_for_each_entry_rcu(ulp_ops, &tcp_ulp_list, list) { 93 offs += snprintf(buf + offs, maxlen - offs, 94 "%s%s", 95 offs == 0 ? "" : " ", ulp_ops->name); 96 97 if (WARN_ON_ONCE(offs >= maxlen)) 98 break; 99 } 100 rcu_read_unlock(); 101 } 102 103 void tcp_update_ulp(struct sock *sk, struct proto *proto, 104 void (*write_space)(struct sock *sk)) 105 { 106 struct inet_connection_sock *icsk = inet_csk(sk); 107 108 if (!icsk->icsk_ulp_ops) { 109 sk->sk_write_space = write_space; 110 /* Pairs with lockless read in sk_clone_lock() */ 111 WRITE_ONCE(sk->sk_prot, proto); 112 return; 113 } 114 115 if (icsk->icsk_ulp_ops->update) 116 icsk->icsk_ulp_ops->update(sk, proto, write_space); 117 } 118 119 void tcp_cleanup_ulp(struct sock *sk) 120 { 121 struct inet_connection_sock *icsk = inet_csk(sk); 122 123 /* No sock_owned_by_me() check here as at the time the 124 * stack calls this function, the socket is dead and 125 * about to be destroyed. 126 */ 127 if (!icsk->icsk_ulp_ops) 128 return; 129 130 if (icsk->icsk_ulp_ops->release) 131 icsk->icsk_ulp_ops->release(sk); 132 module_put(icsk->icsk_ulp_ops->owner); 133 134 icsk->icsk_ulp_ops = NULL; 135 } 136 137 static int __tcp_set_ulp(struct sock *sk, const struct tcp_ulp_ops *ulp_ops) 138 { 139 struct inet_connection_sock *icsk = inet_csk(sk); 140 int err; 141 142 err = -EEXIST; 143 if (icsk->icsk_ulp_ops) 144 goto out_err; 145 146 err = ulp_ops->init(sk); 147 if (err) 148 goto out_err; 149 150 icsk->icsk_ulp_ops = ulp_ops; 151 return 0; 152 out_err: 153 module_put(ulp_ops->owner); 154 return err; 155 } 156 157 int tcp_set_ulp(struct sock *sk, const char *name) 158 { 159 const struct tcp_ulp_ops *ulp_ops; 160 161 sock_owned_by_me(sk); 162 163 ulp_ops = __tcp_ulp_find_autoload(name); 164 if (!ulp_ops) 165 return -ENOENT; 166 167 return __tcp_set_ulp(sk, ulp_ops); 168 } 169