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(module: 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(lock: &tcp_ulp_list_lock); |
64 | if (tcp_ulp_find(name: ulp->name)) |
65 | ret = -EEXIST; |
66 | else |
67 | list_add_tail_rcu(new: &ulp->list, head: &tcp_ulp_list); |
68 | spin_unlock(lock: &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(lock: &tcp_ulp_list_lock); |
77 | list_del_rcu(entry: &ulp->list); |
78 | spin_unlock(lock: &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: buf + offs, size: maxlen - offs, |
94 | fmt: "%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->update) |
109 | icsk->icsk_ulp_ops->update(sk, proto, write_space); |
110 | } |
111 | |
112 | void tcp_cleanup_ulp(struct sock *sk) |
113 | { |
114 | struct inet_connection_sock *icsk = inet_csk(sk); |
115 | |
116 | /* No sock_owned_by_me() check here as at the time the |
117 | * stack calls this function, the socket is dead and |
118 | * about to be destroyed. |
119 | */ |
120 | if (!icsk->icsk_ulp_ops) |
121 | return; |
122 | |
123 | if (icsk->icsk_ulp_ops->release) |
124 | icsk->icsk_ulp_ops->release(sk); |
125 | module_put(module: icsk->icsk_ulp_ops->owner); |
126 | |
127 | icsk->icsk_ulp_ops = NULL; |
128 | } |
129 | |
130 | static int __tcp_set_ulp(struct sock *sk, const struct tcp_ulp_ops *ulp_ops) |
131 | { |
132 | struct inet_connection_sock *icsk = inet_csk(sk); |
133 | int err; |
134 | |
135 | err = -EEXIST; |
136 | if (icsk->icsk_ulp_ops) |
137 | goto out_err; |
138 | |
139 | if (sk->sk_socket) |
140 | clear_bit(SOCK_SUPPORT_ZC, addr: &sk->sk_socket->flags); |
141 | |
142 | err = -ENOTCONN; |
143 | if (!ulp_ops->clone && sk->sk_state == TCP_LISTEN) |
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(module: 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 | |