1 /*
2  * Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.
3  *
4  * This program is free software; you may redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; version 2 of the License.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
10  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
11  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
12  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
13  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
14  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
15  * SOFTWARE.
16  *
17  */
18 #include <linux/bitmap.h>
19 #include <linux/file.h>
20 #include <linux/module.h>
21 #include <linux/slab.h>
22 #include <net/inet_sock.h>
23 
24 #include "usnic_transport.h"
25 #include "usnic_log.h"
26 
27 /* ROCE */
28 static unsigned long *roce_bitmap;
29 static u16 roce_next_port = 1;
30 #define ROCE_BITMAP_SZ ((1 << (8 /*CHAR_BIT*/ * sizeof(u16)))/8 /*CHAR BIT*/)
31 static DEFINE_SPINLOCK(roce_bitmap_lock);
32 
33 const char *usnic_transport_to_str(enum usnic_transport_type type)
34 {
35 	switch (type) {
36 	case USNIC_TRANSPORT_UNKNOWN:
37 		return "Unknown";
38 	case USNIC_TRANSPORT_ROCE_CUSTOM:
39 		return "roce custom";
40 	case USNIC_TRANSPORT_IPV4_UDP:
41 		return "IPv4 UDP";
42 	case USNIC_TRANSPORT_MAX:
43 		return "Max?";
44 	default:
45 		return "Not known";
46 	}
47 }
48 
49 int usnic_transport_sock_to_str(char *buf, int buf_sz,
50 					struct socket *sock)
51 {
52 	int err;
53 	uint32_t addr;
54 	uint16_t port;
55 	int proto;
56 
57 	memset(buf, 0, buf_sz);
58 	err = usnic_transport_sock_get_addr(sock, &proto, &addr, &port);
59 	if (err)
60 		return 0;
61 
62 	return scnprintf(buf, buf_sz, "Proto:%u Addr:%pI4h Port:%hu",
63 			proto, &addr, port);
64 }
65 
66 /*
67  * reserve a port number.  if "0" specified, we will try to pick one
68  * starting at roce_next_port.  roce_next_port will take on the values
69  * 1..4096
70  */
71 u16 usnic_transport_rsrv_port(enum usnic_transport_type type, u16 port_num)
72 {
73 	if (type == USNIC_TRANSPORT_ROCE_CUSTOM) {
74 		spin_lock(&roce_bitmap_lock);
75 		if (!port_num) {
76 			port_num = bitmap_find_next_zero_area(roce_bitmap,
77 						ROCE_BITMAP_SZ,
78 						roce_next_port /* start */,
79 						1 /* nr */,
80 						0 /* align */);
81 			roce_next_port = (port_num & 4095) + 1;
82 		} else if (test_bit(port_num, roce_bitmap)) {
83 			usnic_err("Failed to allocate port for %s\n",
84 					usnic_transport_to_str(type));
85 			spin_unlock(&roce_bitmap_lock);
86 			goto out_fail;
87 		}
88 		bitmap_set(roce_bitmap, port_num, 1);
89 		spin_unlock(&roce_bitmap_lock);
90 	} else {
91 		usnic_err("Failed to allocate port - transport %s unsupported\n",
92 				usnic_transport_to_str(type));
93 		goto out_fail;
94 	}
95 
96 	usnic_dbg("Allocating port %hu for %s\n", port_num,
97 			usnic_transport_to_str(type));
98 	return port_num;
99 
100 out_fail:
101 	return 0;
102 }
103 
104 void usnic_transport_unrsrv_port(enum usnic_transport_type type, u16 port_num)
105 {
106 	if (type == USNIC_TRANSPORT_ROCE_CUSTOM) {
107 		spin_lock(&roce_bitmap_lock);
108 		if (!port_num) {
109 			usnic_err("Unreserved unvalid port num 0 for %s\n",
110 					usnic_transport_to_str(type));
111 			goto out_roce_custom;
112 		}
113 
114 		if (!test_bit(port_num, roce_bitmap)) {
115 			usnic_err("Unreserving invalid %hu for %s\n",
116 					port_num,
117 					usnic_transport_to_str(type));
118 			goto out_roce_custom;
119 		}
120 		bitmap_clear(roce_bitmap, port_num, 1);
121 		usnic_dbg("Freeing port %hu for %s\n", port_num,
122 				usnic_transport_to_str(type));
123 out_roce_custom:
124 		spin_unlock(&roce_bitmap_lock);
125 	} else {
126 		usnic_err("Freeing invalid port %hu for %d\n", port_num, type);
127 	}
128 }
129 
130 struct socket *usnic_transport_get_socket(int sock_fd)
131 {
132 	struct socket *sock;
133 	int err;
134 	char buf[25];
135 
136 	/* sockfd_lookup will internally do a fget */
137 	sock = sockfd_lookup(sock_fd, &err);
138 	if (!sock) {
139 		usnic_err("Unable to lookup socket for fd %d with err %d\n",
140 				sock_fd, err);
141 		return ERR_PTR(-ENOENT);
142 	}
143 
144 	usnic_transport_sock_to_str(buf, sizeof(buf), sock);
145 	usnic_dbg("Get sock %s\n", buf);
146 
147 	return sock;
148 }
149 
150 void usnic_transport_put_socket(struct socket *sock)
151 {
152 	char buf[100];
153 
154 	usnic_transport_sock_to_str(buf, sizeof(buf), sock);
155 	usnic_dbg("Put sock %s\n", buf);
156 	sockfd_put(sock);
157 }
158 
159 int usnic_transport_sock_get_addr(struct socket *sock, int *proto,
160 					uint32_t *addr, uint16_t *port)
161 {
162 	int len;
163 	int err;
164 	struct sockaddr_in sock_addr;
165 
166 	err = sock->ops->getname(sock,
167 				(struct sockaddr *)&sock_addr,
168 				&len, 0);
169 	if (err)
170 		return err;
171 
172 	if (sock_addr.sin_family != AF_INET)
173 		return -EINVAL;
174 
175 	if (proto)
176 		*proto = sock->sk->sk_protocol;
177 	if (port)
178 		*port = ntohs(((struct sockaddr_in *)&sock_addr)->sin_port);
179 	if (addr)
180 		*addr = ntohl(((struct sockaddr_in *)
181 					&sock_addr)->sin_addr.s_addr);
182 
183 	return 0;
184 }
185 
186 int usnic_transport_init(void)
187 {
188 	roce_bitmap = kzalloc(ROCE_BITMAP_SZ, GFP_KERNEL);
189 	if (!roce_bitmap) {
190 		usnic_err("Failed to allocate bit map");
191 		return -ENOMEM;
192 	}
193 
194 	/* Do not ever allocate bit 0, hence set it here */
195 	bitmap_set(roce_bitmap, 0, 1);
196 	return 0;
197 }
198 
199 void usnic_transport_fini(void)
200 {
201 	kfree(roce_bitmap);
202 }
203