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