1/*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2012 The FreeBSD Foundation
5 *
6 * This software was developed by Edward Tomasz Napierala under sponsorship
7 * from the FreeBSD Foundation.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 *    notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 *    notice, this list of conditions and the following disclaimer in the
16 *    documentation and/or other materials provided with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * SUCH DAMAGE.
29 *
30 */
31
32/*
33 * iSCSI Common Layer.  It's used by both the initiator and target to send
34 * and receive iSCSI PDUs.
35 */
36
37#include <sys/param.h>
38#include <sys/condvar.h>
39#include <sys/conf.h>
40#include <sys/lock.h>
41#include <sys/kernel.h>
42#include <sys/malloc.h>
43#include <sys/mutex.h>
44#include <sys/module.h>
45#include <sys/queue.h>
46#include <sys/sbuf.h>
47#include <sys/socket.h>
48#include <sys/sysctl.h>
49#include <sys/systm.h>
50#include <sys/sx.h>
51
52#include <dev/iscsi/icl.h>
53#include <icl_conn_if.h>
54
55struct icl_module {
56	TAILQ_ENTRY(icl_module)		im_next;
57	char				*im_name;
58	bool				im_iser;
59	int				im_priority;
60	int				(*im_limits)(struct icl_drv_limits *idl,
61					    int socket);
62	struct icl_conn			*(*im_new_conn)(const char *name,
63					    struct mtx *lock);
64};
65
66struct icl_softc {
67	struct sx			sc_lock;
68	TAILQ_HEAD(, icl_module)	sc_modules;
69};
70
71static int sysctl_kern_icl_offloads(SYSCTL_HANDLER_ARGS);
72static MALLOC_DEFINE(M_ICL, "icl", "iSCSI Common Layer");
73static struct icl_softc	*sc;
74
75SYSCTL_NODE(_kern, OID_AUTO, icl, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
76    "iSCSI Common Layer");
77int icl_debug = 1;
78SYSCTL_INT(_kern_icl, OID_AUTO, debug, CTLFLAG_RWTUN,
79    &icl_debug, 0, "Enable debug messages");
80SYSCTL_PROC(_kern_icl, OID_AUTO, offloads,
81    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
82    NULL, false, sysctl_kern_icl_offloads, "A",
83    "List of ICL modules");
84SYSCTL_PROC(_kern_icl, OID_AUTO, iser_offloads,
85    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
86    NULL, true, sysctl_kern_icl_offloads, "A",
87    "List of iSER ICL modules");
88
89static int
90sysctl_kern_icl_offloads(SYSCTL_HANDLER_ARGS)
91{
92	const struct icl_module *im;
93	struct sbuf sb;
94	bool iser = arg2;
95	int error;
96
97	sbuf_new(&sb, NULL, 256, SBUF_AUTOEXTEND | SBUF_INCLUDENUL);
98
99	sx_slock(&sc->sc_lock);
100	TAILQ_FOREACH(im, &sc->sc_modules, im_next) {
101		if (im->im_iser != iser)
102			continue;
103		if (im != TAILQ_FIRST(&sc->sc_modules))
104			sbuf_putc(&sb, ' ');
105		sbuf_printf(&sb, "%s", im->im_name);
106	}
107	sx_sunlock(&sc->sc_lock);
108
109	error = sbuf_finish(&sb);
110	if (error == 0)
111		error = SYSCTL_OUT(req, sbuf_data(&sb), sbuf_len(&sb));
112	sbuf_delete(&sb);
113	return (error);
114}
115
116static struct icl_module *
117icl_find(const char *name, bool iser, bool quiet)
118{
119	struct icl_module *im, *im_max;
120
121	sx_assert(&sc->sc_lock, SA_LOCKED);
122
123	/*
124	 * If the name was not specified, pick a module with highest
125	 * priority.
126	 */
127	if (name == NULL || name[0] == '\0') {
128		im_max = NULL;
129		TAILQ_FOREACH(im, &sc->sc_modules, im_next) {
130			if (im->im_iser != iser)
131				continue;
132			if (im_max == NULL ||
133			    im->im_priority > im_max->im_priority)
134				im_max = im;
135		}
136
137		if (iser && im_max == NULL && !quiet)
138			ICL_WARN("no iSER-capable offload found");
139
140		return (im_max);
141	}
142
143	TAILQ_FOREACH(im, &sc->sc_modules, im_next) {
144		if (strcasecmp(im->im_name, name) != 0)
145			continue;
146
147		if (!im->im_iser && iser && !quiet) {
148			ICL_WARN("offload \"%s\" is not iSER-capable", name);
149			return (NULL);
150		}
151		if (im->im_iser && !iser && !quiet) {
152			ICL_WARN("offload \"%s\" is iSER-only", name);
153			return (NULL);
154		}
155
156		return (im);
157	}
158
159	if (!quiet)
160		ICL_WARN("offload \"%s\" not found", name);
161
162	return (NULL);
163}
164
165struct icl_conn *
166icl_new_conn(const char *offload, bool iser, const char *name, struct mtx *lock)
167{
168	struct icl_module *im;
169	struct icl_conn *ic;
170
171	sx_slock(&sc->sc_lock);
172	im = icl_find(offload, iser, false);
173	if (im == NULL) {
174		sx_sunlock(&sc->sc_lock);
175		return (NULL);
176	}
177
178	ic = im->im_new_conn(name, lock);
179	sx_sunlock(&sc->sc_lock);
180
181	return (ic);
182}
183
184int
185icl_limits(const char *offload, bool iser, int socket,
186    struct icl_drv_limits *idl)
187{
188	struct icl_module *im;
189	int error;
190
191	bzero(idl, sizeof(*idl));
192	sx_slock(&sc->sc_lock);
193	im = icl_find(offload, iser, false);
194	if (im == NULL) {
195		sx_sunlock(&sc->sc_lock);
196		return (ENXIO);
197	}
198
199	error = im->im_limits(idl, socket);
200	sx_sunlock(&sc->sc_lock);
201
202	/*
203	 * Validate the limits provided by the driver against values allowed by
204	 * the iSCSI RFC.  0 means iscsid/ctld should pick a reasonable value.
205	 *
206	 * Note that max_send_dsl is an internal implementation detail and not
207	 * part of the RFC.
208	 */
209#define OUT_OF_RANGE(x, lo, hi) ((x) != 0 && ((x) < (lo) || (x) > (hi)))
210	if (error == 0 &&
211	    (OUT_OF_RANGE(idl->idl_max_recv_data_segment_length, 512, 16777215) ||
212	    OUT_OF_RANGE(idl->idl_max_send_data_segment_length, 512, 16777215) ||
213	    OUT_OF_RANGE(idl->idl_max_burst_length, 512, 16777215) ||
214	    OUT_OF_RANGE(idl->idl_first_burst_length, 512, 16777215))) {
215		error = EINVAL;
216	}
217#undef OUT_OF_RANGE
218
219	/*
220	 * If both first_burst and max_burst are provided then first_burst must
221	 * not exceed max_burst.
222	 */
223	if (error == 0 && idl->idl_first_burst_length > 0 &&
224	    idl->idl_max_burst_length > 0 &&
225	    idl->idl_first_burst_length > idl->idl_max_burst_length) {
226		error = EINVAL;
227	}
228
229	return (error);
230}
231
232int
233icl_register(const char *offload, bool iser, int priority,
234    int (*limits)(struct icl_drv_limits *, int),
235    struct icl_conn *(*new_conn)(const char *, struct mtx *))
236{
237	struct icl_module *im;
238
239	sx_xlock(&sc->sc_lock);
240	im = icl_find(offload, iser, true);
241	if (im != NULL) {
242		ICL_WARN("offload \"%s\" already registered", offload);
243		sx_xunlock(&sc->sc_lock);
244		return (EBUSY);
245	}
246
247	im = malloc(sizeof(*im), M_ICL, M_ZERO | M_WAITOK);
248	im->im_name = strdup(offload, M_ICL);
249	im->im_iser = iser;
250	im->im_priority = priority;
251	im->im_limits = limits;
252	im->im_new_conn = new_conn;
253
254	TAILQ_INSERT_HEAD(&sc->sc_modules, im, im_next);
255	sx_xunlock(&sc->sc_lock);
256
257	ICL_DEBUG("offload \"%s\" registered", offload);
258	return (0);
259}
260
261int
262icl_unregister(const char *offload, bool rdma)
263{
264	struct icl_module *im;
265
266	sx_xlock(&sc->sc_lock);
267	im = icl_find(offload, rdma, true);
268	if (im == NULL) {
269		ICL_WARN("offload \"%s\" not registered", offload);
270		sx_xunlock(&sc->sc_lock);
271		return (ENXIO);
272	}
273
274	TAILQ_REMOVE(&sc->sc_modules, im, im_next);
275	sx_xunlock(&sc->sc_lock);
276
277	free(im->im_name, M_ICL);
278	free(im, M_ICL);
279
280	ICL_DEBUG("offload \"%s\" unregistered", offload);
281	return (0);
282}
283
284static int
285icl_load(void)
286{
287
288	sc = malloc(sizeof(*sc), M_ICL, M_ZERO | M_WAITOK);
289	sx_init(&sc->sc_lock, "icl");
290	TAILQ_INIT(&sc->sc_modules);
291
292	return (0);
293}
294
295static int
296icl_unload(void)
297{
298
299	sx_slock(&sc->sc_lock);
300	KASSERT(TAILQ_EMPTY(&sc->sc_modules), ("still have modules"));
301	sx_sunlock(&sc->sc_lock);
302
303	sx_destroy(&sc->sc_lock);
304	free(sc, M_ICL);
305
306	return (0);
307}
308
309static int
310icl_modevent(module_t mod, int what, void *arg)
311{
312
313	switch (what) {
314	case MOD_LOAD:
315		return (icl_load());
316	case MOD_UNLOAD:
317		return (icl_unload());
318	default:
319		return (EINVAL);
320	}
321}
322
323moduledata_t icl_data = {
324	"icl",
325	icl_modevent,
326	0
327};
328
329DECLARE_MODULE(icl, icl_data, SI_SUB_DRIVERS, SI_ORDER_FIRST);
330MODULE_VERSION(icl, 1);
331