projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'for-3.10' of git://linux-nfs.org/~bfields/linux
[linux-2.6-block.git] / drivers / scsi / scsi_transport_iscsi.c
CommitLineData
0896b752 1/*
1da177e4
LT		 2 * iSCSI transport class definitions
3 *
4 * Copyright (C) IBM Corporation, 2004
0896b752
AA		 5 * Copyright (C) Mike Christie, 2004 - 2005
6 * Copyright (C) Dmitry Yusupov, 2004 - 2005
7 * Copyright (C) Alex Aizman, 2004 - 2005
1da177e4
LT		 8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 */
23#include <linux/module.h>
0b950672 24#include <linux/mutex.h>
5a0e3ad6 25#include <linux/slab.h>
90eeb01a 26#include <linux/bsg-lib.h>
8d4a690c 27#include <linux/idr.h>
c6a4bb2e 28#include <linux/list.h>
0896b752 29#include <net/tcp.h>
1da177e4
LT		 30#include <scsi/scsi.h>
31#include <scsi/scsi_host.h>
32#include <scsi/scsi_device.h>
33#include <scsi/scsi_transport.h>
34#include <scsi/scsi_transport_iscsi.h>
0896b752 35#include <scsi/iscsi_if.h>
c01be6dc 36#include <scsi/scsi_cmnd.h>
90eeb01a 37#include <scsi/scsi_bsg_iscsi.h>
1da177e4 38
4c2133c8 39#define ISCSI_TRANSPORT_VERSION "2.0-870"
1da177e4 40
632248aa
MC		 41static int dbg_session;
42module_param_named(debug_session, dbg_session, int,
43 S_IRUGO | S_IWUSR);
44MODULE_PARM_DESC(debug_session,
45 "Turn on debugging for sessions in scsi_transport_iscsi "
46 "module. Set to 1 to turn on, and zero to turn off. Default "
47 "is off.");
48
49static int dbg_conn;
50module_param_named(debug_conn, dbg_conn, int,
51 S_IRUGO | S_IWUSR);
52MODULE_PARM_DESC(debug_conn,
53 "Turn on debugging for connections in scsi_transport_iscsi "
54 "module. Set to 1 to turn on, and zero to turn off. Default "
55 "is off.");
56
57#define ISCSI_DBG_TRANS_SESSION(_session, dbg_fmt, arg...) \
58 do { \
59 if (dbg_session) \
60 iscsi_cls_session_printk(KERN_INFO, _session, \
61 "%s: " dbg_fmt, \
62 __func__, ##arg); \
63 } while (0);
64
65#define ISCSI_DBG_TRANS_CONN(_conn, dbg_fmt, arg...) \
66 do { \
67 if (dbg_conn) \
68 iscsi_cls_conn_printk(KERN_INFO, _conn, \
69 "%s: " dbg_fmt, \
70 __func__, ##arg); \
71 } while (0);
72
1da177e4
LT		 73struct iscsi_internal {
74 struct scsi_transport_template t;
0896b752
AA		 75 struct iscsi_transport *iscsi_transport;
76 struct list_head list;
ee959b00 77 struct device dev;
30a6c652 78
0896b752 79 struct transport_container conn_cont;
0896b752 80 struct transport_container session_cont;
1da177e4
LT		 81};
82
41be1444 83static atomic_t iscsi_session_nr; /* sysfs session id for next new session */
d8bf541e 84static struct workqueue_struct *iscsi_eh_timer_workq;
b5c7a12d 85
8d4a690c 86static DEFINE_IDA(iscsi_sess_ida);
0896b752
AA		 87/*
88 * list of registered transports and lock that must
89 * be held while accessing list. The iscsi_transport_lock must
0b950672 90 * be acquired after the rx_queue_mutex.
0896b752
AA		 91 */
92static LIST_HEAD(iscsi_transports);
93static DEFINE_SPINLOCK(iscsi_transport_lock);
94
95#define to_iscsi_internal(tmpl) \
96 container_of(tmpl, struct iscsi_internal, t)
97
ee959b00
TJ		 98#define dev_to_iscsi_internal(_dev) \
99 container_of(_dev, struct iscsi_internal, dev)
0896b752 100
ee959b00 101static void iscsi_transport_release(struct device *dev)
0896b752 102{
ee959b00 103 struct iscsi_internal *priv = dev_to_iscsi_internal(dev);
0896b752
AA		 104 kfree(priv);
105}
1da177e4 106
0896b752
AA		 107/*
108 * iscsi_transport_class represents the iscsi_transports that are
109 * registered.
110 */
111static struct class iscsi_transport_class = {
112 .name = "iscsi_transport",
ee959b00 113 .dev_release = iscsi_transport_release,
0896b752
AA		 114};
115
116static ssize_t
ee959b00
TJ		 117show_transport_handle(struct device *dev, struct device_attribute *attr,
118 char *buf)
0896b752 119{
ee959b00 120 struct iscsi_internal *priv = dev_to_iscsi_internal(dev);
762e2bfa 121 return sprintf(buf, "%llu\n", (unsigned long long)iscsi_handle(priv->iscsi_transport));
0896b752 122}
ee959b00 123static DEVICE_ATTR(handle, S_IRUGO, show_transport_handle, NULL);
0896b752
AA		 124
125#define show_transport_attr(name, format) \
126static ssize_t \
ee959b00
TJ		 127show_transport_##name(struct device *dev, \
128 struct device_attribute *attr,char *buf) \
0896b752 129{ \
ee959b00 130 struct iscsi_internal *priv = dev_to_iscsi_internal(dev); \
0896b752
AA		 131 return sprintf(buf, format"\n", priv->iscsi_transport->name); \
132} \
ee959b00 133static DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL);
0896b752
AA		 134
135show_transport_attr(caps, "0x%x");
0896b752
AA		 136
137static struct attribute *iscsi_transport_attrs[] = {
ee959b00
TJ		 138 &dev_attr_handle.attr,
139 &dev_attr_caps.attr,
0896b752
AA		 140 NULL,
141};
142
143static struct attribute_group iscsi_transport_group = {
144 .attrs = iscsi_transport_attrs,
145};
146
d82ff9be
MC		 147/*
148 * iSCSI endpoint attrs
149 */
150#define iscsi_dev_to_endpoint(_dev) \
151 container_of(_dev, struct iscsi_endpoint, dev)
152
153#define ISCSI_ATTR(_prefix,_name,_mode,_show,_store) \
154struct device_attribute dev_attr_##_prefix##_##_name = \
155 __ATTR(_name,_mode,_show,_store)
156
157static void iscsi_endpoint_release(struct device *dev)
158{
159 struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev);
160 kfree(ep);
161}
162
163static struct class iscsi_endpoint_class = {
164 .name = "iscsi_endpoint",
165 .dev_release = iscsi_endpoint_release,
166};
167
168static ssize_t
169show_ep_handle(struct device *dev, struct device_attribute *attr, char *buf)
170{
171 struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev);
21536062 172 return sprintf(buf, "%llu\n", (unsigned long long) ep->id);
d82ff9be
MC		 173}
174static ISCSI_ATTR(ep, handle, S_IRUGO, show_ep_handle, NULL);
175
176static struct attribute *iscsi_endpoint_attrs[] = {
177 &dev_attr_ep_handle.attr,
178 NULL,
179};
180
181static struct attribute_group iscsi_endpoint_group = {
182 .attrs = iscsi_endpoint_attrs,
183};
184
185#define ISCSI_MAX_EPID -1
186
9f3b795a 187static int iscsi_match_epid(struct device *dev, const void *data)
d82ff9be
MC		 188{
189 struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev);
9f3b795a 190 const uint64_t *epid = data;
d82ff9be
MC		 191
192 return *epid == ep->id;
193}
194
195struct iscsi_endpoint *
196iscsi_create_endpoint(int dd_size)
197{
198 struct device *dev;
199 struct iscsi_endpoint *ep;
21536062 200 uint64_t id;
d82ff9be
MC		 201 int err;
202
203 for (id = 1; id < ISCSI_MAX_EPID; id++) {
695794ae 204 dev = class_find_device(&iscsi_endpoint_class, NULL, &id,
d82ff9be
MC		 205 iscsi_match_epid);
206 if (!dev)
207 break;
208 }
209 if (id == ISCSI_MAX_EPID) {
210 printk(KERN_ERR "Too many connections. Max supported %u\n",
211 ISCSI_MAX_EPID - 1);
212 return NULL;
213 }
214
215 ep = kzalloc(sizeof(*ep) + dd_size, GFP_KERNEL);
216 if (!ep)
217 return NULL;
218
219 ep->id = id;
220 ep->dev.class = &iscsi_endpoint_class;
71610f55 221 dev_set_name(&ep->dev, "ep-%llu", (unsigned long long) id);
d82ff9be
MC		 222 err = device_register(&ep->dev);
223 if (err)
224 goto free_ep;
225
226 err = sysfs_create_group(&ep->dev.kobj, &iscsi_endpoint_group);
227 if (err)
228 goto unregister_dev;
229
230 if (dd_size)
231 ep->dd_data = &ep[1];
232 return ep;
233
234unregister_dev:
235 device_unregister(&ep->dev);
236 return NULL;
237
238free_ep:
239 kfree(ep);
240 return NULL;
241}
242EXPORT_SYMBOL_GPL(iscsi_create_endpoint);
243
244void iscsi_destroy_endpoint(struct iscsi_endpoint *ep)
245{
246 sysfs_remove_group(&ep->dev.kobj, &iscsi_endpoint_group);
247 device_unregister(&ep->dev);
248}
249EXPORT_SYMBOL_GPL(iscsi_destroy_endpoint);
250
251struct iscsi_endpoint *iscsi_lookup_endpoint(u64 handle)
252{
f80f868e 253 struct iscsi_endpoint *ep;
d82ff9be
MC		 254 struct device *dev;
255
695794ae 256 dev = class_find_device(&iscsi_endpoint_class, NULL, &handle,
d82ff9be
MC		 257 iscsi_match_epid);
258 if (!dev)
259 return NULL;
260
f80f868e
MC		 261 ep = iscsi_dev_to_endpoint(dev);
262 /*
263 * we can drop this now because the interface will prevent
264 * removals and lookups from racing.
265 */
266 put_device(dev);
267 return ep;
d82ff9be
MC		 268}
269EXPORT_SYMBOL_GPL(iscsi_lookup_endpoint);
270
8d07913d
MC		 271/*
272 * Interface to display network param to sysfs
273 */
274
275static void iscsi_iface_release(struct device *dev)
276{
277 struct iscsi_iface *iface = iscsi_dev_to_iface(dev);
278 struct device *parent = iface->dev.parent;
279
280 kfree(iface);
281 put_device(parent);
282}
283
284
285static struct class iscsi_iface_class = {
286 .name = "iscsi_iface",
287 .dev_release = iscsi_iface_release,
288};
289
290#define ISCSI_IFACE_ATTR(_prefix, _name, _mode, _show, _store) \
291struct device_attribute dev_attr_##_prefix##_##_name = \
292 __ATTR(_name, _mode, _show, _store)
293
294/* iface attrs show */
295#define iscsi_iface_attr_show(type, name, param_type, param) \
296static ssize_t \
297show_##type##_##name(struct device *dev, struct device_attribute *attr, \
298 char *buf) \
299{ \
300 struct iscsi_iface *iface = iscsi_dev_to_iface(dev); \
301 struct iscsi_transport *t = iface->transport; \
302 return t->get_iface_param(iface, param_type, param, buf); \
303} \
304
305#define iscsi_iface_net_attr(type, name, param) \
306 iscsi_iface_attr_show(type, name, ISCSI_NET_PARAM, param) \
307static ISCSI_IFACE_ATTR(type, name, S_IRUGO, show_##type##_##name, NULL);
308
309/* generic read only ipvi4 attribute */
310iscsi_iface_net_attr(ipv4_iface, ipaddress, ISCSI_NET_PARAM_IPV4_ADDR);
311iscsi_iface_net_attr(ipv4_iface, gateway, ISCSI_NET_PARAM_IPV4_GW);
312iscsi_iface_net_attr(ipv4_iface, subnet, ISCSI_NET_PARAM_IPV4_SUBNET);
313iscsi_iface_net_attr(ipv4_iface, bootproto, ISCSI_NET_PARAM_IPV4_BOOTPROTO);
314
315/* generic read only ipv6 attribute */
316iscsi_iface_net_attr(ipv6_iface, ipaddress, ISCSI_NET_PARAM_IPV6_ADDR);
317iscsi_iface_net_attr(ipv6_iface, link_local_addr, ISCSI_NET_PARAM_IPV6_LINKLOCAL);
318iscsi_iface_net_attr(ipv6_iface, router_addr, ISCSI_NET_PARAM_IPV6_ROUTER);
319iscsi_iface_net_attr(ipv6_iface, ipaddr_autocfg,
320 ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG);
88f4f517 321iscsi_iface_net_attr(ipv6_iface, link_local_autocfg,
8d07913d
MC		 322 ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG);
323
324/* common read only iface attribute */
325iscsi_iface_net_attr(iface, enabled, ISCSI_NET_PARAM_IFACE_ENABLE);
2d63673b 326iscsi_iface_net_attr(iface, vlan_id, ISCSI_NET_PARAM_VLAN_ID);
4223b9e9
MC		 327iscsi_iface_net_attr(iface, vlan_priority, ISCSI_NET_PARAM_VLAN_PRIORITY);
328iscsi_iface_net_attr(iface, vlan_enabled, ISCSI_NET_PARAM_VLAN_ENABLED);
8c7d40fb 329iscsi_iface_net_attr(iface, mtu, ISCSI_NET_PARAM_MTU);
fcb5124e 330iscsi_iface_net_attr(iface, port, ISCSI_NET_PARAM_PORT);
8d07913d 331
587a1f16 332static umode_t iscsi_iface_attr_is_visible(struct kobject *kobj,
8d07913d
MC		 333 struct attribute *attr, int i)
334{
335 struct device *dev = container_of(kobj, struct device, kobj);
336 struct iscsi_iface *iface = iscsi_dev_to_iface(dev);
337 struct iscsi_transport *t = iface->transport;
b78dbba0 338 int param;
8d07913d
MC		 339
340 if (attr == &dev_attr_iface_enabled.attr)
b78dbba0 341 param = ISCSI_NET_PARAM_IFACE_ENABLE;
2d63673b 342 else if (attr == &dev_attr_iface_vlan_id.attr)
b78dbba0 343 param = ISCSI_NET_PARAM_VLAN_ID;
4223b9e9
MC		 344 else if (attr == &dev_attr_iface_vlan_priority.attr)
345 param = ISCSI_NET_PARAM_VLAN_PRIORITY;
346 else if (attr == &dev_attr_iface_vlan_enabled.attr)
347 param = ISCSI_NET_PARAM_VLAN_ENABLED;
8c7d40fb
VC		 348 else if (attr == &dev_attr_iface_mtu.attr)
349 param = ISCSI_NET_PARAM_MTU;
fcb5124e
VC		 350 else if (attr == &dev_attr_iface_port.attr)
351 param = ISCSI_NET_PARAM_PORT;
b78dbba0 352 else if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
8d07913d 353 if (attr == &dev_attr_ipv4_iface_ipaddress.attr)
b78dbba0 354 param = ISCSI_NET_PARAM_IPV4_ADDR;
8d07913d 355 else if (attr == &dev_attr_ipv4_iface_gateway.attr)
b78dbba0 356 param = ISCSI_NET_PARAM_IPV4_GW;
8d07913d 357 else if (attr == &dev_attr_ipv4_iface_subnet.attr)
b78dbba0 358 param = ISCSI_NET_PARAM_IPV4_SUBNET;
8d07913d 359 else if (attr == &dev_attr_ipv4_iface_bootproto.attr)
b78dbba0
MC		 360 param = ISCSI_NET_PARAM_IPV4_BOOTPROTO;
361 else
362 return 0;
8d07913d
MC		 363 } else if (iface->iface_type == ISCSI_IFACE_TYPE_IPV6) {
364 if (attr == &dev_attr_ipv6_iface_ipaddress.attr)
b78dbba0 365 param = ISCSI_NET_PARAM_IPV6_ADDR;
8d07913d 366 else if (attr == &dev_attr_ipv6_iface_link_local_addr.attr)
b78dbba0 367 param = ISCSI_NET_PARAM_IPV6_LINKLOCAL;
8d07913d 368 else if (attr == &dev_attr_ipv6_iface_router_addr.attr)
b78dbba0 369 param = ISCSI_NET_PARAM_IPV6_ROUTER;
8d07913d 370 else if (attr == &dev_attr_ipv6_iface_ipaddr_autocfg.attr)
b78dbba0 371 param = ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG;
88f4f517 372 else if (attr == &dev_attr_ipv6_iface_link_local_autocfg.attr)
b78dbba0
MC		 373 param = ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG;
374 else
375 return 0;
376 } else {
377 WARN_ONCE(1, "Invalid iface attr");
378 return 0;
8d07913d
MC		 379 }
380
b78dbba0 381 return t->attr_is_visible(ISCSI_NET_PARAM, param);
8d07913d
MC		 382}
383
384static struct attribute *iscsi_iface_attrs[] = {
385 &dev_attr_iface_enabled.attr,
2d63673b 386 &dev_attr_iface_vlan_id.attr,
4223b9e9
MC		 387 &dev_attr_iface_vlan_priority.attr,
388 &dev_attr_iface_vlan_enabled.attr,
8d07913d
MC		 389 &dev_attr_ipv4_iface_ipaddress.attr,
390 &dev_attr_ipv4_iface_gateway.attr,
391 &dev_attr_ipv4_iface_subnet.attr,
392 &dev_attr_ipv4_iface_bootproto.attr,
393 &dev_attr_ipv6_iface_ipaddress.attr,
394 &dev_attr_ipv6_iface_link_local_addr.attr,
395 &dev_attr_ipv6_iface_router_addr.attr,
396 &dev_attr_ipv6_iface_ipaddr_autocfg.attr,
88f4f517 397 &dev_attr_ipv6_iface_link_local_autocfg.attr,
8c7d40fb 398 &dev_attr_iface_mtu.attr,
fcb5124e 399 &dev_attr_iface_port.attr,
8d07913d
MC		 400 NULL,
401};
402
403static struct attribute_group iscsi_iface_group = {
404 .attrs = iscsi_iface_attrs,
405 .is_visible = iscsi_iface_attr_is_visible,
406};
407
408struct iscsi_iface *
409iscsi_create_iface(struct Scsi_Host *shost, struct iscsi_transport *transport,
410 uint32_t iface_type, uint32_t iface_num, int dd_size)
411{
412 struct iscsi_iface *iface;
413 int err;
414
415 iface = kzalloc(sizeof(*iface) + dd_size, GFP_KERNEL);
416 if (!iface)
417 return NULL;
418
419 iface->transport = transport;
420 iface->iface_type = iface_type;
421 iface->iface_num = iface_num;
422 iface->dev.release = iscsi_iface_release;
423 iface->dev.class = &iscsi_iface_class;
424 /* parent reference released in iscsi_iface_release */
425 iface->dev.parent = get_device(&shost->shost_gendev);
426 if (iface_type == ISCSI_IFACE_TYPE_IPV4)
427 dev_set_name(&iface->dev, "ipv4-iface-%u-%u", shost->host_no,
428 iface_num);
429 else
430 dev_set_name(&iface->dev, "ipv6-iface-%u-%u", shost->host_no,
431 iface_num);
432
433 err = device_register(&iface->dev);
434 if (err)
435 goto free_iface;
436
437 err = sysfs_create_group(&iface->dev.kobj, &iscsi_iface_group);
438 if (err)
439 goto unreg_iface;
440
441 if (dd_size)
442 iface->dd_data = &iface[1];
443 return iface;
444
445unreg_iface:
446 device_unregister(&iface->dev);
447 return NULL;
448
449free_iface:
450 put_device(iface->dev.parent);
451 kfree(iface);
452 return NULL;
453}
454EXPORT_SYMBOL_GPL(iscsi_create_iface);
455
456void iscsi_destroy_iface(struct iscsi_iface *iface)
457{
458 sysfs_remove_group(&iface->dev.kobj, &iscsi_iface_group);
459 device_unregister(&iface->dev);
460}
461EXPORT_SYMBOL_GPL(iscsi_destroy_iface);
462
c6a4bb2e
AC		 463/*
464 * Interface to display flash node params to sysfs
465 */
466
467#define ISCSI_FLASHNODE_ATTR(_prefix, _name, _mode, _show, _store) \
468struct device_attribute dev_attr_##_prefix##_##_name = \
469 __ATTR(_name, _mode, _show, _store)
470
471/* flash node session attrs show */
472#define iscsi_flashnode_sess_attr_show(type, name, param) \
473static ssize_t \
474show_##type##_##name(struct device *dev, struct device_attribute *attr, \
475 char *buf) \
476{ \
477 struct iscsi_bus_flash_session *fnode_sess = \
478 iscsi_dev_to_flash_session(dev);\
479 struct iscsi_transport *t = fnode_sess->transport; \
480 return t->get_flashnode_param(fnode_sess, param, buf); \
481} \
482
483
484#define iscsi_flashnode_sess_attr(type, name, param) \
485 iscsi_flashnode_sess_attr_show(type, name, param) \
486static ISCSI_FLASHNODE_ATTR(type, name, S_IRUGO, \
487 show_##type##_##name, NULL);
488
489/* Flash node session attributes */
490
491iscsi_flashnode_sess_attr(fnode, auto_snd_tgt_disable,
492 ISCSI_FLASHNODE_AUTO_SND_TGT_DISABLE);
493iscsi_flashnode_sess_attr(fnode, discovery_session,
494 ISCSI_FLASHNODE_DISCOVERY_SESS);
495iscsi_flashnode_sess_attr(fnode, portal_type, ISCSI_FLASHNODE_PORTAL_TYPE);
496iscsi_flashnode_sess_attr(fnode, entry_enable, ISCSI_FLASHNODE_ENTRY_EN);
497iscsi_flashnode_sess_attr(fnode, immediate_data, ISCSI_FLASHNODE_IMM_DATA_EN);
498iscsi_flashnode_sess_attr(fnode, initial_r2t, ISCSI_FLASHNODE_INITIAL_R2T_EN);
499iscsi_flashnode_sess_attr(fnode, data_seq_in_order,
500 ISCSI_FLASHNODE_DATASEQ_INORDER);
501iscsi_flashnode_sess_attr(fnode, data_pdu_in_order,
502 ISCSI_FLASHNODE_PDU_INORDER);
503iscsi_flashnode_sess_attr(fnode, chap_auth, ISCSI_FLASHNODE_CHAP_AUTH_EN);
504iscsi_flashnode_sess_attr(fnode, discovery_logout,
505 ISCSI_FLASHNODE_DISCOVERY_LOGOUT_EN);
506iscsi_flashnode_sess_attr(fnode, bidi_chap, ISCSI_FLASHNODE_BIDI_CHAP_EN);
507iscsi_flashnode_sess_attr(fnode, discovery_auth_optional,
508 ISCSI_FLASHNODE_DISCOVERY_AUTH_OPTIONAL);
509iscsi_flashnode_sess_attr(fnode, erl, ISCSI_FLASHNODE_ERL);
510iscsi_flashnode_sess_attr(fnode, first_burst_len, ISCSI_FLASHNODE_FIRST_BURST);
511iscsi_flashnode_sess_attr(fnode, def_time2wait, ISCSI_FLASHNODE_DEF_TIME2WAIT);
512iscsi_flashnode_sess_attr(fnode, def_time2retain,
513 ISCSI_FLASHNODE_DEF_TIME2RETAIN);
514iscsi_flashnode_sess_attr(fnode, max_outstanding_r2t, ISCSI_FLASHNODE_MAX_R2T);
515iscsi_flashnode_sess_attr(fnode, isid, ISCSI_FLASHNODE_ISID);
516iscsi_flashnode_sess_attr(fnode, tsid, ISCSI_FLASHNODE_TSID);
517iscsi_flashnode_sess_attr(fnode, max_burst_len, ISCSI_FLASHNODE_MAX_BURST);
518iscsi_flashnode_sess_attr(fnode, def_taskmgmt_tmo,
519 ISCSI_FLASHNODE_DEF_TASKMGMT_TMO);
520iscsi_flashnode_sess_attr(fnode, targetalias, ISCSI_FLASHNODE_ALIAS);
521iscsi_flashnode_sess_attr(fnode, targetname, ISCSI_FLASHNODE_NAME);
522iscsi_flashnode_sess_attr(fnode, tpgt, ISCSI_FLASHNODE_TPGT);
523iscsi_flashnode_sess_attr(fnode, discovery_parent_idx,
524 ISCSI_FLASHNODE_DISCOVERY_PARENT_IDX);
525iscsi_flashnode_sess_attr(fnode, discovery_parent_type,
526 ISCSI_FLASHNODE_DISCOVERY_PARENT_TYPE);
527iscsi_flashnode_sess_attr(fnode, chap_in_idx, ISCSI_FLASHNODE_CHAP_IN_IDX);
528iscsi_flashnode_sess_attr(fnode, chap_out_idx, ISCSI_FLASHNODE_CHAP_OUT_IDX);
529iscsi_flashnode_sess_attr(fnode, username, ISCSI_FLASHNODE_USERNAME);
530iscsi_flashnode_sess_attr(fnode, username_in, ISCSI_FLASHNODE_USERNAME_IN);
531iscsi_flashnode_sess_attr(fnode, password, ISCSI_FLASHNODE_PASSWORD);
532iscsi_flashnode_sess_attr(fnode, password_in, ISCSI_FLASHNODE_PASSWORD_IN);
533iscsi_flashnode_sess_attr(fnode, is_boot_target, ISCSI_FLASHNODE_IS_BOOT_TGT);
534
535static struct attribute *iscsi_flashnode_sess_attrs[] = {
536 &dev_attr_fnode_auto_snd_tgt_disable.attr,
537 &dev_attr_fnode_discovery_session.attr,
538 &dev_attr_fnode_portal_type.attr,
539 &dev_attr_fnode_entry_enable.attr,
540 &dev_attr_fnode_immediate_data.attr,
541 &dev_attr_fnode_initial_r2t.attr,
542 &dev_attr_fnode_data_seq_in_order.attr,
543 &dev_attr_fnode_data_pdu_in_order.attr,
544 &dev_attr_fnode_chap_auth.attr,
545 &dev_attr_fnode_discovery_logout.attr,
546 &dev_attr_fnode_bidi_chap.attr,
547 &dev_attr_fnode_discovery_auth_optional.attr,
548 &dev_attr_fnode_erl.attr,
549 &dev_attr_fnode_first_burst_len.attr,
550 &dev_attr_fnode_def_time2wait.attr,
551 &dev_attr_fnode_def_time2retain.attr,
552 &dev_attr_fnode_max_outstanding_r2t.attr,
553 &dev_attr_fnode_isid.attr,
554 &dev_attr_fnode_tsid.attr,
555 &dev_attr_fnode_max_burst_len.attr,
556 &dev_attr_fnode_def_taskmgmt_tmo.attr,
557 &dev_attr_fnode_targetalias.attr,
558 &dev_attr_fnode_targetname.attr,
559 &dev_attr_fnode_tpgt.attr,
560 &dev_attr_fnode_discovery_parent_idx.attr,
561 &dev_attr_fnode_discovery_parent_type.attr,
562 &dev_attr_fnode_chap_in_idx.attr,
563 &dev_attr_fnode_chap_out_idx.attr,
564 &dev_attr_fnode_username.attr,
565 &dev_attr_fnode_username_in.attr,
566 &dev_attr_fnode_password.attr,
567 &dev_attr_fnode_password_in.attr,
568 &dev_attr_fnode_is_boot_target.attr,
569 NULL,
570};
571
572static umode_t iscsi_flashnode_sess_attr_is_visible(struct kobject *kobj,
573 struct attribute *attr,
574 int i)
575{
576 struct device *dev = container_of(kobj, struct device, kobj);
577 struct iscsi_bus_flash_session *fnode_sess =
578 iscsi_dev_to_flash_session(dev);
579 struct iscsi_transport *t = fnode_sess->transport;
580 int param;
581
582 if (attr == &dev_attr_fnode_auto_snd_tgt_disable.attr) {
583 param = ISCSI_FLASHNODE_AUTO_SND_TGT_DISABLE;
584 } else if (attr == &dev_attr_fnode_discovery_session.attr) {
585 param = ISCSI_FLASHNODE_DISCOVERY_SESS;
586 } else if (attr == &dev_attr_fnode_portal_type.attr) {
587 param = ISCSI_FLASHNODE_PORTAL_TYPE;
588 } else if (attr == &dev_attr_fnode_entry_enable.attr) {
589 param = ISCSI_FLASHNODE_ENTRY_EN;
590 } else if (attr == &dev_attr_fnode_immediate_data.attr) {
591 param = ISCSI_FLASHNODE_IMM_DATA_EN;
592 } else if (attr == &dev_attr_fnode_initial_r2t.attr) {
593 param = ISCSI_FLASHNODE_INITIAL_R2T_EN;
594 } else if (attr == &dev_attr_fnode_data_seq_in_order.attr) {
595 param = ISCSI_FLASHNODE_DATASEQ_INORDER;
596 } else if (attr == &dev_attr_fnode_data_pdu_in_order.attr) {
597 param = ISCSI_FLASHNODE_PDU_INORDER;
598 } else if (attr == &dev_attr_fnode_chap_auth.attr) {
599 param = ISCSI_FLASHNODE_CHAP_AUTH_EN;
600 } else if (attr == &dev_attr_fnode_discovery_logout.attr) {
601 param = ISCSI_FLASHNODE_DISCOVERY_LOGOUT_EN;
602 } else if (attr == &dev_attr_fnode_bidi_chap.attr) {
603 param = ISCSI_FLASHNODE_BIDI_CHAP_EN;
604 } else if (attr == &dev_attr_fnode_discovery_auth_optional.attr) {
605 param = ISCSI_FLASHNODE_DISCOVERY_AUTH_OPTIONAL;
606 } else if (attr == &dev_attr_fnode_erl.attr) {
607 param = ISCSI_FLASHNODE_ERL;
608 } else if (attr == &dev_attr_fnode_first_burst_len.attr) {
609 param = ISCSI_FLASHNODE_FIRST_BURST;
610 } else if (attr == &dev_attr_fnode_def_time2wait.attr) {
611 param = ISCSI_FLASHNODE_DEF_TIME2WAIT;
612 } else if (attr == &dev_attr_fnode_def_time2retain.attr) {
613 param = ISCSI_FLASHNODE_DEF_TIME2RETAIN;
614 } else if (attr == &dev_attr_fnode_max_outstanding_r2t.attr) {
615 param = ISCSI_FLASHNODE_MAX_R2T;
616 } else if (attr == &dev_attr_fnode_isid.attr) {
617 param = ISCSI_FLASHNODE_ISID;
618 } else if (attr == &dev_attr_fnode_tsid.attr) {
619 param = ISCSI_FLASHNODE_TSID;
620 } else if (attr == &dev_attr_fnode_max_burst_len.attr) {
621 param = ISCSI_FLASHNODE_MAX_BURST;
622 } else if (attr == &dev_attr_fnode_def_taskmgmt_tmo.attr) {
623 param = ISCSI_FLASHNODE_DEF_TASKMGMT_TMO;
624 } else if (attr == &dev_attr_fnode_targetalias.attr) {
625 param = ISCSI_FLASHNODE_ALIAS;
626 } else if (attr == &dev_attr_fnode_targetname.attr) {
627 param = ISCSI_FLASHNODE_NAME;
628 } else if (attr == &dev_attr_fnode_tpgt.attr) {
629 param = ISCSI_FLASHNODE_TPGT;
630 } else if (attr == &dev_attr_fnode_discovery_parent_idx.attr) {
631 param = ISCSI_FLASHNODE_DISCOVERY_PARENT_IDX;
632 } else if (attr == &dev_attr_fnode_discovery_parent_type.attr) {
633 param = ISCSI_FLASHNODE_DISCOVERY_PARENT_TYPE;
634 } else if (attr == &dev_attr_fnode_chap_in_idx.attr) {
635 param = ISCSI_FLASHNODE_CHAP_IN_IDX;
636 } else if (attr == &dev_attr_fnode_chap_out_idx.attr) {
637 param = ISCSI_FLASHNODE_CHAP_OUT_IDX;
638 } else if (attr == &dev_attr_fnode_username.attr) {
639 param = ISCSI_FLASHNODE_USERNAME;
640 } else if (attr == &dev_attr_fnode_username_in.attr) {
641 param = ISCSI_FLASHNODE_USERNAME_IN;
642 } else if (attr == &dev_attr_fnode_password.attr) {
643 param = ISCSI_FLASHNODE_PASSWORD;
644 } else if (attr == &dev_attr_fnode_password_in.attr) {
645 param = ISCSI_FLASHNODE_PASSWORD_IN;
646 } else if (attr == &dev_attr_fnode_is_boot_target.attr) {
647 param = ISCSI_FLASHNODE_IS_BOOT_TGT;
648 } else {
649 WARN_ONCE(1, "Invalid flashnode session attr");
650 return 0;
651 }
652
653 return t->attr_is_visible(ISCSI_FLASHNODE_PARAM, param);
654}
655
656static struct attribute_group iscsi_flashnode_sess_attr_group = {
657 .attrs = iscsi_flashnode_sess_attrs,
658 .is_visible = iscsi_flashnode_sess_attr_is_visible,
659};
660
661static const struct attribute_group *iscsi_flashnode_sess_attr_groups[] = {
662 &iscsi_flashnode_sess_attr_group,
663 NULL,
664};
665
666static void iscsi_flashnode_sess_release(struct device *dev)
667{
668 struct iscsi_bus_flash_session *fnode_sess =
669 iscsi_dev_to_flash_session(dev);
670
671 kfree(fnode_sess->targetname);
672 kfree(fnode_sess->targetalias);
673 kfree(fnode_sess->portal_type);
674 kfree(fnode_sess);
675}
676
677struct device_type iscsi_flashnode_sess_dev_type = {
678 .name = "iscsi_flashnode_sess_dev_type",
679 .groups = iscsi_flashnode_sess_attr_groups,
680 .release = iscsi_flashnode_sess_release,
681};
682
683/* flash node connection attrs show */
684#define iscsi_flashnode_conn_attr_show(type, name, param) \
685static ssize_t \
686show_##type##_##name(struct device *dev, struct device_attribute *attr, \
687 char *buf) \
688{ \
689 struct iscsi_bus_flash_conn *fnode_conn = iscsi_dev_to_flash_conn(dev);\
690 struct iscsi_bus_flash_session *fnode_sess = \
691 iscsi_flash_conn_to_flash_session(fnode_conn);\
692 struct iscsi_transport *t = fnode_conn->transport; \
693 return t->get_flashnode_param(fnode_sess, param, buf); \
694} \
695
696
697#define iscsi_flashnode_conn_attr(type, name, param) \
698 iscsi_flashnode_conn_attr_show(type, name, param) \
699static ISCSI_FLASHNODE_ATTR(type, name, S_IRUGO, \
700 show_##type##_##name, NULL);
701
702/* Flash node connection attributes */
703
704iscsi_flashnode_conn_attr(fnode, is_fw_assigned_ipv6,
705 ISCSI_FLASHNODE_IS_FW_ASSIGNED_IPV6);
706iscsi_flashnode_conn_attr(fnode, header_digest, ISCSI_FLASHNODE_HDR_DGST_EN);
707iscsi_flashnode_conn_attr(fnode, data_digest, ISCSI_FLASHNODE_DATA_DGST_EN);
708iscsi_flashnode_conn_attr(fnode, snack_req, ISCSI_FLASHNODE_SNACK_REQ_EN);
709iscsi_flashnode_conn_attr(fnode, tcp_timestamp_stat,
710 ISCSI_FLASHNODE_TCP_TIMESTAMP_STAT);
711iscsi_flashnode_conn_attr(fnode, tcp_nagle_disable,
712 ISCSI_FLASHNODE_TCP_NAGLE_DISABLE);
713iscsi_flashnode_conn_attr(fnode, tcp_wsf_disable,
714 ISCSI_FLASHNODE_TCP_WSF_DISABLE);
715iscsi_flashnode_conn_attr(fnode, tcp_timer_scale,
716 ISCSI_FLASHNODE_TCP_TIMER_SCALE);
717iscsi_flashnode_conn_attr(fnode, tcp_timestamp_enable,
718 ISCSI_FLASHNODE_TCP_TIMESTAMP_EN);
719iscsi_flashnode_conn_attr(fnode, fragment_disable,
720 ISCSI_FLASHNODE_IP_FRAG_DISABLE);
721iscsi_flashnode_conn_attr(fnode, keepalive_tmo, ISCSI_FLASHNODE_KEEPALIVE_TMO);
722iscsi_flashnode_conn_attr(fnode, port, ISCSI_FLASHNODE_PORT);
723iscsi_flashnode_conn_attr(fnode, ipaddress, ISCSI_FLASHNODE_IPADDR);
724iscsi_flashnode_conn_attr(fnode, max_recv_dlength,
725 ISCSI_FLASHNODE_MAX_RECV_DLENGTH);
726iscsi_flashnode_conn_attr(fnode, max_xmit_dlength,
727 ISCSI_FLASHNODE_MAX_XMIT_DLENGTH);
728iscsi_flashnode_conn_attr(fnode, local_port, ISCSI_FLASHNODE_LOCAL_PORT);
729iscsi_flashnode_conn_attr(fnode, ipv4_tos, ISCSI_FLASHNODE_IPV4_TOS);
730iscsi_flashnode_conn_attr(fnode, ipv6_traffic_class, ISCSI_FLASHNODE_IPV6_TC);
731iscsi_flashnode_conn_attr(fnode, ipv6_flow_label,
732 ISCSI_FLASHNODE_IPV6_FLOW_LABEL);
733iscsi_flashnode_conn_attr(fnode, redirect_ipaddr,
734 ISCSI_FLASHNODE_REDIRECT_IPADDR);
735iscsi_flashnode_conn_attr(fnode, max_segment_size,
736 ISCSI_FLASHNODE_MAX_SEGMENT_SIZE);
737iscsi_flashnode_conn_attr(fnode, link_local_ipv6,
738 ISCSI_FLASHNODE_LINK_LOCAL_IPV6);
739iscsi_flashnode_conn_attr(fnode, tcp_xmit_wsf, ISCSI_FLASHNODE_TCP_XMIT_WSF);
740iscsi_flashnode_conn_attr(fnode, tcp_recv_wsf, ISCSI_FLASHNODE_TCP_RECV_WSF);
741iscsi_flashnode_conn_attr(fnode, statsn, ISCSI_FLASHNODE_STATSN);
742iscsi_flashnode_conn_attr(fnode, exp_statsn, ISCSI_FLASHNODE_EXP_STATSN);
743
744static struct attribute *iscsi_flashnode_conn_attrs[] = {
745 &dev_attr_fnode_is_fw_assigned_ipv6.attr,
746 &dev_attr_fnode_header_digest.attr,
747 &dev_attr_fnode_data_digest.attr,
748 &dev_attr_fnode_snack_req.attr,
749 &dev_attr_fnode_tcp_timestamp_stat.attr,
750 &dev_attr_fnode_tcp_nagle_disable.attr,
751 &dev_attr_fnode_tcp_wsf_disable.attr,
752 &dev_attr_fnode_tcp_timer_scale.attr,
753 &dev_attr_fnode_tcp_timestamp_enable.attr,
754 &dev_attr_fnode_fragment_disable.attr,
755 &dev_attr_fnode_max_recv_dlength.attr,
756 &dev_attr_fnode_max_xmit_dlength.attr,
757 &dev_attr_fnode_keepalive_tmo.attr,
758 &dev_attr_fnode_port.attr,
759 &dev_attr_fnode_ipaddress.attr,
760 &dev_attr_fnode_redirect_ipaddr.attr,
761 &dev_attr_fnode_max_segment_size.attr,
762 &dev_attr_fnode_local_port.attr,
763 &dev_attr_fnode_ipv4_tos.attr,
764 &dev_attr_fnode_ipv6_traffic_class.attr,
765 &dev_attr_fnode_ipv6_flow_label.attr,
766 &dev_attr_fnode_link_local_ipv6.attr,
767 &dev_attr_fnode_tcp_xmit_wsf.attr,
768 &dev_attr_fnode_tcp_recv_wsf.attr,
769 &dev_attr_fnode_statsn.attr,
770 &dev_attr_fnode_exp_statsn.attr,
771 NULL,
772};
773
774static umode_t iscsi_flashnode_conn_attr_is_visible(struct kobject *kobj,
775 struct attribute *attr,
776 int i)
777{
778 struct device *dev = container_of(kobj, struct device, kobj);
779 struct iscsi_bus_flash_conn *fnode_conn = iscsi_dev_to_flash_conn(dev);
780 struct iscsi_transport *t = fnode_conn->transport;
781 int param;
782
783 if (attr == &dev_attr_fnode_is_fw_assigned_ipv6.attr) {
784 param = ISCSI_FLASHNODE_IS_FW_ASSIGNED_IPV6;
785 } else if (attr == &dev_attr_fnode_header_digest.attr) {
786 param = ISCSI_FLASHNODE_HDR_DGST_EN;
787 } else if (attr == &dev_attr_fnode_data_digest.attr) {
788 param = ISCSI_FLASHNODE_DATA_DGST_EN;
789 } else if (attr == &dev_attr_fnode_snack_req.attr) {
790 param = ISCSI_FLASHNODE_SNACK_REQ_EN;
791 } else if (attr == &dev_attr_fnode_tcp_timestamp_stat.attr) {
792 param = ISCSI_FLASHNODE_TCP_TIMESTAMP_STAT;
793 } else if (attr == &dev_attr_fnode_tcp_nagle_disable.attr) {
794 param = ISCSI_FLASHNODE_TCP_NAGLE_DISABLE;
795 } else if (attr == &dev_attr_fnode_tcp_wsf_disable.attr) {
796 param = ISCSI_FLASHNODE_TCP_WSF_DISABLE;
797 } else if (attr == &dev_attr_fnode_tcp_timer_scale.attr) {
798 param = ISCSI_FLASHNODE_TCP_TIMER_SCALE;
799 } else if (attr == &dev_attr_fnode_tcp_timestamp_enable.attr) {
800 param = ISCSI_FLASHNODE_TCP_TIMESTAMP_EN;
801 } else if (attr == &dev_attr_fnode_fragment_disable.attr) {
802 param = ISCSI_FLASHNODE_IP_FRAG_DISABLE;
803 } else if (attr == &dev_attr_fnode_max_recv_dlength.attr) {
804 param = ISCSI_FLASHNODE_MAX_RECV_DLENGTH;
805 } else if (attr == &dev_attr_fnode_max_xmit_dlength.attr) {
806 param = ISCSI_FLASHNODE_MAX_XMIT_DLENGTH;
807 } else if (attr == &dev_attr_fnode_keepalive_tmo.attr) {
808 param = ISCSI_FLASHNODE_KEEPALIVE_TMO;
809 } else if (attr == &dev_attr_fnode_port.attr) {
810 param = ISCSI_FLASHNODE_PORT;
811 } else if (attr == &dev_attr_fnode_ipaddress.attr) {
812 param = ISCSI_FLASHNODE_IPADDR;
813 } else if (attr == &dev_attr_fnode_redirect_ipaddr.attr) {
814 param = ISCSI_FLASHNODE_REDIRECT_IPADDR;
815 } else if (attr == &dev_attr_fnode_max_segment_size.attr) {
816 param = ISCSI_FLASHNODE_MAX_SEGMENT_SIZE;
817 } else if (attr == &dev_attr_fnode_local_port.attr) {
818 param = ISCSI_FLASHNODE_LOCAL_PORT;
819 } else if (attr == &dev_attr_fnode_ipv4_tos.attr) {
820 param = ISCSI_FLASHNODE_IPV4_TOS;
821 } else if (attr == &dev_attr_fnode_ipv6_traffic_class.attr) {
822 param = ISCSI_FLASHNODE_IPV6_TC;
823 } else if (attr == &dev_attr_fnode_ipv6_flow_label.attr) {
824 param = ISCSI_FLASHNODE_IPV6_FLOW_LABEL;
825 } else if (attr == &dev_attr_fnode_link_local_ipv6.attr) {
826 param = ISCSI_FLASHNODE_LINK_LOCAL_IPV6;
827 } else if (attr == &dev_attr_fnode_tcp_xmit_wsf.attr) {
828 param = ISCSI_FLASHNODE_TCP_XMIT_WSF;
829 } else if (attr == &dev_attr_fnode_tcp_recv_wsf.attr) {
830 param = ISCSI_FLASHNODE_TCP_RECV_WSF;
831 } else if (attr == &dev_attr_fnode_statsn.attr) {
832 param = ISCSI_FLASHNODE_STATSN;
833 } else if (attr == &dev_attr_fnode_exp_statsn.attr) {
834 param = ISCSI_FLASHNODE_EXP_STATSN;
835 } else {
836 WARN_ONCE(1, "Invalid flashnode connection attr");
837 return 0;
838 }
839
840 return t->attr_is_visible(ISCSI_FLASHNODE_PARAM, param);
841}
842
843static struct attribute_group iscsi_flashnode_conn_attr_group = {
844 .attrs = iscsi_flashnode_conn_attrs,
845 .is_visible = iscsi_flashnode_conn_attr_is_visible,
846};
847
848static const struct attribute_group *iscsi_flashnode_conn_attr_groups[] = {
849 &iscsi_flashnode_conn_attr_group,
850 NULL,
851};
852
853static void iscsi_flashnode_conn_release(struct device *dev)
854{
855 struct iscsi_bus_flash_conn *fnode_conn = iscsi_dev_to_flash_conn(dev);
856
857 kfree(fnode_conn->ipaddress);
858 kfree(fnode_conn->redirect_ipaddr);
859 kfree(fnode_conn->link_local_ipv6_addr);
860 kfree(fnode_conn);
861}
862
863struct device_type iscsi_flashnode_conn_dev_type = {
864 .name = "iscsi_flashnode_conn_dev_type",
865 .groups = iscsi_flashnode_conn_attr_groups,
866 .release = iscsi_flashnode_conn_release,
867};
868
869struct bus_type iscsi_flashnode_bus;
870
871int iscsi_flashnode_bus_match(struct device *dev,
872 struct device_driver *drv)
873{
874 if (dev->bus == &iscsi_flashnode_bus)
875 return 1;
876 return 0;
877}
878EXPORT_SYMBOL_GPL(iscsi_flashnode_bus_match);
879
880struct bus_type iscsi_flashnode_bus = {
881 .name = "iscsi_flashnode",
882 .match = &iscsi_flashnode_bus_match,
883};
884
885/**
886 * iscsi_create_flashnode_sess - Add flashnode session entry in sysfs
887 * @shost: pointer to host data
888 * @index: index of flashnode to add in sysfs
889 * @transport: pointer to transport data
890 * @dd_size: total size to allocate
891 *
892 * Adds a sysfs entry for the flashnode session attributes
893 *
894 * Returns:
895 * pointer to allocated flashnode sess on sucess
896 * %NULL on failure
897 */
898struct iscsi_bus_flash_session *
899iscsi_create_flashnode_sess(struct Scsi_Host *shost, int index,
900 struct iscsi_transport *transport,
901 int dd_size)
902{
903 struct iscsi_bus_flash_session *fnode_sess;
904 int err;
905
906 fnode_sess = kzalloc(sizeof(*fnode_sess) + dd_size, GFP_KERNEL);
907 if (!fnode_sess)
908 return NULL;
909
910 fnode_sess->transport = transport;
911 fnode_sess->target_id = index;
912 fnode_sess->dev.type = &iscsi_flashnode_sess_dev_type;
913 fnode_sess->dev.bus = &iscsi_flashnode_bus;
914 fnode_sess->dev.parent = &shost->shost_gendev;
915 dev_set_name(&fnode_sess->dev, "flashnode_sess-%u:%u",
916 shost->host_no, index);
917
918 err = device_register(&fnode_sess->dev);
919 if (err)
920 goto free_fnode_sess;
921
922 if (dd_size)
923 fnode_sess->dd_data = &fnode_sess[1];
924
925 return fnode_sess;
926
927free_fnode_sess:
928 kfree(fnode_sess);
929 return NULL;
930}
931EXPORT_SYMBOL_GPL(iscsi_create_flashnode_sess);
932
933/**
934 * iscsi_create_flashnode_conn - Add flashnode conn entry in sysfs
935 * @shost: pointer to host data
936 * @fnode_sess: pointer to the parent flashnode session entry
937 * @transport: pointer to transport data
938 * @dd_size: total size to allocate
939 *
940 * Adds a sysfs entry for the flashnode connection attributes
941 *
942 * Returns:
943 * pointer to allocated flashnode conn on success
944 * %NULL on failure
945 */
946struct iscsi_bus_flash_conn *
947iscsi_create_flashnode_conn(struct Scsi_Host *shost,
948 struct iscsi_bus_flash_session *fnode_sess,
949 struct iscsi_transport *transport,
950 int dd_size)
951{
952 struct iscsi_bus_flash_conn *fnode_conn;
953 int err;
954
955 fnode_conn = kzalloc(sizeof(*fnode_conn) + dd_size, GFP_KERNEL);
956 if (!fnode_conn)
957 return NULL;
958
959 fnode_conn->transport = transport;
960 fnode_conn->dev.type = &iscsi_flashnode_conn_dev_type;
961 fnode_conn->dev.bus = &iscsi_flashnode_bus;
962 fnode_conn->dev.parent = &fnode_sess->dev;
963 dev_set_name(&fnode_conn->dev, "flashnode_conn-%u:%u:0",
964 shost->host_no, fnode_sess->target_id);
965
966 err = device_register(&fnode_conn->dev);
967 if (err)
968 goto free_fnode_conn;
969
970 if (dd_size)
971 fnode_conn->dd_data = &fnode_conn[1];
972
973 return fnode_conn;
974
975free_fnode_conn:
976 kfree(fnode_conn);
977 return NULL;
978}
979EXPORT_SYMBOL_GPL(iscsi_create_flashnode_conn);
980
981/**
982 * iscsi_is_flashnode_conn_dev - verify passed device is to be flashnode conn
983 * @dev: device to verify
984 * @data: pointer to data containing value to use for verification
985 *
986 * Verifies if the passed device is flashnode conn device
987 *
988 * Returns:
989 * 1 on success
990 * 0 on failure
991 */
992int iscsi_is_flashnode_conn_dev(struct device *dev, void *data)
993{
994 return dev->bus == &iscsi_flashnode_bus;
995}
996EXPORT_SYMBOL_GPL(iscsi_is_flashnode_conn_dev);
997
998static int iscsi_destroy_flashnode_conn(struct iscsi_bus_flash_conn *fnode_conn)
999{
1000 device_unregister(&fnode_conn->dev);
1001 return 0;
1002}
1003
1004static int flashnode_match_index(struct device *dev, void *data)
1005{
1006 struct iscsi_bus_flash_session *fnode_sess = NULL;
1007 int ret = 0;
1008
1009 if (!iscsi_flashnode_bus_match(dev, NULL))
1010 goto exit_match_index;
1011
1012 fnode_sess = iscsi_dev_to_flash_session(dev);
1013 ret = (fnode_sess->target_id == *((int *)data)) ? 1 : 0;
1014
1015exit_match_index:
1016 return ret;
1017}
1018
1019/**
1020 * iscsi_get_flashnode_by_index -finds flashnode session entry by index
1021 * @shost: pointer to host data
1022 * @data: pointer to data containing value to use for comparison
1023 * @fn: function pointer that does actual comparison
1024 *
1025 * Finds the flashnode session object for the passed index
1026 *
1027 * Returns:
1028 * pointer to found flashnode session object on success
1029 * %NULL on failure
1030 */
1031static struct iscsi_bus_flash_session *
1032iscsi_get_flashnode_by_index(struct Scsi_Host *shost, void *data,
1033 int (*fn)(struct device *dev, void *data))
1034{
1035 struct iscsi_bus_flash_session *fnode_sess = NULL;
1036 struct device *dev;
1037
1038 dev = device_find_child(&shost->shost_gendev, data, fn);
1039 if (dev)
1040 fnode_sess = iscsi_dev_to_flash_session(dev);
1041
1042 return fnode_sess;
1043}
1044
1045/**
1046 * iscsi_find_flashnode_sess - finds flashnode session entry
1047 * @shost: pointer to host data
1048 * @data: pointer to data containing value to use for comparison
1049 * @fn: function pointer that does actual comparison
1050 *
1051 * Finds the flashnode session object comparing the data passed using logic
1052 * defined in passed function pointer
1053 *
1054 * Returns:
1055 * pointer to found flashnode session device object on success
1056 * %NULL on failure
1057 */
1058struct device *
1059iscsi_find_flashnode_sess(struct Scsi_Host *shost, void *data,
1060 int (*fn)(struct device *dev, void *data))
1061{
1062 struct device *dev;
1063
1064 dev = device_find_child(&shost->shost_gendev, data, fn);
1065 return dev;
1066}
1067EXPORT_SYMBOL_GPL(iscsi_find_flashnode_sess);
1068
1069/**
1070 * iscsi_find_flashnode_conn - finds flashnode connection entry
1071 * @fnode_sess: pointer to parent flashnode session entry
1072 * @data: pointer to data containing value to use for comparison
1073 * @fn: function pointer that does actual comparison
1074 *
1075 * Finds the flashnode connection object comparing the data passed using logic
1076 * defined in passed function pointer
1077 *
1078 * Returns:
1079 * pointer to found flashnode connection device object on success
1080 * %NULL on failure
1081 */
1082struct device *
1083iscsi_find_flashnode_conn(struct iscsi_bus_flash_session *fnode_sess,
1084 void *data,
1085 int (*fn)(struct device *dev, void *data))
1086{
1087 struct device *dev;
1088
1089 dev = device_find_child(&fnode_sess->dev, data, fn);
1090 return dev;
1091}
1092EXPORT_SYMBOL_GPL(iscsi_find_flashnode_conn);
1093
1094static int iscsi_iter_destroy_flashnode_conn_fn(struct device *dev, void *data)
1095{
1096 if (!iscsi_is_flashnode_conn_dev(dev, NULL))
1097 return 0;
1098
1099 return iscsi_destroy_flashnode_conn(iscsi_dev_to_flash_conn(dev));
1100}
1101
1102/**
1103 * iscsi_destroy_flashnode_sess - destory flashnode session entry
1104 * @fnode_sess: pointer to flashnode session entry to be destroyed
1105 *
1106 * Deletes the flashnode session entry and all children flashnode connection
1107 * entries from sysfs
1108 */
1109void iscsi_destroy_flashnode_sess(struct iscsi_bus_flash_session *fnode_sess)
1110{
1111 int err;
1112
1113 err = device_for_each_child(&fnode_sess->dev, NULL,
1114 iscsi_iter_destroy_flashnode_conn_fn);
1115 if (err)
1116 pr_err("Could not delete all connections for %s. Error %d.\n",
1117 fnode_sess->dev.kobj.name, err);
1118
1119 device_unregister(&fnode_sess->dev);
1120}
1121EXPORT_SYMBOL_GPL(iscsi_destroy_flashnode_sess);
1122
1123static int iscsi_iter_destroy_flashnode_fn(struct device *dev, void *data)
1124{
1125 if (!iscsi_flashnode_bus_match(dev, NULL))
1126 return 0;
1127
1128 iscsi_destroy_flashnode_sess(iscsi_dev_to_flash_session(dev));
1129 return 0;
1130}
1131
1132/**
1133 * iscsi_destroy_all_flashnode - destory all flashnode session entries
1134 * @shost: pointer to host data
1135 *
1136 * Destroys all the flashnode session entries and all corresponding children
1137 * flashnode connection entries from sysfs
1138 */
1139void iscsi_destroy_all_flashnode(struct Scsi_Host *shost)
1140{
1141 device_for_each_child(&shost->shost_gendev, NULL,
1142 iscsi_iter_destroy_flashnode_fn);
1143}
1144EXPORT_SYMBOL_GPL(iscsi_destroy_all_flashnode);
1145
90eeb01a
MC		 1146/*
1147 * BSG support
1148 */
1149/**
1150 * iscsi_bsg_host_dispatch - Dispatch command to LLD.
1151 * @job: bsg job to be processed
1152 */
1153static int iscsi_bsg_host_dispatch(struct bsg_job *job)
1154{
1155 struct Scsi_Host *shost = iscsi_job_to_shost(job);
1156 struct iscsi_bsg_request *req = job->request;
1157 struct iscsi_bsg_reply *reply = job->reply;
1158 struct iscsi_internal *i = to_iscsi_internal(shost->transportt);
1159 int cmdlen = sizeof(uint32_t); /* start with length of msgcode */
1160 int ret;
1161
1162 /* check if we have the msgcode value at least */
1163 if (job->request_len < sizeof(uint32_t)) {
1164 ret = -ENOMSG;
1165 goto fail_host_msg;
1166 }
1167
1168 /* Validate the host command */
1169 switch (req->msgcode) {
1170 case ISCSI_BSG_HST_VENDOR:
1171 cmdlen += sizeof(struct iscsi_bsg_host_vendor);
1172 if ((shost->hostt->vendor_id == 0L) ||
1173 (req->rqst_data.h_vendor.vendor_id !=
1174 shost->hostt->vendor_id)) {
1175 ret = -ESRCH;
1176 goto fail_host_msg;
1177 }
1178 break;
1179 default:
1180 ret = -EBADR;
1181 goto fail_host_msg;
1182 }
1183
1184 /* check if we really have all the request data needed */
1185 if (job->request_len < cmdlen) {
1186 ret = -ENOMSG;
1187 goto fail_host_msg;
1188 }
1189
1190 ret = i->iscsi_transport->bsg_request(job);
1191 if (!ret)
1192 return 0;
1193
1194fail_host_msg:
1195 /* return the errno failure code as the only status */
1196 BUG_ON(job->reply_len < sizeof(uint32_t));
1197 reply->reply_payload_rcv_len = 0;
1198 reply->result = ret;
1199 job->reply_len = sizeof(uint32_t);
1200 bsg_job_done(job, ret, 0);
1201 return 0;
1202}
1203
1204/**
1205 * iscsi_bsg_host_add - Create and add the bsg hooks to receive requests
1206 * @shost: shost for iscsi_host
eae627e4 1207 * @ihost: iscsi_cls_host adding the structures to
90eeb01a
MC		 1208 */
1209static int
1210iscsi_bsg_host_add(struct Scsi_Host *shost, struct iscsi_cls_host *ihost)
1211{
1212 struct device *dev = &shost->shost_gendev;
1213 struct iscsi_internal *i = to_iscsi_internal(shost->transportt);
1214 struct request_queue *q;
1215 char bsg_name[20];
1216 int ret;
1217
1218 if (!i->iscsi_transport->bsg_request)
1219 return -ENOTSUPP;
1220
1221 snprintf(bsg_name, sizeof(bsg_name), "iscsi_host%d", shost->host_no);
1222
1223 q = __scsi_alloc_queue(shost, bsg_request_fn);
1224 if (!q)
1225 return -ENOMEM;
1226
1227 ret = bsg_setup_queue(dev, q, bsg_name, iscsi_bsg_host_dispatch, 0);
1228 if (ret) {
1229 shost_printk(KERN_ERR, shost, "bsg interface failed to "
1230 "initialize - no request queue\n");
1231 blk_cleanup_queue(q);
1232 return ret;
1233 }
1234
1235 ihost->bsg_q = q;
1236 return 0;
1237}
1238
30a6c652 1239static int iscsi_setup_host(struct transport_container *tc, struct device *dev,
ee959b00 1240 struct device *cdev)
30a6c652
MC		 1241{
1242 struct Scsi_Host *shost = dev_to_shost(dev);
32c6e1b9 1243 struct iscsi_cls_host *ihost = shost->shost_data;
30a6c652
MC		 1244
1245 memset(ihost, 0, sizeof(*ihost));
8aae18ad 1246 atomic_set(&ihost->nr_scans, 0);
7970634b 1247 mutex_init(&ihost->mutex);
90eeb01a
MC		 1248
1249 iscsi_bsg_host_add(shost, ihost);
1250 /* ignore any bsg add error - we just can't do sgio */
1251
1252 return 0;
1253}
1254
1255static int iscsi_remove_host(struct transport_container *tc,
1256 struct device *dev, struct device *cdev)
1257{
1258 struct Scsi_Host *shost = dev_to_shost(dev);
1259 struct iscsi_cls_host *ihost = shost->shost_data;
1260
1261 if (ihost->bsg_q) {
86072d81 1262 bsg_unregister_queue(ihost->bsg_q);
90eeb01a
MC		 1263 blk_cleanup_queue(ihost->bsg_q);
1264 }
30a6c652
MC		 1265 return 0;
1266}
1267
1268static DECLARE_TRANSPORT_CLASS(iscsi_host_class,
1269 "iscsi_host",
1270 iscsi_setup_host,
90eeb01a 1271 iscsi_remove_host,
30a6c652
MC		 1272 NULL);
1273
0896b752
AA		 1274static DECLARE_TRANSPORT_CLASS(iscsi_session_class,
1275 "iscsi_session",
1da177e4
LT		 1276 NULL,
1277 NULL,
1278 NULL);
1279
0896b752
AA		 1280static DECLARE_TRANSPORT_CLASS(iscsi_connection_class,
1281 "iscsi_connection",
1da177e4
LT		 1282 NULL,
1283 NULL,
1284 NULL);
0896b752
AA		 1285
1286static struct sock *nls;
0b950672 1287static DEFINE_MUTEX(rx_queue_mutex);
0896b752 1288
7b7232f3
MC		 1289static LIST_HEAD(sesslist);
1290static DEFINE_SPINLOCK(sesslock);
7b8631b5
MC		 1291static LIST_HEAD(connlist);
1292static DEFINE_SPINLOCK(connlock);
0896b752 1293
b5c7a12d
MC		 1294static uint32_t iscsi_conn_get_sid(struct iscsi_cls_conn *conn)
1295{
1296 struct iscsi_cls_session *sess = iscsi_dev_to_session(conn->dev.parent);
1297 return sess->sid;
1298}
1299
1300/*
1301 * Returns the matching session to a given sid
1302 */
1303static struct iscsi_cls_session *iscsi_session_lookup(uint32_t sid)
7b7232f3
MC		 1304{
1305 unsigned long flags;
1306 struct iscsi_cls_session *sess;
1307
1308 spin_lock_irqsave(&sesslock, flags);
1309 list_for_each_entry(sess, &sesslist, sess_list) {
b5c7a12d 1310 if (sess->sid == sid) {
7b7232f3
MC		 1311 spin_unlock_irqrestore(&sesslock, flags);
1312 return sess;
1313 }
1314 }
1315 spin_unlock_irqrestore(&sesslock, flags);
1316 return NULL;
1317}
1318
b5c7a12d
MC		 1319/*
1320 * Returns the matching connection to a given sid / cid tuple
1321 */
1322static struct iscsi_cls_conn *iscsi_conn_lookup(uint32_t sid, uint32_t cid)
7b7232f3
MC		 1323{
1324 unsigned long flags;
1325 struct iscsi_cls_conn *conn;
1326
1327 spin_lock_irqsave(&connlock, flags);
1328 list_for_each_entry(conn, &connlist, conn_list) {
b5c7a12d 1329 if ((conn->cid == cid) && (iscsi_conn_get_sid(conn) == sid)) {
7b7232f3
MC		 1330 spin_unlock_irqrestore(&connlock, flags);
1331 return conn;
1332 }
1333 }
1334 spin_unlock_irqrestore(&connlock, flags);
1335 return NULL;
1336}
1337
7b8631b5
MC		 1338/*
1339 * The following functions can be used by LLDs that allocate
1340 * their own scsi_hosts or by software iscsi LLDs
1341 */
6eabafbe
MC		 1342static struct {
1343 int value;
1344 char *name;
1345} iscsi_session_state_names[] = {
1346 { ISCSI_SESSION_LOGGED_IN, "LOGGED_IN" },
1347 { ISCSI_SESSION_FAILED, "FAILED" },
1348 { ISCSI_SESSION_FREE, "FREE" },
1349};
1350
3b0f208a 1351static const char *iscsi_session_state_name(int state)
6eabafbe
MC		 1352{
1353 int i;
1354 char *name = NULL;
1355
1356 for (i = 0; i < ARRAY_SIZE(iscsi_session_state_names); i++) {
1357 if (iscsi_session_state_names[i].value == state) {
1358 name = iscsi_session_state_names[i].name;
1359 break;
1360 }
1361 }
1362 return name;
1363}
1364
1365int iscsi_session_chkready(struct iscsi_cls_session *session)
1366{
1367 unsigned long flags;
1368 int err;
1369
1370 spin_lock_irqsave(&session->lock, flags);
1371 switch (session->state) {
1372 case ISCSI_SESSION_LOGGED_IN:
1373 err = 0;
1374 break;
1375 case ISCSI_SESSION_FAILED:
9a1a69a1 1376 err = DID_IMM_RETRY << 16;
6eabafbe
MC		 1377 break;
1378 case ISCSI_SESSION_FREE:
56d7fcfa 1379 err = DID_TRANSPORT_FAILFAST << 16;
6eabafbe
MC		 1380 break;
1381 default:
1382 err = DID_NO_CONNECT << 16;
1383 break;
1384 }
1385 spin_unlock_irqrestore(&session->lock, flags);
1386 return err;
1387}
1388EXPORT_SYMBOL_GPL(iscsi_session_chkready);
1389
17fa575e
MR		 1390int iscsi_is_session_online(struct iscsi_cls_session *session)
1391{
1392 unsigned long flags;
1393 int ret = 0;
1394
1395 spin_lock_irqsave(&session->lock, flags);
1396 if (session->state == ISCSI_SESSION_LOGGED_IN)
1397 ret = 1;
1398 spin_unlock_irqrestore(&session->lock, flags);
1399 return ret;
1400}
1401EXPORT_SYMBOL_GPL(iscsi_is_session_online);
1402
7b8631b5
MC		 1403static void iscsi_session_release(struct device *dev)
1404{
1405 struct iscsi_cls_session *session = iscsi_dev_to_session(dev);
7b8631b5 1406 struct Scsi_Host *shost;
0896b752 1407
7b8631b5
MC		 1408 shost = iscsi_session_to_shost(session);
1409 scsi_host_put(shost);
632248aa 1410 ISCSI_DBG_TRANS_SESSION(session, "Completing session release\n");
7b8631b5 1411 kfree(session);
7b8631b5 1412}
0896b752 1413
6260a5d2 1414int iscsi_is_session_dev(const struct device *dev)
7b8631b5
MC		 1415{
1416 return dev->release == iscsi_session_release;
1417}
6260a5d2 1418EXPORT_SYMBOL_GPL(iscsi_is_session_dev);
0896b752 1419
a4804cd6
MC		 1420static int iscsi_iter_session_fn(struct device *dev, void *data)
1421{
1422 void (* fn) (struct iscsi_cls_session *) = data;
1423
1424 if (!iscsi_is_session_dev(dev))
1425 return 0;
1426 fn(iscsi_dev_to_session(dev));
1427 return 0;
1428}
1429
1430void iscsi_host_for_each_session(struct Scsi_Host *shost,
1431 void (*fn)(struct iscsi_cls_session *))
1432{
1433 device_for_each_child(&shost->shost_gendev, fn,
1434 iscsi_iter_session_fn);
1435}
1436EXPORT_SYMBOL_GPL(iscsi_host_for_each_session);
1437
8aae18ad
MC		 1438/**
1439 * iscsi_scan_finished - helper to report when running scans are done
1440 * @shost: scsi host
1441 * @time: scan run time
1442 *
1443 * This function can be used by drives like qla4xxx to report to the scsi
1444 * layer when the scans it kicked off at module load time are done.
1445 */
1446int iscsi_scan_finished(struct Scsi_Host *shost, unsigned long time)
1447{
32c6e1b9 1448 struct iscsi_cls_host *ihost = shost->shost_data;
8aae18ad
MC		 1449 /*
1450 * qla4xxx will have kicked off some session unblocks before calling
1451 * scsi_scan_host, so just wait for them to complete.
1452 */
1453 return !atomic_read(&ihost->nr_scans);
1454}
1455EXPORT_SYMBOL_GPL(iscsi_scan_finished);
1456
7970634b
MC		 1457struct iscsi_scan_data {
1458 unsigned int channel;
1459 unsigned int id;
1460 unsigned int lun;
1461};
1462
1463static int iscsi_user_scan_session(struct device *dev, void *data)
30a6c652 1464{
7970634b 1465 struct iscsi_scan_data *scan_data = data;
30a6c652 1466 struct iscsi_cls_session *session;
7970634b
MC		 1467 struct Scsi_Host *shost;
1468 struct iscsi_cls_host *ihost;
1469 unsigned long flags;
1470 unsigned int id;
1471
1472 if (!iscsi_is_session_dev(dev))
1473 return 0;
1474
1475 session = iscsi_dev_to_session(dev);
632248aa
MC		 1476
1477 ISCSI_DBG_TRANS_SESSION(session, "Scanning session\n");
1478
7970634b
MC		 1479 shost = iscsi_session_to_shost(session);
1480 ihost = shost->shost_data;
30a6c652
MC		 1481
1482 mutex_lock(&ihost->mutex);
7970634b
MC		 1483 spin_lock_irqsave(&session->lock, flags);
1484 if (session->state != ISCSI_SESSION_LOGGED_IN) {
1485 spin_unlock_irqrestore(&session->lock, flags);
632248aa 1486 goto user_scan_exit;
30a6c652 1487 }
7970634b
MC		 1488 id = session->target_id;
1489 spin_unlock_irqrestore(&session->lock, flags);
30a6c652 1490
7970634b
MC		 1491 if (id != ISCSI_MAX_TARGET) {
1492 if ((scan_data->channel == SCAN_WILD_CARD ||
1493 scan_data->channel == 0) &&
1494 (scan_data->id == SCAN_WILD_CARD ||
1495 scan_data->id == id))
1496 scsi_scan_target(&session->dev, 0, id,
1497 scan_data->lun, 1);
1498 }
632248aa
MC		 1499
1500user_scan_exit:
7970634b 1501 mutex_unlock(&ihost->mutex);
632248aa 1502 ISCSI_DBG_TRANS_SESSION(session, "Completed session scan\n");
30a6c652
MC		 1503 return 0;
1504}
1505
7970634b
MC		 1506static int iscsi_user_scan(struct Scsi_Host *shost, uint channel,
1507 uint id, uint lun)
1508{
1509 struct iscsi_scan_data scan_data;
1510
1511 scan_data.channel = channel;
1512 scan_data.id = id;
1513 scan_data.lun = lun;
1514
1515 return device_for_each_child(&shost->shost_gendev, &scan_data,
1516 iscsi_user_scan_session);
1517}
1518
bd976f62
MC		 1519static void iscsi_scan_session(struct work_struct *work)
1520{
1521 struct iscsi_cls_session *session =
1522 container_of(work, struct iscsi_cls_session, scan_work);
8aae18ad 1523 struct Scsi_Host *shost = iscsi_session_to_shost(session);
32c6e1b9 1524 struct iscsi_cls_host *ihost = shost->shost_data;
7970634b 1525 struct iscsi_scan_data scan_data;
bd976f62 1526
7970634b
MC		 1527 scan_data.channel = 0;
1528 scan_data.id = SCAN_WILD_CARD;
1529 scan_data.lun = SCAN_WILD_CARD;
bd976f62 1530
7970634b 1531 iscsi_user_scan_session(&session->dev, &scan_data);
8aae18ad 1532 atomic_dec(&ihost->nr_scans);
bd976f62
MC		 1533}
1534
c01be6dc
MC		 1535/**
1536 * iscsi_block_scsi_eh - block scsi eh until session state has transistioned
e6d4ef45 1537 * @cmd: scsi cmd passed to scsi eh handler
c01be6dc
MC		 1538 *
1539 * If the session is down this function will wait for the recovery
1540 * timer to fire or for the session to be logged back in. If the
1541 * recovery timer fires then FAST_IO_FAIL is returned. The caller
1542 * should pass this error value to the scsi eh.
1543 */
1544int iscsi_block_scsi_eh(struct scsi_cmnd *cmd)
1545{
1546 struct iscsi_cls_session *session =
1547 starget_to_session(scsi_target(cmd->device));
1548 unsigned long flags;
1549 int ret = 0;
1550
1551 spin_lock_irqsave(&session->lock, flags);
1552 while (session->state != ISCSI_SESSION_LOGGED_IN) {
1553 if (session->state == ISCSI_SESSION_FREE) {
1554 ret = FAST_IO_FAIL;
1555 break;
1556 }
1557 spin_unlock_irqrestore(&session->lock, flags);
1558 msleep(1000);
1559 spin_lock_irqsave(&session->lock, flags);
1560 }
1561 spin_unlock_irqrestore(&session->lock, flags);
1562 return ret;
1563}
1564EXPORT_SYMBOL_GPL(iscsi_block_scsi_eh);
1565
c4028958 1566static void session_recovery_timedout(struct work_struct *work)
30a6c652 1567{
c4028958
DH		 1568 struct iscsi_cls_session *session =
1569 container_of(work, struct iscsi_cls_session,
1570 recovery_work.work);
6eabafbe 1571 unsigned long flags;
30a6c652 1572
322d739d
MC		 1573 iscsi_cls_session_printk(KERN_INFO, session,
1574 "session recovery timed out after %d secs\n",
1575 session->recovery_tmo);
30a6c652 1576
6eabafbe
MC		 1577 spin_lock_irqsave(&session->lock, flags);
1578 switch (session->state) {
1579 case ISCSI_SESSION_FAILED:
1580 session->state = ISCSI_SESSION_FREE;
1581 break;
1582 case ISCSI_SESSION_LOGGED_IN:
1583 case ISCSI_SESSION_FREE:
1584 /* we raced with the unblock's flush */
1585 spin_unlock_irqrestore(&session->lock, flags);
1586 return;
1587 }
1588 spin_unlock_irqrestore(&session->lock, flags);
1589
30a6c652
MC		 1590 if (session->transport->session_recovery_timedout)
1591 session->transport->session_recovery_timedout(session);
1592
632248aa 1593 ISCSI_DBG_TRANS_SESSION(session, "Unblocking SCSI target\n");
5d9fb5cc 1594 scsi_target_unblock(&session->dev, SDEV_TRANSPORT_OFFLINE);
632248aa 1595 ISCSI_DBG_TRANS_SESSION(session, "Completed unblocking SCSI target\n");
30a6c652
MC		 1596}
1597
45ab33b6 1598static void __iscsi_unblock_session(struct work_struct *work)
6eabafbe 1599{
45ab33b6
MC		 1600 struct iscsi_cls_session *session =
1601 container_of(work, struct iscsi_cls_session,
1602 unblock_work);
bd976f62 1603 struct Scsi_Host *shost = iscsi_session_to_shost(session);
32c6e1b9 1604 struct iscsi_cls_host *ihost = shost->shost_data;
6eabafbe
MC		 1605 unsigned long flags;
1606
632248aa 1607 ISCSI_DBG_TRANS_SESSION(session, "Unblocking session\n");
45ab33b6
MC		 1608 /*
1609 * The recovery and unblock work get run from the same workqueue,
1610 * so try to cancel it if it was going to run after this unblock.
1611 */
1612 cancel_delayed_work(&session->recovery_work);
6eabafbe
MC		 1613 spin_lock_irqsave(&session->lock, flags);
1614 session->state = ISCSI_SESSION_LOGGED_IN;
1615 spin_unlock_irqrestore(&session->lock, flags);
45ab33b6 1616 /* start IO */
5d9fb5cc 1617 scsi_target_unblock(&session->dev, SDEV_RUNNING);
8aae18ad
MC		 1618 /*
1619 * Only do kernel scanning if the driver is properly hooked into
1620 * the async scanning code (drivers like iscsi_tcp do login and
1621 * scanning from userspace).
1622 */
1623 if (shost->hostt->scan_finished) {
06d25af4 1624 if (scsi_queue_work(shost, &session->scan_work))
8aae18ad
MC		 1625 atomic_inc(&ihost->nr_scans);
1626 }
632248aa 1627 ISCSI_DBG_TRANS_SESSION(session, "Completed unblocking session\n");
6eabafbe 1628}
45ab33b6
MC		 1629
1630/**
1631 * iscsi_unblock_session - set a session as logged in and start IO.
1632 * @session: iscsi session
1633 *
1634 * Mark a session as ready to accept IO.
1635 */
1636void iscsi_unblock_session(struct iscsi_cls_session *session)
1637{
1638 queue_work(iscsi_eh_timer_workq, &session->unblock_work);
1639 /*
1640 * make sure all the events have completed before tell the driver
1641 * it is safe
1642 */
1643 flush_workqueue(iscsi_eh_timer_workq);
1644}
30a6c652
MC		 1645EXPORT_SYMBOL_GPL(iscsi_unblock_session);
1646
45ab33b6 1647static void __iscsi_block_session(struct work_struct *work)
30a6c652 1648{
45ab33b6
MC		 1649 struct iscsi_cls_session *session =
1650 container_of(work, struct iscsi_cls_session,
1651 block_work);
6eabafbe
MC		 1652 unsigned long flags;
1653
632248aa 1654 ISCSI_DBG_TRANS_SESSION(session, "Blocking session\n");
6eabafbe
MC		 1655 spin_lock_irqsave(&session->lock, flags);
1656 session->state = ISCSI_SESSION_FAILED;
1657 spin_unlock_irqrestore(&session->lock, flags);
30a6c652 1658 scsi_target_block(&session->dev);
632248aa 1659 ISCSI_DBG_TRANS_SESSION(session, "Completed SCSI target blocking\n");
fdd46dcb
MC		 1660 if (session->recovery_tmo >= 0)
1661 queue_delayed_work(iscsi_eh_timer_workq,
1662 &session->recovery_work,
1663 session->recovery_tmo * HZ);
30a6c652 1664}
45ab33b6
MC		 1665
1666void iscsi_block_session(struct iscsi_cls_session *session)
1667{
1668 queue_work(iscsi_eh_timer_workq, &session->block_work);
1669}
30a6c652
MC		 1670EXPORT_SYMBOL_GPL(iscsi_block_session);
1671
26974789
MC		 1672static void __iscsi_unbind_session(struct work_struct *work)
1673{
1674 struct iscsi_cls_session *session =
1675 container_of(work, struct iscsi_cls_session,
1676 unbind_work);
1677 struct Scsi_Host *shost = iscsi_session_to_shost(session);
32c6e1b9 1678 struct iscsi_cls_host *ihost = shost->shost_data;
7970634b 1679 unsigned long flags;
8d4a690c 1680 unsigned int target_id;
26974789 1681
632248aa
MC		 1682 ISCSI_DBG_TRANS_SESSION(session, "Unbinding session\n");
1683
26974789
MC		 1684 /* Prevent new scans and make sure scanning is not in progress */
1685 mutex_lock(&ihost->mutex);
7970634b
MC		 1686 spin_lock_irqsave(&session->lock, flags);
1687 if (session->target_id == ISCSI_MAX_TARGET) {
1688 spin_unlock_irqrestore(&session->lock, flags);
26974789
MC		 1689 mutex_unlock(&ihost->mutex);
1690 return;
1691 }
8d4a690c
MC		 1692
1693 target_id = session->target_id;
7970634b
MC		 1694 session->target_id = ISCSI_MAX_TARGET;
1695 spin_unlock_irqrestore(&session->lock, flags);
26974789
MC		 1696 mutex_unlock(&ihost->mutex);
1697
8d4a690c
MC		 1698 if (session->ida_used)
1699 ida_simple_remove(&iscsi_sess_ida, target_id);
1700
26974789
MC		 1701 scsi_remove_target(&session->dev);
1702 iscsi_session_event(session, ISCSI_KEVENT_UNBIND_SESSION);
632248aa 1703 ISCSI_DBG_TRANS_SESSION(session, "Completed target removal\n");
26974789
MC		 1704}
1705
7b8631b5 1706struct iscsi_cls_session *
5d91e209
MC		 1707iscsi_alloc_session(struct Scsi_Host *shost, struct iscsi_transport *transport,
1708 int dd_size)
7b8631b5
MC		 1709{
1710 struct iscsi_cls_session *session;
7b8631b5 1711
5d91e209 1712 session = kzalloc(sizeof(*session) + dd_size,
b5c7a12d 1713 GFP_KERNEL);
7b8631b5 1714 if (!session)
f53a88da
MC		 1715 return NULL;
1716
7b8631b5 1717 session->transport = transport;
0c70d84b 1718 session->creator = -1;
30a6c652 1719 session->recovery_tmo = 120;
6eabafbe 1720 session->state = ISCSI_SESSION_FREE;
c4028958 1721 INIT_DELAYED_WORK(&session->recovery_work, session_recovery_timedout);
30a6c652 1722 INIT_LIST_HEAD(&session->sess_list);
45ab33b6
MC		 1723 INIT_WORK(&session->unblock_work, __iscsi_unblock_session);
1724 INIT_WORK(&session->block_work, __iscsi_block_session);
26974789 1725 INIT_WORK(&session->unbind_work, __iscsi_unbind_session);
bd976f62 1726 INIT_WORK(&session->scan_work, iscsi_scan_session);
6eabafbe 1727 spin_lock_init(&session->lock);
7b8631b5 1728
6a8a0d36
MC		 1729 /* this is released in the dev's release function */
1730 scsi_host_get(shost);
8434aa8b
MC		 1731 session->dev.parent = &shost->shost_gendev;
1732 session->dev.release = iscsi_session_release;
1733 device_initialize(&session->dev);
5d91e209 1734 if (dd_size)
b5c7a12d 1735 session->dd_data = &session[1];
632248aa
MC		 1736
1737 ISCSI_DBG_TRANS_SESSION(session, "Completed session allocation\n");
8434aa8b
MC		 1738 return session;
1739}
1740EXPORT_SYMBOL_GPL(iscsi_alloc_session);
1741
6a8a0d36 1742int iscsi_add_session(struct iscsi_cls_session *session, unsigned int target_id)
8434aa8b
MC		 1743{
1744 struct Scsi_Host *shost = iscsi_session_to_shost(session);
32c6e1b9 1745 struct iscsi_cls_host *ihost;
26974789 1746 unsigned long flags;
8d4a690c 1747 int id = 0;
8434aa8b 1748 int err;
b5c7a12d 1749
30a6c652 1750 ihost = shost->shost_data;
41be1444 1751 session->sid = atomic_add_return(1, &iscsi_session_nr);
7970634b 1752
8d4a690c
MC		 1753 if (target_id == ISCSI_MAX_TARGET) {
1754 id = ida_simple_get(&iscsi_sess_ida, 0, 0, GFP_KERNEL);
7970634b 1755
8d4a690c 1756 if (id < 0) {
7970634b 1757 iscsi_cls_session_printk(KERN_ERR, session,
8d4a690c
MC		 1758 "Failure in Target ID Allocation\n");
1759 return id;
7970634b 1760 }
8d4a690c
MC		 1761 session->target_id = (unsigned int)id;
1762 session->ida_used = true;
1763 } else
1764 session->target_id = target_id;
30a6c652 1765
71610f55 1766 dev_set_name(&session->dev, "session%u", session->sid);
8434aa8b 1767 err = device_add(&session->dev);
7b8631b5 1768 if (err) {
322d739d
MC		 1769 iscsi_cls_session_printk(KERN_ERR, session,
1770 "could not register session's dev\n");
8d4a690c 1771 goto release_ida;
7b8631b5
MC		 1772 }
1773 transport_register_device(&session->dev);
1774
26974789
MC		 1775 spin_lock_irqsave(&sesslock, flags);
1776 list_add(&session->sess_list, &sesslist);
1777 spin_unlock_irqrestore(&sesslock, flags);
1778
26974789 1779 iscsi_session_event(session, ISCSI_KEVENT_CREATE_SESSION);
632248aa 1780 ISCSI_DBG_TRANS_SESSION(session, "Completed session adding\n");
8434aa8b 1781 return 0;
30a6c652 1782
8d4a690c
MC		 1783release_ida:
1784 if (session->ida_used)
1785 ida_simple_remove(&iscsi_sess_ida, session->target_id);
1786
8434aa8b 1787 return err;
7b8631b5 1788}
8434aa8b 1789EXPORT_SYMBOL_GPL(iscsi_add_session);
7b8631b5
MC		 1790
1791/**
8434aa8b
MC		 1792 * iscsi_create_session - create iscsi class session
1793 * @shost: scsi host
1794 * @transport: iscsi transport
5d91e209 1795 * @dd_size: private driver data size
eb44820c 1796 * @target_id: which target
7b8631b5 1797 *
8434aa8b 1798 * This can be called from a LLD or iscsi_transport.
eb44820c 1799 */
8434aa8b 1800struct iscsi_cls_session *
5d91e209
MC		 1801iscsi_create_session(struct Scsi_Host *shost, struct iscsi_transport *transport,
1802 int dd_size, unsigned int target_id)
8434aa8b
MC		 1803{
1804 struct iscsi_cls_session *session;
1805
5d91e209 1806 session = iscsi_alloc_session(shost, transport, dd_size);
8434aa8b
MC		 1807 if (!session)
1808 return NULL;
1809
6a8a0d36 1810 if (iscsi_add_session(session, target_id)) {
8434aa8b
MC		 1811 iscsi_free_session(session);
1812 return NULL;
1813 }
1814 return session;
1815}
1816EXPORT_SYMBOL_GPL(iscsi_create_session);
1817
26974789
MC		 1818static void iscsi_conn_release(struct device *dev)
1819{
1820 struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev);
1821 struct device *parent = conn->dev.parent;
1822
632248aa 1823 ISCSI_DBG_TRANS_CONN(conn, "Releasing conn\n");
26974789
MC		 1824 kfree(conn);
1825 put_device(parent);
1826}
1827
1828static int iscsi_is_conn_dev(const struct device *dev)
1829{
1830 return dev->release == iscsi_conn_release;
1831}
1832
1833static int iscsi_iter_destroy_conn_fn(struct device *dev, void *data)
1834{
1835 if (!iscsi_is_conn_dev(dev))
1836 return 0;
1837 return iscsi_destroy_conn(iscsi_dev_to_conn(dev));
1838}
1839
8434aa8b 1840void iscsi_remove_session(struct iscsi_cls_session *session)
7b8631b5 1841{
30a6c652 1842 struct Scsi_Host *shost = iscsi_session_to_shost(session);
26974789
MC		 1843 unsigned long flags;
1844 int err;
1845
632248aa
MC		 1846 ISCSI_DBG_TRANS_SESSION(session, "Removing session\n");
1847
26974789
MC		 1848 spin_lock_irqsave(&sesslock, flags);
1849 list_del(&session->sess_list);
1850 spin_unlock_irqrestore(&sesslock, flags);
30a6c652 1851
45ab33b6
MC		 1852 /* make sure there are no blocks/unblocks queued */
1853 flush_workqueue(iscsi_eh_timer_workq);
1854 /* make sure the timedout callout is not running */
1855 if (!cancel_delayed_work(&session->recovery_work))
1856 flush_workqueue(iscsi_eh_timer_workq);
26974789
MC		 1857 /*
1858 * If we are blocked let commands flow again. The lld or iscsi
1859 * layer should set up the queuecommand to fail commands.
45ab33b6
MC		 1860 * We assume that LLD will not be calling block/unblock while
1861 * removing the session.
26974789 1862 */
6eabafbe
MC		 1863 spin_lock_irqsave(&session->lock, flags);
1864 session->state = ISCSI_SESSION_FREE;
1865 spin_unlock_irqrestore(&session->lock, flags);
bd976f62 1866
5d9fb5cc 1867 scsi_target_unblock(&session->dev, SDEV_TRANSPORT_OFFLINE);
45ab33b6 1868 /* flush running scans then delete devices */
06d25af4 1869 scsi_flush_work(shost);
45ab33b6 1870 __iscsi_unbind_session(&session->unbind_work);
30a6c652 1871
26974789
MC		 1872 /* hw iscsi may not have removed all connections from session */
1873 err = device_for_each_child(&session->dev, NULL,
1874 iscsi_iter_destroy_conn_fn);
1875 if (err)
322d739d
MC		 1876 iscsi_cls_session_printk(KERN_ERR, session,
1877 "Could not delete all connections "
1878 "for session. Error %d.\n", err);
8434aa8b 1879
7b8631b5 1880 transport_unregister_device(&session->dev);
632248aa
MC		 1881
1882 ISCSI_DBG_TRANS_SESSION(session, "Completing session removal\n");
8434aa8b
MC		 1883 device_del(&session->dev);
1884}
1885EXPORT_SYMBOL_GPL(iscsi_remove_session);
1886
1887void iscsi_free_session(struct iscsi_cls_session *session)
1888{
632248aa 1889 ISCSI_DBG_TRANS_SESSION(session, "Freeing session\n");
26974789 1890 iscsi_session_event(session, ISCSI_KEVENT_DESTROY_SESSION);
8434aa8b 1891 put_device(&session->dev);
7b8631b5 1892}
8434aa8b
MC		 1893EXPORT_SYMBOL_GPL(iscsi_free_session);
1894
1895/**
1896 * iscsi_destroy_session - destroy iscsi session
1897 * @session: iscsi_session
1898 *
1899 * Can be called by a LLD or iscsi_transport. There must not be
1900 * any running connections.
eb44820c 1901 */
8434aa8b
MC		 1902int iscsi_destroy_session(struct iscsi_cls_session *session)
1903{
1904 iscsi_remove_session(session);
632248aa 1905 ISCSI_DBG_TRANS_SESSION(session, "Completing session destruction\n");
8434aa8b
MC		 1906 iscsi_free_session(session);
1907 return 0;
1908}
7b8631b5
MC		 1909EXPORT_SYMBOL_GPL(iscsi_destroy_session);
1910
7b8631b5
MC		 1911/**
1912 * iscsi_create_conn - create iscsi class connection
1913 * @session: iscsi cls session
5d91e209 1914 * @dd_size: private driver data size
7b8631b5
MC		 1915 * @cid: connection id
1916 *
1917 * This can be called from a LLD or iscsi_transport. The connection
1918 * is child of the session so cid must be unique for all connections
1919 * on the session.
b5c7a12d
MC		 1920 *
1921 * Since we do not support MCS, cid will normally be zero. In some cases
1922 * for software iscsi we could be trying to preallocate a connection struct
1923 * in which case there could be two connection structs and cid would be
1924 * non-zero.
eb44820c 1925 */
7b8631b5 1926struct iscsi_cls_conn *
5d91e209 1927iscsi_create_conn(struct iscsi_cls_session *session, int dd_size, uint32_t cid)
7b8631b5
MC		 1928{
1929 struct iscsi_transport *transport = session->transport;
7b8631b5 1930 struct iscsi_cls_conn *conn;
26974789 1931 unsigned long flags;
7b8631b5
MC		 1932 int err;
1933
5d91e209 1934 conn = kzalloc(sizeof(*conn) + dd_size, GFP_KERNEL);
7b8631b5
MC		 1935 if (!conn)
1936 return NULL;
5d91e209 1937 if (dd_size)
7b8631b5
MC		 1938 conn->dd_data = &conn[1];
1939
22a39fbb 1940 mutex_init(&conn->ep_mutex);
7b8631b5
MC		 1941 INIT_LIST_HEAD(&conn->conn_list);
1942 conn->transport = transport;
b5c7a12d 1943 conn->cid = cid;
7b8631b5
MC		 1944
1945 /* this is released in the dev's release function */
1946 if (!get_device(&session->dev))
43a145a3 1947 goto free_conn;
b5c7a12d 1948
71610f55 1949 dev_set_name(&conn->dev, "connection%d:%u", session->sid, cid);
7b8631b5
MC		 1950 conn->dev.parent = &session->dev;
1951 conn->dev.release = iscsi_conn_release;
1952 err = device_register(&conn->dev);
1953 if (err) {
322d739d
MC		 1954 iscsi_cls_session_printk(KERN_ERR, session, "could not "
1955 "register connection's dev\n");
7b8631b5
MC		 1956 goto release_parent_ref;
1957 }
1958 transport_register_device(&conn->dev);
26974789
MC		 1959
1960 spin_lock_irqsave(&connlock, flags);
1961 list_add(&conn->conn_list, &connlist);
26974789 1962 spin_unlock_irqrestore(&connlock, flags);
632248aa
MC		 1963
1964 ISCSI_DBG_TRANS_CONN(conn, "Completed conn creation\n");
7b8631b5
MC		 1965 return conn;
1966
1967release_parent_ref:
1968 put_device(&session->dev);
1969free_conn:
1970 kfree(conn);
1971 return NULL;
1972}
1973
1974EXPORT_SYMBOL_GPL(iscsi_create_conn);
1975
1976/**
1977 * iscsi_destroy_conn - destroy iscsi class connection
eb44820c 1978 * @conn: iscsi cls session
7b8631b5 1979 *
26974789 1980 * This can be called from a LLD or iscsi_transport.
eb44820c 1981 */
7b8631b5
MC		 1982int iscsi_destroy_conn(struct iscsi_cls_conn *conn)
1983{
26974789
MC		 1984 unsigned long flags;
1985
1986 spin_lock_irqsave(&connlock, flags);
26974789
MC		 1987 list_del(&conn->conn_list);
1988 spin_unlock_irqrestore(&connlock, flags);
1989
7b8631b5 1990 transport_unregister_device(&conn->dev);
632248aa 1991 ISCSI_DBG_TRANS_CONN(conn, "Completing conn destruction\n");
7b8631b5
MC		 1992 device_unregister(&conn->dev);
1993 return 0;
1994}
7b8631b5
MC		 1995EXPORT_SYMBOL_GPL(iscsi_destroy_conn);
1996
7b8631b5
MC		 1997/*
1998 * iscsi interface functions
1999 */
0896b752
AA		 2000static struct iscsi_internal *
2001iscsi_if_transport_lookup(struct iscsi_transport *tt)
2002{
2003 struct iscsi_internal *priv;
2004 unsigned long flags;
2005
2006 spin_lock_irqsave(&iscsi_transport_lock, flags);
2007 list_for_each_entry(priv, &iscsi_transports, list) {
2008 if (tt == priv->iscsi_transport) {
2009 spin_unlock_irqrestore(&iscsi_transport_lock, flags);
2010 return priv;
2011 }
2012 }
2013 spin_unlock_irqrestore(&iscsi_transport_lock, flags);
2014 return NULL;
2015}
1da177e4 2016
53cb8a1f 2017static int
43514774 2018iscsi_multicast_skb(struct sk_buff *skb, uint32_t group, gfp_t gfp)
53cb8a1f 2019{
43514774 2020 return nlmsg_multicast(nls, skb, 0, group, gfp);
1da177e4 2021}
1da177e4 2022
7b7232f3 2023int iscsi_recv_pdu(struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr,
0896b752 2024 char *data, uint32_t data_size)
1da177e4 2025{
0896b752
AA		 2026 struct nlmsghdr *nlh;
2027 struct sk_buff *skb;
2028 struct iscsi_uevent *ev;
0896b752 2029 char *pdu;
790f39a2 2030 struct iscsi_internal *priv;
e07ebea0
H		 2031 int len = nlmsg_total_size(sizeof(*ev) + sizeof(struct iscsi_hdr) +
2032 data_size);
0896b752 2033
790f39a2
MC		 2034 priv = iscsi_if_transport_lookup(conn->transport);
2035 if (!priv)
2036 return -EINVAL;
2037
43a145a3 2038 skb = alloc_skb(len, GFP_ATOMIC);
0896b752 2039 if (!skb) {
e5bd7b54 2040 iscsi_conn_error_event(conn, ISCSI_ERR_CONN_FAILED);
322d739d
MC		 2041 iscsi_cls_conn_printk(KERN_ERR, conn, "can not deliver "
2042 "control PDU: OOM\n");
0896b752
AA		 2043 return -ENOMEM;
2044 }
1da177e4 2045
43514774 2046 nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
e07ebea0 2047 ev = nlmsg_data(nlh);
0896b752
AA		 2048 memset(ev, 0, sizeof(*ev));
2049 ev->transport_handle = iscsi_handle(conn->transport);
2050 ev->type = ISCSI_KEVENT_RECV_PDU;
b5c7a12d
MC		 2051 ev->r.recv_req.cid = conn->cid;
2052 ev->r.recv_req.sid = iscsi_conn_get_sid(conn);
0896b752
AA		 2053 pdu = (char*)ev + sizeof(*ev);
2054 memcpy(pdu, hdr, sizeof(struct iscsi_hdr));
2055 memcpy(pdu + sizeof(struct iscsi_hdr), data, data_size);
1da177e4 2056
43514774 2057 return iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_ATOMIC);
1da177e4 2058}
0896b752 2059EXPORT_SYMBOL_GPL(iscsi_recv_pdu);
1da177e4 2060
43514774
MC		 2061int iscsi_offload_mesg(struct Scsi_Host *shost,
2062 struct iscsi_transport *transport, uint32_t type,
2063 char *data, uint16_t data_size)
2064{
2065 struct nlmsghdr *nlh;
2066 struct sk_buff *skb;
2067 struct iscsi_uevent *ev;
e07ebea0 2068 int len = nlmsg_total_size(sizeof(*ev) + data_size);
43514774 2069
a541f840 2070 skb = alloc_skb(len, GFP_ATOMIC);
43514774
MC		 2071 if (!skb) {
2072 printk(KERN_ERR "can not deliver iscsi offload message:OOM\n");
2073 return -ENOMEM;
2074 }
2075
2076 nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
e07ebea0 2077 ev = nlmsg_data(nlh);
43514774
MC		 2078 memset(ev, 0, sizeof(*ev));
2079 ev->type = type;
2080 ev->transport_handle = iscsi_handle(transport);
2081 switch (type) {
2082 case ISCSI_KEVENT_PATH_REQ:
2083 ev->r.req_path.host_no = shost->host_no;
2084 break;
2085 case ISCSI_KEVENT_IF_DOWN:
2086 ev->r.notify_if_down.host_no = shost->host_no;
2087 break;
2088 }
2089
2090 memcpy((char *)ev + sizeof(*ev), data, data_size);
2091
a541f840 2092 return iscsi_multicast_skb(skb, ISCSI_NL_GRP_UIP, GFP_ATOMIC);
43514774
MC		 2093}
2094EXPORT_SYMBOL_GPL(iscsi_offload_mesg);
2095
e5bd7b54 2096void iscsi_conn_error_event(struct iscsi_cls_conn *conn, enum iscsi_err error)
1da177e4 2097{
0896b752
AA		 2098 struct nlmsghdr *nlh;
2099 struct sk_buff *skb;
2100 struct iscsi_uevent *ev;
790f39a2 2101 struct iscsi_internal *priv;
e07ebea0 2102 int len = nlmsg_total_size(sizeof(*ev));
0896b752 2103
790f39a2
MC		 2104 priv = iscsi_if_transport_lookup(conn->transport);
2105 if (!priv)
2106 return;
2107
43a145a3 2108 skb = alloc_skb(len, GFP_ATOMIC);
0896b752 2109 if (!skb) {
322d739d
MC		 2110 iscsi_cls_conn_printk(KERN_ERR, conn, "gracefully ignored "
2111 "conn error (%d)\n", error);
0896b752
AA		 2112 return;
2113 }
2114
43514774 2115 nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
e07ebea0 2116 ev = nlmsg_data(nlh);
0896b752
AA		 2117 ev->transport_handle = iscsi_handle(conn->transport);
2118 ev->type = ISCSI_KEVENT_CONN_ERROR;
0896b752 2119 ev->r.connerror.error = error;
b5c7a12d
MC		 2120 ev->r.connerror.cid = conn->cid;
2121 ev->r.connerror.sid = iscsi_conn_get_sid(conn);
1da177e4 2122
43514774 2123 iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_ATOMIC);
1da177e4 2124
322d739d
MC		 2125 iscsi_cls_conn_printk(KERN_INFO, conn, "detected conn error (%d)\n",
2126 error);
0896b752 2127}
e5bd7b54 2128EXPORT_SYMBOL_GPL(iscsi_conn_error_event);
0896b752 2129
17fa575e
MR		 2130void iscsi_conn_login_event(struct iscsi_cls_conn *conn,
2131 enum iscsi_conn_state state)
2132{
2133 struct nlmsghdr *nlh;
2134 struct sk_buff *skb;
2135 struct iscsi_uevent *ev;
2136 struct iscsi_internal *priv;
e07ebea0 2137 int len = nlmsg_total_size(sizeof(*ev));
17fa575e
MR		 2138
2139 priv = iscsi_if_transport_lookup(conn->transport);
2140 if (!priv)
2141 return;
2142
2143 skb = alloc_skb(len, GFP_ATOMIC);
2144 if (!skb) {
2145 iscsi_cls_conn_printk(KERN_ERR, conn, "gracefully ignored "
2146 "conn login (%d)\n", state);
2147 return;
2148 }
2149
2150 nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
e07ebea0 2151 ev = nlmsg_data(nlh);
17fa575e
MR		 2152 ev->transport_handle = iscsi_handle(conn->transport);
2153 ev->type = ISCSI_KEVENT_CONN_LOGIN_STATE;
2154 ev->r.conn_login.state = state;
2155 ev->r.conn_login.cid = conn->cid;
2156 ev->r.conn_login.sid = iscsi_conn_get_sid(conn);
2157 iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_ATOMIC);
2158
2159 iscsi_cls_conn_printk(KERN_INFO, conn, "detected conn login (%d)\n",
2160 state);
2161}
2162EXPORT_SYMBOL_GPL(iscsi_conn_login_event);
2163
a11e2545
VC		 2164void iscsi_post_host_event(uint32_t host_no, struct iscsi_transport *transport,
2165 enum iscsi_host_event_code code, uint32_t data_size,
2166 uint8_t *data)
2167{
2168 struct nlmsghdr *nlh;
2169 struct sk_buff *skb;
2170 struct iscsi_uevent *ev;
e07ebea0 2171 int len = nlmsg_total_size(sizeof(*ev) + data_size);
a11e2545 2172
49d0e64b 2173 skb = alloc_skb(len, GFP_NOIO);
a11e2545
VC		 2174 if (!skb) {
2175 printk(KERN_ERR "gracefully ignored host event (%d):%d OOM\n",
2176 host_no, code);
2177 return;
2178 }
2179
2180 nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
e07ebea0 2181 ev = nlmsg_data(nlh);
a11e2545
VC		 2182 ev->transport_handle = iscsi_handle(transport);
2183 ev->type = ISCSI_KEVENT_HOST_EVENT;
2184 ev->r.host_event.host_no = host_no;
2185 ev->r.host_event.code = code;
2186 ev->r.host_event.data_size = data_size;
2187
2188 if (data_size)
2189 memcpy((char *)ev + sizeof(*ev), data, data_size);
2190
49d0e64b 2191 iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_NOIO);
a11e2545
VC		 2192}
2193EXPORT_SYMBOL_GPL(iscsi_post_host_event);
2194
ac20c7bf
VC		 2195void iscsi_ping_comp_event(uint32_t host_no, struct iscsi_transport *transport,
2196 uint32_t status, uint32_t pid, uint32_t data_size,
2197 uint8_t *data)
2198{
2199 struct nlmsghdr *nlh;
2200 struct sk_buff *skb;
2201 struct iscsi_uevent *ev;
e07ebea0 2202 int len = nlmsg_total_size(sizeof(*ev) + data_size);
ac20c7bf 2203
49d0e64b 2204 skb = alloc_skb(len, GFP_NOIO);
ac20c7bf
VC		 2205 if (!skb) {
2206 printk(KERN_ERR "gracefully ignored ping comp: OOM\n");
2207 return;
2208 }
2209
2210 nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
e07ebea0 2211 ev = nlmsg_data(nlh);
ac20c7bf
VC		 2212 ev->transport_handle = iscsi_handle(transport);
2213 ev->type = ISCSI_KEVENT_PING_COMP;
2214 ev->r.ping_comp.host_no = host_no;
2215 ev->r.ping_comp.status = status;
2216 ev->r.ping_comp.pid = pid;
2217 ev->r.ping_comp.data_size = data_size;
2218 memcpy((char *)ev + sizeof(*ev), data, data_size);
2219
49d0e64b 2220 iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_NOIO);
ac20c7bf
VC		 2221}
2222EXPORT_SYMBOL_GPL(iscsi_ping_comp_event);
2223
0896b752 2224static int
43514774
MC		 2225iscsi_if_send_reply(uint32_t group, int seq, int type, int done, int multi,
2226 void *payload, int size)
0896b752
AA		 2227{
2228 struct sk_buff *skb;
2229 struct nlmsghdr *nlh;
e07ebea0 2230 int len = nlmsg_total_size(size);
0896b752
AA		 2231 int flags = multi ? NLM_F_MULTI : 0;
2232 int t = done ? NLMSG_DONE : type;
2233
43a145a3 2234 skb = alloc_skb(len, GFP_ATOMIC);
239a7dc2
MC		 2235 if (!skb) {
2236 printk(KERN_ERR "Could not allocate skb to send reply.\n");
2237 return -ENOMEM;
2238 }
0896b752 2239
43514774 2240 nlh = __nlmsg_put(skb, 0, 0, t, (len - sizeof(*nlh)), 0);
0896b752 2241 nlh->nlmsg_flags = flags;
e07ebea0 2242 memcpy(nlmsg_data(nlh), payload, size);
43514774 2243 return iscsi_multicast_skb(skb, group, GFP_ATOMIC);
1da177e4 2244}
1da177e4 2245
7b8631b5 2246static int
5b940adf 2247iscsi_if_get_stats(struct iscsi_transport *transport, struct nlmsghdr *nlh)
7b8631b5 2248{
e07ebea0 2249 struct iscsi_uevent *ev = nlmsg_data(nlh);
7b8631b5
MC		 2250 struct iscsi_stats *stats;
2251 struct sk_buff *skbstat;
2252 struct iscsi_cls_conn *conn;
2253 struct nlmsghdr *nlhstat;
2254 struct iscsi_uevent *evstat;
790f39a2 2255 struct iscsi_internal *priv;
e07ebea0
H		 2256 int len = nlmsg_total_size(sizeof(*ev) +
2257 sizeof(struct iscsi_stats) +
2258 sizeof(struct iscsi_stats_custom) *
2259 ISCSI_STATS_CUSTOM_MAX);
7b8631b5 2260 int err = 0;
0896b752 2261
790f39a2
MC		 2262 priv = iscsi_if_transport_lookup(transport);
2263 if (!priv)
2264 return -EINVAL;
2265
b5c7a12d 2266 conn = iscsi_conn_lookup(ev->u.get_stats.sid, ev->u.get_stats.cid);
7b8631b5
MC		 2267 if (!conn)
2268 return -EEXIST;
0896b752 2269
7b8631b5
MC		 2270 do {
2271 int actual_size;
0896b752 2272
43a145a3 2273 skbstat = alloc_skb(len, GFP_ATOMIC);
7b8631b5 2274 if (!skbstat) {
322d739d
MC		 2275 iscsi_cls_conn_printk(KERN_ERR, conn, "can not "
2276 "deliver stats: OOM\n");
7b8631b5
MC		 2277 return -ENOMEM;
2278 }
2279
43514774 2280 nlhstat = __nlmsg_put(skbstat, 0, 0, 0,
7b8631b5 2281 (len - sizeof(*nlhstat)), 0);
e07ebea0 2282 evstat = nlmsg_data(nlhstat);
7b8631b5
MC		 2283 memset(evstat, 0, sizeof(*evstat));
2284 evstat->transport_handle = iscsi_handle(conn->transport);
2285 evstat->type = nlh->nlmsg_type;
b5c7a12d
MC		 2286 evstat->u.get_stats.cid =
2287 ev->u.get_stats.cid;
2288 evstat->u.get_stats.sid =
2289 ev->u.get_stats.sid;
7b8631b5
MC		 2290 stats = (struct iscsi_stats *)
2291 ((char*)evstat + sizeof(*evstat));
2292 memset(stats, 0, sizeof(*stats));
2293
7b7232f3 2294 transport->get_stats(conn, stats);
e07ebea0
H		 2295 actual_size = nlmsg_total_size(sizeof(struct iscsi_uevent) +
2296 sizeof(struct iscsi_stats) +
2297 sizeof(struct iscsi_stats_custom) *
2298 stats->custom_length);
7b8631b5 2299 actual_size -= sizeof(*nlhstat);
e07ebea0 2300 actual_size = nlmsg_msg_size(actual_size);
5b940adf 2301 skb_trim(skbstat, NLMSG_ALIGN(actual_size));
7b8631b5
MC		 2302 nlhstat->nlmsg_len = actual_size;
2303
43514774
MC		 2304 err = iscsi_multicast_skb(skbstat, ISCSI_NL_GRP_ISCSID,
2305 GFP_ATOMIC);
7b8631b5
MC		 2306 } while (err < 0 && err != -ECONNREFUSED);
2307
2308 return err;
0896b752
AA		 2309}
2310
53cb8a1f 2311/**
26974789
MC		 2312 * iscsi_session_event - send session destr. completion event
2313 * @session: iscsi class session
2314 * @event: type of event
eb44820c 2315 */
26974789
MC		 2316int iscsi_session_event(struct iscsi_cls_session *session,
2317 enum iscsi_uevent_e event)
53cb8a1f
MC		 2318{
2319 struct iscsi_internal *priv;
53cb8a1f
MC		 2320 struct Scsi_Host *shost;
2321 struct iscsi_uevent *ev;
2322 struct sk_buff *skb;
2323 struct nlmsghdr *nlh;
e07ebea0 2324 int rc, len = nlmsg_total_size(sizeof(*ev));
53cb8a1f 2325
26974789 2326 priv = iscsi_if_transport_lookup(session->transport);
53cb8a1f
MC		 2327 if (!priv)
2328 return -EINVAL;
53cb8a1f
MC		 2329 shost = iscsi_session_to_shost(session);
2330
43a145a3 2331 skb = alloc_skb(len, GFP_KERNEL);
53cb8a1f 2332 if (!skb) {
322d739d
MC		 2333 iscsi_cls_session_printk(KERN_ERR, session,
2334 "Cannot notify userspace of session "
2335 "event %u\n", event);
53cb8a1f
MC		 2336 return -ENOMEM;
2337 }
2338
43514774 2339 nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
e07ebea0 2340 ev = nlmsg_data(nlh);
26974789 2341 ev->transport_handle = iscsi_handle(session->transport);
53cb8a1f 2342
26974789
MC		 2343 ev->type = event;
2344 switch (event) {
2345 case ISCSI_KEVENT_DESTROY_SESSION:
2346 ev->r.d_session.host_no = shost->host_no;
2347 ev->r.d_session.sid = session->sid;
2348 break;
2349 case ISCSI_KEVENT_CREATE_SESSION:
2350 ev->r.c_session_ret.host_no = shost->host_no;
2351 ev->r.c_session_ret.sid = session->sid;
2352 break;
2353 case ISCSI_KEVENT_UNBIND_SESSION:
2354 ev->r.unbind_session.host_no = shost->host_no;
2355 ev->r.unbind_session.sid = session->sid;
2356 break;
2357 default:
322d739d
MC		 2358 iscsi_cls_session_printk(KERN_ERR, session, "Invalid event "
2359 "%u.\n", event);
26974789 2360 kfree_skb(skb);
53cb8a1f 2361 return -EINVAL;
53cb8a1f
MC		 2362 }
2363
53cb8a1f
MC		 2364 /*
2365 * this will occur if the daemon is not up, so we just warn
2366 * the user and when the daemon is restarted it will handle it
2367 */
43514774 2368 rc = iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_KERNEL);
ff491a73 2369 if (rc == -ESRCH)
322d739d
MC		 2370 iscsi_cls_session_printk(KERN_ERR, session,
2371 "Cannot notify userspace of session "
2372 "event %u. Check iscsi daemon\n",
2373 event);
632248aa
MC		 2374
2375 ISCSI_DBG_TRANS_SESSION(session, "Completed handling event %d rc %d\n",
2376 event, rc);
53cb8a1f
MC		 2377 return rc;
2378}
26974789 2379EXPORT_SYMBOL_GPL(iscsi_session_event);
53cb8a1f 2380
0896b752 2381static int
d82ff9be 2382iscsi_if_create_session(struct iscsi_internal *priv, struct iscsi_endpoint *ep,
0c70d84b
MC		 2383 struct iscsi_uevent *ev, pid_t pid,
2384 uint32_t initial_cmdsn, uint16_t cmds_max,
2385 uint16_t queue_depth)
0896b752
AA		 2386{
2387 struct iscsi_transport *transport = priv->iscsi_transport;
7b7232f3 2388 struct iscsi_cls_session *session;
5e7facb7 2389 struct Scsi_Host *shost;
0896b752 2390
d82ff9be 2391 session = transport->create_session(ep, cmds_max, queue_depth,
5e7facb7 2392 initial_cmdsn);
7b7232f3 2393 if (!session)
7b8631b5 2394 return -ENOMEM;
0896b752 2395
0c70d84b 2396 session->creator = pid;
5e7facb7
MC		 2397 shost = iscsi_session_to_shost(session);
2398 ev->r.c_session_ret.host_no = shost->host_no;
b5c7a12d 2399 ev->r.c_session_ret.sid = session->sid;
632248aa
MC		 2400 ISCSI_DBG_TRANS_SESSION(session,
2401 "Completed creating transport session\n");
0896b752 2402 return 0;
0896b752
AA		 2403}
2404
2405static int
7b7232f3 2406iscsi_if_create_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
0896b752 2407{
7b8631b5 2408 struct iscsi_cls_conn *conn;
7b7232f3 2409 struct iscsi_cls_session *session;
7b8631b5 2410
b5c7a12d
MC		 2411 session = iscsi_session_lookup(ev->u.c_conn.sid);
2412 if (!session) {
322d739d 2413 printk(KERN_ERR "iscsi: invalid session %d.\n",
b5c7a12d 2414 ev->u.c_conn.sid);
7b8631b5 2415 return -EINVAL;
b5c7a12d 2416 }
0896b752 2417
7b7232f3 2418 conn = transport->create_conn(session, ev->u.c_conn.cid);
b5c7a12d 2419 if (!conn) {
322d739d
MC		 2420 iscsi_cls_session_printk(KERN_ERR, session,
2421 "couldn't create a new connection.");
7b7232f3 2422 return -ENOMEM;
b5c7a12d 2423 }
0896b752 2424
b5c7a12d
MC		 2425 ev->r.c_conn_ret.sid = session->sid;
2426 ev->r.c_conn_ret.cid = conn->cid;
632248aa
MC		 2427
2428 ISCSI_DBG_TRANS_CONN(conn, "Completed creating transport conn\n");
0896b752 2429 return 0;
1da177e4
LT		 2430}
2431
0896b752
AA		 2432static int
2433iscsi_if_destroy_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
2434{
7b8631b5 2435 struct iscsi_cls_conn *conn;
0896b752 2436
b5c7a12d 2437 conn = iscsi_conn_lookup(ev->u.d_conn.sid, ev->u.d_conn.cid);
0896b752 2438 if (!conn)
7b8631b5 2439 return -EINVAL;
0896b752 2440
632248aa 2441 ISCSI_DBG_TRANS_CONN(conn, "Destroying transport conn\n");
7b8631b5
MC		 2442 if (transport->destroy_conn)
2443 transport->destroy_conn(conn);
632248aa 2444
7b8631b5 2445 return 0;
0896b752
AA		 2446}
2447
fd7255f5
MC		 2448static int
2449iscsi_set_param(struct iscsi_transport *transport, struct iscsi_uevent *ev)
2450{
2451 char *data = (char*)ev + sizeof(*ev);
2452 struct iscsi_cls_conn *conn;
2453 struct iscsi_cls_session *session;
a54a52ca 2454 int err = 0, value = 0;
fd7255f5
MC		 2455
2456 session = iscsi_session_lookup(ev->u.set_param.sid);
2457 conn = iscsi_conn_lookup(ev->u.set_param.sid, ev->u.set_param.cid);
2458 if (!conn || !session)
2459 return -EINVAL;
2460
2461 switch (ev->u.set_param.param) {
30a6c652 2462 case ISCSI_PARAM_SESS_RECOVERY_TMO:
a54a52ca 2463 sscanf(data, "%d", &value);
fdd46dcb 2464 session->recovery_tmo = value;
30a6c652 2465 break;
fd7255f5 2466 default:
a54a52ca
MC		 2467 err = transport->set_param(conn, ev->u.set_param.param,
2468 data, ev->u.set_param.len);
fd7255f5
MC		 2469 }
2470
2471 return err;
2472}
2473
10eb0f01
MC		 2474static int iscsi_if_ep_connect(struct iscsi_transport *transport,
2475 struct iscsi_uevent *ev, int msg_type)
2476{
2477 struct iscsi_endpoint *ep;
2478 struct sockaddr *dst_addr;
2479 struct Scsi_Host *shost = NULL;
2480 int non_blocking, err = 0;
2481
2482 if (!transport->ep_connect)
2483 return -EINVAL;
2484
2485 if (msg_type == ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST) {
2486 shost = scsi_host_lookup(ev->u.ep_connect_through_host.host_no);
2487 if (!shost) {
2488 printk(KERN_ERR "ep connect failed. Could not find "
2489 "host no %u\n",
2490 ev->u.ep_connect_through_host.host_no);
2491 return -ENODEV;
2492 }
2493 non_blocking = ev->u.ep_connect_through_host.non_blocking;
2494 } else
2495 non_blocking = ev->u.ep_connect.non_blocking;
2496
2497 dst_addr = (struct sockaddr *)((char*)ev + sizeof(*ev));
2498 ep = transport->ep_connect(shost, dst_addr, non_blocking);
2499 if (IS_ERR(ep)) {
2500 err = PTR_ERR(ep);
2501 goto release_host;
2502 }
2503
2504 ev->r.ep_connect_ret.handle = ep->id;
2505release_host:
2506 if (shost)
2507 scsi_host_put(shost);
2508 return err;
2509}
2510
22a39fbb
MC		 2511static int iscsi_if_ep_disconnect(struct iscsi_transport *transport,
2512 u64 ep_handle)
2513{
2514 struct iscsi_cls_conn *conn;
2515 struct iscsi_endpoint *ep;
2516
2517 if (!transport->ep_disconnect)
2518 return -EINVAL;
2519
2520 ep = iscsi_lookup_endpoint(ep_handle);
2521 if (!ep)
2522 return -EINVAL;
2523 conn = ep->conn;
2524 if (conn) {
2525 mutex_lock(&conn->ep_mutex);
2526 conn->ep = NULL;
2527 mutex_unlock(&conn->ep_mutex);
2528 }
2529
2530 transport->ep_disconnect(ep);
2531 return 0;
2532}
2533
264faaaa
OG		 2534static int
2535iscsi_if_transport_ep(struct iscsi_transport *transport,
2536 struct iscsi_uevent *ev, int msg_type)
2537{
d82ff9be 2538 struct iscsi_endpoint *ep;
264faaaa
OG		 2539 int rc = 0;
2540
2541 switch (msg_type) {
10eb0f01 2542 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST:
264faaaa 2543 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT:
10eb0f01 2544 rc = iscsi_if_ep_connect(transport, ev, msg_type);
264faaaa
OG		 2545 break;
2546 case ISCSI_UEVENT_TRANSPORT_EP_POLL:
2547 if (!transport->ep_poll)
2548 return -EINVAL;
2549
d82ff9be
MC		 2550 ep = iscsi_lookup_endpoint(ev->u.ep_poll.ep_handle);
2551 if (!ep)
2552 return -EINVAL;
2553
2554 ev->r.retcode = transport->ep_poll(ep,
264faaaa
OG		 2555 ev->u.ep_poll.timeout_ms);
2556 break;
2557 case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT:
22a39fbb
MC		 2558 rc = iscsi_if_ep_disconnect(transport,
2559 ev->u.ep_disconnect.ep_handle);
264faaaa
OG		 2560 break;
2561 }
2562 return rc;
2563}
2564
01cb225d
MC		 2565static int
2566iscsi_tgt_dscvr(struct iscsi_transport *transport,
2567 struct iscsi_uevent *ev)
2568{
2174a04e 2569 struct Scsi_Host *shost;
01cb225d 2570 struct sockaddr *dst_addr;
2174a04e 2571 int err;
01cb225d
MC		 2572
2573 if (!transport->tgt_dscvr)
2574 return -EINVAL;
2575
2174a04e 2576 shost = scsi_host_lookup(ev->u.tgt_dscvr.host_no);
315cb0ad 2577 if (!shost) {
2174a04e
MC		 2578 printk(KERN_ERR "target discovery could not find host no %u\n",
2579 ev->u.tgt_dscvr.host_no);
2580 return -ENODEV;
2581 }
2582
2583
01cb225d 2584 dst_addr = (struct sockaddr *)((char*)ev + sizeof(*ev));
2174a04e
MC		 2585 err = transport->tgt_dscvr(shost, ev->u.tgt_dscvr.type,
2586 ev->u.tgt_dscvr.enable, dst_addr);
2587 scsi_host_put(shost);
2588 return err;
01cb225d
MC		 2589}
2590
1d9bf13a
MC		 2591static int
2592iscsi_set_host_param(struct iscsi_transport *transport,
2593 struct iscsi_uevent *ev)
2594{
2595 char *data = (char*)ev + sizeof(*ev);
2596 struct Scsi_Host *shost;
2597 int err;
2598
2599 if (!transport->set_host_param)
2600 return -ENOSYS;
2601
2602 shost = scsi_host_lookup(ev->u.set_host_param.host_no);
315cb0ad 2603 if (!shost) {
1d9bf13a
MC		 2604 printk(KERN_ERR "set_host_param could not find host no %u\n",
2605 ev->u.set_host_param.host_no);
2606 return -ENODEV;
2607 }
2608
2609 err = transport->set_host_param(shost, ev->u.set_host_param.param,
2610 data, ev->u.set_host_param.len);
2611 scsi_host_put(shost);
2612 return err;
2613}
2614
0896b752 2615static int
43514774
MC		 2616iscsi_set_path(struct iscsi_transport *transport, struct iscsi_uevent *ev)
2617{
2618 struct Scsi_Host *shost;
2619 struct iscsi_path *params;
2620 int err;
2621
2622 if (!transport->set_path)
2623 return -ENOSYS;
2624
2625 shost = scsi_host_lookup(ev->u.set_path.host_no);
2626 if (!shost) {
2627 printk(KERN_ERR "set path could not find host no %u\n",
2628 ev->u.set_path.host_no);
2629 return -ENODEV;
2630 }
2631
2632 params = (struct iscsi_path *)((char *)ev + sizeof(*ev));
2633 err = transport->set_path(shost, params);
2634
2635 scsi_host_put(shost);
2636 return err;
2637}
2638
56c155b5
MC		 2639static int
2640iscsi_set_iface_params(struct iscsi_transport *transport,
00c31889 2641 struct iscsi_uevent *ev, uint32_t len)
56c155b5
MC		 2642{
2643 char *data = (char *)ev + sizeof(*ev);
2644 struct Scsi_Host *shost;
2645 int err;
2646
2647 if (!transport->set_iface_param)
2648 return -ENOSYS;
2649
2650 shost = scsi_host_lookup(ev->u.set_iface_params.host_no);
2651 if (!shost) {
2652 printk(KERN_ERR "set_iface_params could not find host no %u\n",
2653 ev->u.set_iface_params.host_no);
2654 return -ENODEV;
2655 }
2656
00c31889 2657 err = transport->set_iface_param(shost, data, len);
56c155b5
MC		 2658 scsi_host_put(shost);
2659 return err;
2660}
2661
ac20c7bf
VC		 2662static int
2663iscsi_send_ping(struct iscsi_transport *transport, struct iscsi_uevent *ev)
2664{
2665 struct Scsi_Host *shost;
2666 struct sockaddr *dst_addr;
2667 int err;
2668
2669 if (!transport->send_ping)
2670 return -ENOSYS;
2671
2672 shost = scsi_host_lookup(ev->u.iscsi_ping.host_no);
2673 if (!shost) {
2674 printk(KERN_ERR "iscsi_ping could not find host no %u\n",
2675 ev->u.iscsi_ping.host_no);
2676 return -ENODEV;
2677 }
2678
2679 dst_addr = (struct sockaddr *)((char *)ev + sizeof(*ev));
2680 err = transport->send_ping(shost, ev->u.iscsi_ping.iface_num,
2681 ev->u.iscsi_ping.iface_type,
2682 ev->u.iscsi_ping.payload_size,
2683 ev->u.iscsi_ping.pid,
2684 dst_addr);
2685 scsi_host_put(shost);
2686 return err;
2687}
2688
6260a5d2
NJ		 2689static int
2690iscsi_get_chap(struct iscsi_transport *transport, struct nlmsghdr *nlh)
2691{
e07ebea0 2692 struct iscsi_uevent *ev = nlmsg_data(nlh);
6260a5d2
NJ		 2693 struct Scsi_Host *shost = NULL;
2694 struct iscsi_chap_rec *chap_rec;
2695 struct iscsi_internal *priv;
2696 struct sk_buff *skbchap;
2697 struct nlmsghdr *nlhchap;
2698 struct iscsi_uevent *evchap;
2699 uint32_t chap_buf_size;
2700 int len, err = 0;
2701 char *buf;
2702
2703 if (!transport->get_chap)
2704 return -EINVAL;
2705
2706 priv = iscsi_if_transport_lookup(transport);
2707 if (!priv)
2708 return -EINVAL;
2709
2710 chap_buf_size = (ev->u.get_chap.num_entries * sizeof(*chap_rec));
e07ebea0 2711 len = nlmsg_total_size(sizeof(*ev) + chap_buf_size);
6260a5d2
NJ		 2712
2713 shost = scsi_host_lookup(ev->u.get_chap.host_no);
2714 if (!shost) {
2715 printk(KERN_ERR "%s: failed. Cound not find host no %u\n",
2716 __func__, ev->u.get_chap.host_no);
2717 return -ENODEV;
2718 }
2719
2720 do {
2721 int actual_size;
2722
2723 skbchap = alloc_skb(len, GFP_KERNEL);
2724 if (!skbchap) {
2725 printk(KERN_ERR "can not deliver chap: OOM\n");
2726 err = -ENOMEM;
2727 goto exit_get_chap;
2728 }
2729
2730 nlhchap = __nlmsg_put(skbchap, 0, 0, 0,
2731 (len - sizeof(*nlhchap)), 0);
e07ebea0 2732 evchap = nlmsg_data(nlhchap);
6260a5d2
NJ		 2733 memset(evchap, 0, sizeof(*evchap));
2734 evchap->transport_handle = iscsi_handle(transport);
2735 evchap->type = nlh->nlmsg_type;
2736 evchap->u.get_chap.host_no = ev->u.get_chap.host_no;
2737 evchap->u.get_chap.chap_tbl_idx = ev->u.get_chap.chap_tbl_idx;
2738 evchap->u.get_chap.num_entries = ev->u.get_chap.num_entries;
2739 buf = (char *) ((char *)evchap + sizeof(*evchap));
2740 memset(buf, 0, chap_buf_size);
2741
2742 err = transport->get_chap(shost, ev->u.get_chap.chap_tbl_idx,
2743 &evchap->u.get_chap.num_entries, buf);
2744
e07ebea0 2745 actual_size = nlmsg_total_size(sizeof(*ev) + chap_buf_size);
6260a5d2
NJ		 2746 skb_trim(skbchap, NLMSG_ALIGN(actual_size));
2747 nlhchap->nlmsg_len = actual_size;
2748
2749 err = iscsi_multicast_skb(skbchap, ISCSI_NL_GRP_ISCSID,
2750 GFP_KERNEL);
2751 } while (err < 0 && err != -ECONNREFUSED);
2752
2753exit_get_chap:
2754 scsi_host_put(shost);
2755 return err;
2756}
2757
2758static int iscsi_delete_chap(struct iscsi_transport *transport,
2759 struct iscsi_uevent *ev)
2760{
2761 struct Scsi_Host *shost;
2762 int err = 0;
2763
2764 if (!transport->delete_chap)
2765 return -ENOSYS;
2766
2767 shost = scsi_host_lookup(ev->u.delete_chap.host_no);
2768 if (!shost) {
2769 printk(KERN_ERR "%s could not find host no %u\n",
2770 __func__, ev->u.delete_chap.host_no);
2771 return -ENODEV;
2772 }
2773
2774 err = transport->delete_chap(shost, ev->u.delete_chap.chap_tbl_idx);
2775 scsi_host_put(shost);
2776 return err;
2777}
2778
c6a4bb2e
AC		 2779static const struct {
2780 enum iscsi_discovery_parent_type value;
2781 char *name;
2782} iscsi_discovery_parent_names[] = {
2783 {ISCSI_DISC_PARENT_UNKNOWN, "Unknown" },
2784 {ISCSI_DISC_PARENT_SENDTGT, "Sendtarget" },
2785 {ISCSI_DISC_PARENT_ISNS, "isns" },
2786};
2787
2788char *iscsi_get_discovery_parent_name(int parent_type)
2789{
2790 int i;
2791 char *state = "Unknown!";
2792
2793 for (i = 0; i < ARRAY_SIZE(iscsi_discovery_parent_names); i++) {
2794 if (iscsi_discovery_parent_names[i].value & parent_type) {
2795 state = iscsi_discovery_parent_names[i].name;
2796 break;
2797 }
2798 }
2799 return state;
2800}
2801EXPORT_SYMBOL_GPL(iscsi_get_discovery_parent_name);
2802
2803static int iscsi_set_flashnode_param(struct iscsi_transport *transport,
2804 struct iscsi_uevent *ev, uint32_t len)
2805{
2806 char *data = (char *)ev + sizeof(*ev);
2807 struct Scsi_Host *shost;
2808 struct iscsi_bus_flash_session *fnode_sess;
2809 struct iscsi_bus_flash_conn *fnode_conn;
2810 struct device *dev;
2811 uint32_t *idx;
2812 int err = 0;
2813
2814 if (!transport->set_flashnode_param) {
2815 err = -ENOSYS;
2816 goto exit_set_fnode;
2817 }
2818
2819 shost = scsi_host_lookup(ev->u.set_flashnode.host_no);
2820 if (!shost) {
2821 pr_err("%s could not find host no %u\n",
2822 __func__, ev->u.set_flashnode.host_no);
2823 err = -ENODEV;
2824 goto put_host;
2825 }
2826
2827 idx = &ev->u.set_flashnode.flashnode_idx;
2828 fnode_sess = iscsi_get_flashnode_by_index(shost, idx,
2829 flashnode_match_index);
2830 if (!fnode_sess) {
2831 pr_err("%s could not find flashnode %u for host no %u\n",
2832 __func__, *idx, ev->u.set_flashnode.host_no);
2833 err = -ENODEV;
2834 goto put_host;
2835 }
2836
2837 dev = iscsi_find_flashnode_conn(fnode_sess, NULL,
2838 iscsi_is_flashnode_conn_dev);
2839 if (!dev) {
2840 err = -ENODEV;
2841 goto put_host;
2842 }
2843
2844 fnode_conn = iscsi_dev_to_flash_conn(dev);
2845 err = transport->set_flashnode_param(fnode_sess, fnode_conn, data, len);
2846
2847put_host:
2848 scsi_host_put(shost);
2849
2850exit_set_fnode:
2851 return err;
2852}
2853
2854static int iscsi_new_flashnode(struct iscsi_transport *transport,
2855 struct iscsi_uevent *ev, uint32_t len)
2856{
2857 char *data = (char *)ev + sizeof(*ev);
2858 struct Scsi_Host *shost;
2859 int index;
2860 int err = 0;
2861
2862 if (!transport->new_flashnode) {
2863 err = -ENOSYS;
2864 goto exit_new_fnode;
2865 }
2866
2867 shost = scsi_host_lookup(ev->u.new_flashnode.host_no);
2868 if (!shost) {
2869 pr_err("%s could not find host no %u\n",
2870 __func__, ev->u.new_flashnode.host_no);
2871 err = -ENODEV;
2872 goto put_host;
2873 }
2874
2875 index = transport->new_flashnode(shost, data, len);
2876
2877 if (index >= 0)
2878 ev->r.new_flashnode_ret.flashnode_idx = index;
2879 else
2880 err = -EIO;
2881
2882put_host:
2883 scsi_host_put(shost);
2884
2885exit_new_fnode:
2886 return err;
2887}
2888
2889static int iscsi_del_flashnode(struct iscsi_transport *transport,
2890 struct iscsi_uevent *ev)
2891{
2892 struct Scsi_Host *shost;
2893 struct iscsi_bus_flash_session *fnode_sess;
2894 uint32_t *idx;
2895 int err = 0;
2896
2897 if (!transport->del_flashnode) {
2898 err = -ENOSYS;
2899 goto exit_del_fnode;
2900 }
2901
2902 shost = scsi_host_lookup(ev->u.del_flashnode.host_no);
2903 if (!shost) {
2904 pr_err("%s could not find host no %u\n",
2905 __func__, ev->u.del_flashnode.host_no);
2906 err = -ENODEV;
2907 goto put_host;
2908 }
2909
2910 idx = &ev->u.del_flashnode.flashnode_idx;
2911 fnode_sess = iscsi_get_flashnode_by_index(shost, idx,
2912 flashnode_match_index);
2913 if (!fnode_sess) {
2914 pr_err("%s could not find flashnode %u for host no %u\n",
2915 __func__, *idx, ev->u.del_flashnode.host_no);
2916 err = -ENODEV;
2917 goto put_host;
2918 }
2919
2920 err = transport->del_flashnode(fnode_sess);
2921
2922put_host:
2923 scsi_host_put(shost);
2924
2925exit_del_fnode:
2926 return err;
2927}
2928
2929static int iscsi_login_flashnode(struct iscsi_transport *transport,
2930 struct iscsi_uevent *ev)
2931{
2932 struct Scsi_Host *shost;
2933 struct iscsi_bus_flash_session *fnode_sess;
2934 struct iscsi_bus_flash_conn *fnode_conn;
2935 struct device *dev;
2936 uint32_t *idx;
2937 int err = 0;
2938
2939 if (!transport->login_flashnode) {
2940 err = -ENOSYS;
2941 goto exit_login_fnode;
2942 }
2943
2944 shost = scsi_host_lookup(ev->u.login_flashnode.host_no);
2945 if (!shost) {
2946 pr_err("%s could not find host no %u\n",
2947 __func__, ev->u.login_flashnode.host_no);
2948 err = -ENODEV;
2949 goto put_host;
2950 }
2951
2952 idx = &ev->u.login_flashnode.flashnode_idx;
2953 fnode_sess = iscsi_get_flashnode_by_index(shost, idx,
2954 flashnode_match_index);
2955 if (!fnode_sess) {
2956 pr_err("%s could not find flashnode %u for host no %u\n",
2957 __func__, *idx, ev->u.login_flashnode.host_no);
2958 err = -ENODEV;
2959 goto put_host;
2960 }
2961
2962 dev = iscsi_find_flashnode_conn(fnode_sess, NULL,
2963 iscsi_is_flashnode_conn_dev);
2964 if (!dev) {
2965 err = -ENODEV;
2966 goto put_host;
2967 }
2968
2969 fnode_conn = iscsi_dev_to_flash_conn(dev);
2970 err = transport->login_flashnode(fnode_sess, fnode_conn);
2971
2972put_host:
2973 scsi_host_put(shost);
2974
2975exit_login_fnode:
2976 return err;
2977}
2978
2979static int iscsi_logout_flashnode(struct iscsi_transport *transport,
2980 struct iscsi_uevent *ev)
2981{
2982 struct Scsi_Host *shost;
2983 struct iscsi_bus_flash_session *fnode_sess;
2984 struct iscsi_bus_flash_conn *fnode_conn;
2985 struct device *dev;
2986 uint32_t *idx;
2987 int err = 0;
2988
2989 if (!transport->logout_flashnode) {
2990 err = -ENOSYS;
2991 goto exit_logout_fnode;
2992 }
2993
2994 shost = scsi_host_lookup(ev->u.logout_flashnode.host_no);
2995 if (!shost) {
2996 pr_err("%s could not find host no %u\n",
2997 __func__, ev->u.logout_flashnode.host_no);
2998 err = -ENODEV;
2999 goto put_host;
3000 }
3001
3002 idx = &ev->u.logout_flashnode.flashnode_idx;
3003 fnode_sess = iscsi_get_flashnode_by_index(shost, idx,
3004 flashnode_match_index);
3005 if (!fnode_sess) {
3006 pr_err("%s could not find flashnode %u for host no %u\n",
3007 __func__, *idx, ev->u.logout_flashnode.host_no);
3008 err = -ENODEV;
3009 goto put_host;
3010 }
3011
3012 dev = iscsi_find_flashnode_conn(fnode_sess, NULL,
3013 iscsi_is_flashnode_conn_dev);
3014 if (!dev) {
3015 err = -ENODEV;
3016 goto put_host;
3017 }
3018
3019 fnode_conn = iscsi_dev_to_flash_conn(dev);
3020
3021 err = transport->logout_flashnode(fnode_sess, fnode_conn);
3022
3023put_host:
3024 scsi_host_put(shost);
3025
3026exit_logout_fnode:
3027 return err;
3028}
3029
3030static int iscsi_logout_flashnode_sid(struct iscsi_transport *transport,
3031 struct iscsi_uevent *ev)
3032{
3033 struct Scsi_Host *shost;
3034 struct iscsi_cls_session *session;
3035 int err = 0;
3036
3037 if (!transport->logout_flashnode_sid) {
3038 err = -ENOSYS;
3039 goto exit_logout_sid;
3040 }
3041
3042 shost = scsi_host_lookup(ev->u.logout_flashnode_sid.host_no);
3043 if (!shost) {
3044 pr_err("%s could not find host no %u\n",
3045 __func__, ev->u.logout_flashnode.host_no);
3046 err = -ENODEV;
3047 goto put_host;
3048 }
3049
3050 session = iscsi_session_lookup(ev->u.logout_flashnode_sid.sid);
3051 if (!session) {
3052 pr_err("%s could not find session id %u\n",
3053 __func__, ev->u.logout_flashnode_sid.sid);
3054 err = -EINVAL;
3055 goto put_host;
3056 }
3057
3058 err = transport->logout_flashnode_sid(session);
3059
3060put_host:
3061 scsi_host_put(shost);
3062
3063exit_logout_sid:
3064 return err;
3065}
3066
43514774
MC		 3067static int
3068iscsi_if_recv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, uint32_t *group)
0896b752
AA		 3069{
3070 int err = 0;
e07ebea0 3071 struct iscsi_uevent *ev = nlmsg_data(nlh);
0896b752
AA		 3072 struct iscsi_transport *transport = NULL;
3073 struct iscsi_internal *priv;
7b7232f3
MC		 3074 struct iscsi_cls_session *session;
3075 struct iscsi_cls_conn *conn;
d82ff9be 3076 struct iscsi_endpoint *ep = NULL;
0896b752 3077
43514774
MC		 3078 if (nlh->nlmsg_type == ISCSI_UEVENT_PATH_UPDATE)
3079 *group = ISCSI_NL_GRP_UIP;
3080 else
3081 *group = ISCSI_NL_GRP_ISCSID;
3082
0896b752
AA		 3083 priv = iscsi_if_transport_lookup(iscsi_ptr(ev->transport_handle));
3084 if (!priv)
3085 return -EINVAL;
3086 transport = priv->iscsi_transport;
3087
7b7232f3
MC		 3088 if (!try_module_get(transport->owner))
3089 return -EINVAL;
3090
0896b752
AA		 3091 switch (nlh->nlmsg_type) {
3092 case ISCSI_UEVENT_CREATE_SESSION:
d82ff9be 3093 err = iscsi_if_create_session(priv, ep, ev,
15e47304 3094 NETLINK_CB(skb).portid,
40753caa
MC		 3095 ev->u.c_session.initial_cmdsn,
3096 ev->u.c_session.cmds_max,
3097 ev->u.c_session.queue_depth);
3098 break;
3099 case ISCSI_UEVENT_CREATE_BOUND_SESSION:
d82ff9be 3100 ep = iscsi_lookup_endpoint(ev->u.c_bound_session.ep_handle);
c95fddc7
MC		 3101 if (!ep) {
3102 err = -EINVAL;
3103 break;
3104 }
d82ff9be
MC		 3105
3106 err = iscsi_if_create_session(priv, ep, ev,
15e47304 3107 NETLINK_CB(skb).portid,
40753caa
MC		 3108 ev->u.c_bound_session.initial_cmdsn,
3109 ev->u.c_bound_session.cmds_max,
3110 ev->u.c_bound_session.queue_depth);
0896b752
AA		 3111 break;
3112 case ISCSI_UEVENT_DESTROY_SESSION:
b5c7a12d 3113 session = iscsi_session_lookup(ev->u.d_session.sid);
26974789 3114 if (session)
7b7232f3 3115 transport->destroy_session(session);
26974789
MC		 3116 else
3117 err = -EINVAL;
3118 break;
3119 case ISCSI_UEVENT_UNBIND_SESSION:
3120 session = iscsi_session_lookup(ev->u.d_session.sid);
3121 if (session)
06d25af4
MC		 3122 scsi_queue_work(iscsi_session_to_shost(session),
3123 &session->unbind_work);
26974789 3124 else
7b7232f3 3125 err = -EINVAL;
0896b752
AA		 3126 break;
3127 case ISCSI_UEVENT_CREATE_CONN:
3128 err = iscsi_if_create_conn(transport, ev);
3129 break;
3130 case ISCSI_UEVENT_DESTROY_CONN:
3131 err = iscsi_if_destroy_conn(transport, ev);
3132 break;
3133 case ISCSI_UEVENT_BIND_CONN:
b5c7a12d
MC		 3134 session = iscsi_session_lookup(ev->u.b_conn.sid);
3135 conn = iscsi_conn_lookup(ev->u.b_conn.sid, ev->u.b_conn.cid);
7b7232f3 3136
22a39fbb
MC		 3137 if (conn && conn->ep)
3138 iscsi_if_ep_disconnect(transport, conn->ep->id);
3139
3140 if (!session || !conn) {
7b7232f3 3141 err = -EINVAL;
22a39fbb
MC		 3142 break;
3143 }
3144
3145 ev->r.retcode = transport->bind_conn(session, conn,
3146 ev->u.b_conn.transport_eph,
3147 ev->u.b_conn.is_leading);
3148 if (ev->r.retcode || !transport->ep_connect)
3149 break;
3150
3151 ep = iscsi_lookup_endpoint(ev->u.b_conn.transport_eph);
3152 if (ep) {
3153 ep->conn = conn;
3154
3155 mutex_lock(&conn->ep_mutex);
3156 conn->ep = ep;
3157 mutex_unlock(&conn->ep_mutex);
3158 } else
3159 iscsi_cls_conn_printk(KERN_ERR, conn,
3160 "Could not set ep conn "
3161 "binding\n");
0896b752
AA		 3162 break;
3163 case ISCSI_UEVENT_SET_PARAM:
fd7255f5 3164 err = iscsi_set_param(transport, ev);
0896b752
AA		 3165 break;
3166 case ISCSI_UEVENT_START_CONN:
b5c7a12d 3167 conn = iscsi_conn_lookup(ev->u.start_conn.sid, ev->u.start_conn.cid);
7b7232f3
MC		 3168 if (conn)
3169 ev->r.retcode = transport->start_conn(conn);
3170 else
3171 err = -EINVAL;
0896b752
AA		 3172 break;
3173 case ISCSI_UEVENT_STOP_CONN:
b5c7a12d 3174 conn = iscsi_conn_lookup(ev->u.stop_conn.sid, ev->u.stop_conn.cid);
7b7232f3
MC		 3175 if (conn)
3176 transport->stop_conn(conn, ev->u.stop_conn.flag);
3177 else
3178 err = -EINVAL;
0896b752
AA		 3179 break;
3180 case ISCSI_UEVENT_SEND_PDU:
b5c7a12d 3181 conn = iscsi_conn_lookup(ev->u.send_pdu.sid, ev->u.send_pdu.cid);
7b7232f3
MC		 3182 if (conn)
3183 ev->r.retcode = transport->send_pdu(conn,
3184 (struct iscsi_hdr*)((char*)ev + sizeof(*ev)),
3185 (char*)ev + sizeof(*ev) + ev->u.send_pdu.hdr_size,
3186 ev->u.send_pdu.data_size);
3187 else
3188 err = -EINVAL;
0896b752
AA		 3189 break;
3190 case ISCSI_UEVENT_GET_STATS:
5b940adf 3191 err = iscsi_if_get_stats(transport, nlh);
0896b752 3192 break;
264faaaa
OG		 3193 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT:
3194 case ISCSI_UEVENT_TRANSPORT_EP_POLL:
3195 case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT:
10eb0f01 3196 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST:
264faaaa
OG		 3197 err = iscsi_if_transport_ep(transport, ev, nlh->nlmsg_type);
3198 break;
01cb225d
MC		 3199 case ISCSI_UEVENT_TGT_DSCVR:
3200 err = iscsi_tgt_dscvr(transport, ev);
3201 break;
1d9bf13a
MC		 3202 case ISCSI_UEVENT_SET_HOST_PARAM:
3203 err = iscsi_set_host_param(transport, ev);
3204 break;
43514774
MC		 3205 case ISCSI_UEVENT_PATH_UPDATE:
3206 err = iscsi_set_path(transport, ev);
3207 break;
56c155b5 3208 case ISCSI_UEVENT_SET_IFACE_PARAMS:
00c31889
MC		 3209 err = iscsi_set_iface_params(transport, ev,
3210 nlmsg_attrlen(nlh, sizeof(*ev)));
56c155b5 3211 break;
ac20c7bf
VC		 3212 case ISCSI_UEVENT_PING:
3213 err = iscsi_send_ping(transport, ev);
3214 break;
6260a5d2
NJ		 3215 case ISCSI_UEVENT_GET_CHAP:
3216 err = iscsi_get_chap(transport, nlh);
3217 break;
3218 case ISCSI_UEVENT_DELETE_CHAP:
3219 err = iscsi_delete_chap(transport, ev);
3220 break;
c6a4bb2e
AC		 3221 case ISCSI_UEVENT_SET_FLASHNODE_PARAMS:
3222 err = iscsi_set_flashnode_param(transport, ev,
3223 nlmsg_attrlen(nlh,
3224 sizeof(*ev)));
3225 break;
3226 case ISCSI_UEVENT_NEW_FLASHNODE:
3227 err = iscsi_new_flashnode(transport, ev,
3228 nlmsg_attrlen(nlh, sizeof(*ev)));
3229 break;
3230 case ISCSI_UEVENT_DEL_FLASHNODE:
3231 err = iscsi_del_flashnode(transport, ev);
3232 break;
3233 case ISCSI_UEVENT_LOGIN_FLASHNODE:
3234 err = iscsi_login_flashnode(transport, ev);
3235 break;
3236 case ISCSI_UEVENT_LOGOUT_FLASHNODE:
3237 err = iscsi_logout_flashnode(transport, ev);
3238 break;
3239 case ISCSI_UEVENT_LOGOUT_FLASHNODE_SID:
3240 err = iscsi_logout_flashnode_sid(transport, ev);
3241 break;
0896b752 3242 default:
1d9bf13a 3243 err = -ENOSYS;
0896b752
AA		 3244 break;
3245 }
3246
7b7232f3 3247 module_put(transport->owner);
0896b752
AA		 3248 return err;
3249}
3250
b5c7a12d 3251/*
cd40b7d3
DL		 3252 * Get message from skb. Each message is processed by iscsi_if_recv_msg.
3253 * Malformed skbs with wrong lengths or invalid creds are not processed.
b5c7a12d 3254 */
0896b752 3255static void
cd40b7d3 3256iscsi_if_rx(struct sk_buff *skb)
0896b752 3257{
0b950672 3258 mutex_lock(&rx_queue_mutex);
e07ebea0 3259 while (skb->len >= NLMSG_HDRLEN) {
cd40b7d3
DL		 3260 int err;
3261 uint32_t rlen;
3262 struct nlmsghdr *nlh;
3263 struct iscsi_uevent *ev;
43514774 3264 uint32_t group;
cd40b7d3
DL		 3265
3266 nlh = nlmsg_hdr(skb);
3267 if (nlh->nlmsg_len < sizeof(*nlh) ||
3268 skb->len < nlh->nlmsg_len) {
3269 break;
ee7f8e40 3270 }
ee7f8e40 3271
e07ebea0 3272 ev = nlmsg_data(nlh);
cd40b7d3
DL		 3273 rlen = NLMSG_ALIGN(nlh->nlmsg_len);
3274 if (rlen > skb->len)
3275 rlen = skb->len;
0896b752 3276
43514774 3277 err = iscsi_if_recv_msg(skb, nlh, &group);
cd40b7d3
DL		 3278 if (err) {
3279 ev->type = ISCSI_KEVENT_IF_ERROR;
3280 ev->iferror = err;
0896b752 3281 }
cd40b7d3
DL		 3282 do {
3283 /*
3284 * special case for GET_STATS:
3285 * on success - sending reply and stats from
3286 * inside of if_recv_msg(),
3287 * on error - fall through.
3288 */
3289 if (ev->type == ISCSI_UEVENT_GET_STATS && !err)
3290 break;
6260a5d2
NJ		 3291 if (ev->type == ISCSI_UEVENT_GET_CHAP && !err)
3292 break;
43514774 3293 err = iscsi_if_send_reply(group, nlh->nlmsg_seq,
cd40b7d3 3294 nlh->nlmsg_type, 0, 0, ev, sizeof(*ev));
46a7c17d 3295 } while (err < 0 && err != -ECONNREFUSED && err != -ESRCH);
cd40b7d3 3296 skb_pull(skb, rlen);
0896b752 3297 }
0b950672 3298 mutex_unlock(&rx_queue_mutex);
0896b752 3299}
1da177e4 3300
fd7255f5 3301#define ISCSI_CLASS_ATTR(_prefix,_name,_mode,_show,_store) \
ee959b00 3302struct device_attribute dev_attr_##_prefix##_##_name = \
fd7255f5
MC		 3303 __ATTR(_name,_mode,_show,_store)
3304
1da177e4 3305/*
0896b752 3306 * iSCSI connection attrs
1da177e4 3307 */
a54a52ca 3308#define iscsi_conn_attr_show(param) \
0896b752 3309static ssize_t \
ee959b00
TJ		 3310show_conn_param_##param(struct device *dev, \
3311 struct device_attribute *attr, char *buf) \
0896b752 3312{ \
ee959b00 3313 struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent); \
7b8631b5 3314 struct iscsi_transport *t = conn->transport; \
a54a52ca 3315 return t->get_conn_param(conn, param, buf); \
0896b752
AA		 3316}
3317
a54a52ca
MC		 3318#define iscsi_conn_attr(field, param) \
3319 iscsi_conn_attr_show(param) \
3320static ISCSI_CLASS_ATTR(conn, field, S_IRUGO, show_conn_param_##param, \
fd7255f5 3321 NULL);
0896b752 3322
a54a52ca
MC		 3323iscsi_conn_attr(max_recv_dlength, ISCSI_PARAM_MAX_RECV_DLENGTH);
3324iscsi_conn_attr(max_xmit_dlength, ISCSI_PARAM_MAX_XMIT_DLENGTH);
3325iscsi_conn_attr(header_digest, ISCSI_PARAM_HDRDGST_EN);
3326iscsi_conn_attr(data_digest, ISCSI_PARAM_DATADGST_EN);
3327iscsi_conn_attr(ifmarker, ISCSI_PARAM_IFMARKER_EN);
3328iscsi_conn_attr(ofmarker, ISCSI_PARAM_OFMARKER_EN);
3329iscsi_conn_attr(persistent_port, ISCSI_PARAM_PERSISTENT_PORT);
a54a52ca
MC		 3330iscsi_conn_attr(exp_statsn, ISCSI_PARAM_EXP_STATSN);
3331iscsi_conn_attr(persistent_address, ISCSI_PARAM_PERSISTENT_ADDRESS);
f6d5180c
MC		 3332iscsi_conn_attr(ping_tmo, ISCSI_PARAM_PING_TMO);
3333iscsi_conn_attr(recv_tmo, ISCSI_PARAM_RECV_TMO);
1da177e4 3334
289324b0
MC		 3335#define iscsi_conn_ep_attr_show(param) \
3336static ssize_t show_conn_ep_param_##param(struct device *dev, \
3337 struct device_attribute *attr,\
3338 char *buf) \
3339{ \
3340 struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent); \
3341 struct iscsi_transport *t = conn->transport; \
3342 struct iscsi_endpoint *ep; \
3343 ssize_t rc; \
3344 \
3345 /* \
3346 * Need to make sure ep_disconnect does not free the LLD's \
3347 * interconnect resources while we are trying to read them. \
3348 */ \
3349 mutex_lock(&conn->ep_mutex); \
3350 ep = conn->ep; \
3351 if (!ep && t->ep_connect) { \
3352 mutex_unlock(&conn->ep_mutex); \
3353 return -ENOTCONN; \
3354 } \
3355 \
3356 if (ep) \
3357 rc = t->get_ep_param(ep, param, buf); \
3358 else \
3359 rc = t->get_conn_param(conn, param, buf); \
3360 mutex_unlock(&conn->ep_mutex); \
3361 return rc; \
3362}
3363
3364#define iscsi_conn_ep_attr(field, param) \
3365 iscsi_conn_ep_attr_show(param) \
3366static ISCSI_CLASS_ATTR(conn, field, S_IRUGO, \
3367 show_conn_ep_param_##param, NULL);
3368
3369iscsi_conn_ep_attr(address, ISCSI_PARAM_CONN_ADDRESS);
3370iscsi_conn_ep_attr(port, ISCSI_PARAM_CONN_PORT);
3371
3128c6c7
MC		 3372static struct attribute *iscsi_conn_attrs[] = {
3373 &dev_attr_conn_max_recv_dlength.attr,
3374 &dev_attr_conn_max_xmit_dlength.attr,
3375 &dev_attr_conn_header_digest.attr,
3376 &dev_attr_conn_data_digest.attr,
3377 &dev_attr_conn_ifmarker.attr,
3378 &dev_attr_conn_ofmarker.attr,
3379 &dev_attr_conn_address.attr,
3380 &dev_attr_conn_port.attr,
3381 &dev_attr_conn_exp_statsn.attr,
3382 &dev_attr_conn_persistent_address.attr,
3383 &dev_attr_conn_persistent_port.attr,
3384 &dev_attr_conn_ping_tmo.attr,
3385 &dev_attr_conn_recv_tmo.attr,
3386 NULL,
3387};
3388
587a1f16 3389static umode_t iscsi_conn_attr_is_visible(struct kobject *kobj,
3128c6c7
MC		 3390 struct attribute *attr, int i)
3391{
3392 struct device *cdev = container_of(kobj, struct device, kobj);
3393 struct iscsi_cls_conn *conn = transport_class_to_conn(cdev);
3394 struct iscsi_transport *t = conn->transport;
3395 int param;
3396
3397 if (attr == &dev_attr_conn_max_recv_dlength.attr)
3398 param = ISCSI_PARAM_MAX_RECV_DLENGTH;
3399 else if (attr == &dev_attr_conn_max_xmit_dlength.attr)
3400 param = ISCSI_PARAM_MAX_XMIT_DLENGTH;
3401 else if (attr == &dev_attr_conn_header_digest.attr)
3402 param = ISCSI_PARAM_HDRDGST_EN;
3403 else if (attr == &dev_attr_conn_data_digest.attr)
3404 param = ISCSI_PARAM_DATADGST_EN;
3405 else if (attr == &dev_attr_conn_ifmarker.attr)
3406 param = ISCSI_PARAM_IFMARKER_EN;
3407 else if (attr == &dev_attr_conn_ofmarker.attr)
3408 param = ISCSI_PARAM_OFMARKER_EN;
3409 else if (attr == &dev_attr_conn_address.attr)
3410 param = ISCSI_PARAM_CONN_ADDRESS;
3411 else if (attr == &dev_attr_conn_port.attr)
3412 param = ISCSI_PARAM_CONN_PORT;
3413 else if (attr == &dev_attr_conn_exp_statsn.attr)
3414 param = ISCSI_PARAM_EXP_STATSN;
3415 else if (attr == &dev_attr_conn_persistent_address.attr)
3416 param = ISCSI_PARAM_PERSISTENT_ADDRESS;
3417 else if (attr == &dev_attr_conn_persistent_port.attr)
3418 param = ISCSI_PARAM_PERSISTENT_PORT;
3419 else if (attr == &dev_attr_conn_ping_tmo.attr)
3420 param = ISCSI_PARAM_PING_TMO;
3421 else if (attr == &dev_attr_conn_recv_tmo.attr)
3422 param = ISCSI_PARAM_RECV_TMO;
3423 else {
3424 WARN_ONCE(1, "Invalid conn attr");
3425 return 0;
3426 }
3427
3428 return t->attr_is_visible(ISCSI_PARAM, param);
3429}
3430
3431static struct attribute_group iscsi_conn_group = {
3432 .attrs = iscsi_conn_attrs,
3433 .is_visible = iscsi_conn_attr_is_visible,
3434};
3435
1da177e4 3436/*
0896b752 3437 * iSCSI session attrs
1da177e4 3438 */
b2c64167 3439#define iscsi_session_attr_show(param, perm) \
fd7255f5 3440static ssize_t \
ee959b00
TJ		 3441show_session_param_##param(struct device *dev, \
3442 struct device_attribute *attr, char *buf) \
fd7255f5 3443{ \
ee959b00
TJ		 3444 struct iscsi_cls_session *session = \
3445 iscsi_dev_to_session(dev->parent); \
fd7255f5 3446 struct iscsi_transport *t = session->transport; \
b2c64167
MC		 3447 \
3448 if (perm && !capable(CAP_SYS_ADMIN)) \
3449 return -EACCES; \
a54a52ca 3450 return t->get_session_param(session, param, buf); \
fd7255f5
MC		 3451}
3452
b2c64167
MC		 3453#define iscsi_session_attr(field, param, perm) \
3454 iscsi_session_attr_show(param, perm) \
a54a52ca 3455static ISCSI_CLASS_ATTR(sess, field, S_IRUGO, show_session_param_##param, \
fd7255f5 3456 NULL);
b2c64167
MC		 3457iscsi_session_attr(targetname, ISCSI_PARAM_TARGET_NAME, 0);
3458iscsi_session_attr(initial_r2t, ISCSI_PARAM_INITIAL_R2T_EN, 0);
3459iscsi_session_attr(max_outstanding_r2t, ISCSI_PARAM_MAX_R2T, 0);
3460iscsi_session_attr(immediate_data, ISCSI_PARAM_IMM_DATA_EN, 0);
3461iscsi_session_attr(first_burst_len, ISCSI_PARAM_FIRST_BURST, 0);
3462iscsi_session_attr(max_burst_len, ISCSI_PARAM_MAX_BURST, 0);
3463iscsi_session_attr(data_pdu_in_order, ISCSI_PARAM_PDU_INORDER_EN, 0);
3464iscsi_session_attr(data_seq_in_order, ISCSI_PARAM_DATASEQ_INORDER_EN, 0);
3465iscsi_session_attr(erl, ISCSI_PARAM_ERL, 0);
3466iscsi_session_attr(tpgt, ISCSI_PARAM_TPGT, 0);
3467iscsi_session_attr(username, ISCSI_PARAM_USERNAME, 1);
3468iscsi_session_attr(username_in, ISCSI_PARAM_USERNAME_IN, 1);
3469iscsi_session_attr(password, ISCSI_PARAM_PASSWORD, 1);
3470iscsi_session_attr(password_in, ISCSI_PARAM_PASSWORD_IN, 1);
30534952
MC		 3471iscsi_session_attr(chap_out_idx, ISCSI_PARAM_CHAP_OUT_IDX, 1);
3472iscsi_session_attr(chap_in_idx, ISCSI_PARAM_CHAP_IN_IDX, 1);
4cd49ea1
MC		 3473iscsi_session_attr(fast_abort, ISCSI_PARAM_FAST_ABORT, 0);
3474iscsi_session_attr(abort_tmo, ISCSI_PARAM_ABORT_TMO, 0);
3475iscsi_session_attr(lu_reset_tmo, ISCSI_PARAM_LU_RESET_TMO, 0);
3fe5ae8b 3476iscsi_session_attr(tgt_reset_tmo, ISCSI_PARAM_TGT_RESET_TMO, 0);
88dfd340 3477iscsi_session_attr(ifacename, ISCSI_PARAM_IFACE_NAME, 0);
3b2bef1f
VC		 3478iscsi_session_attr(initiatorname, ISCSI_PARAM_INITIATOR_NAME, 0);
3479iscsi_session_attr(targetalias, ISCSI_PARAM_TARGET_ALIAS, 0);
1da177e4 3480
6eabafbe 3481static ssize_t
ee959b00
TJ		 3482show_priv_session_state(struct device *dev, struct device_attribute *attr,
3483 char *buf)
6eabafbe 3484{
ee959b00 3485 struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent);
6eabafbe
MC		 3486 return sprintf(buf, "%s\n", iscsi_session_state_name(session->state));
3487}
3488static ISCSI_CLASS_ATTR(priv_sess, state, S_IRUGO, show_priv_session_state,
3489 NULL);
0c70d84b
MC		 3490static ssize_t
3491show_priv_session_creator(struct device *dev, struct device_attribute *attr,
3492 char *buf)
3493{
3494 struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent);
3495 return sprintf(buf, "%d\n", session->creator);
3496}
3497static ISCSI_CLASS_ATTR(priv_sess, creator, S_IRUGO, show_priv_session_creator,
3498 NULL);
930a9f04
MR		 3499static ssize_t
3500show_priv_session_target_id(struct device *dev, struct device_attribute *attr,
3501 char *buf)
3502{
3503 struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent);
3504 return sprintf(buf, "%d\n", session->target_id);
3505}
3506static ISCSI_CLASS_ATTR(priv_sess, target_id, S_IRUGO,
3507 show_priv_session_target_id, NULL);
6eabafbe 3508
fd7255f5
MC		 3509#define iscsi_priv_session_attr_show(field, format) \
3510static ssize_t \
ee959b00
TJ		 3511show_priv_session_##field(struct device *dev, \
3512 struct device_attribute *attr, char *buf) \
fd7255f5 3513{ \
ee959b00
TJ		 3514 struct iscsi_cls_session *session = \
3515 iscsi_dev_to_session(dev->parent); \
fe4f0bde
VC		 3516 if (session->field == -1) \
3517 return sprintf(buf, "off\n"); \
fd7255f5
MC		 3518 return sprintf(buf, format"\n", session->field); \
3519}
3520
fe4f0bde
VC		 3521#define iscsi_priv_session_attr_store(field) \
3522static ssize_t \
3523store_priv_session_##field(struct device *dev, \
3524 struct device_attribute *attr, \
3525 const char *buf, size_t count) \
3526{ \
3527 int val; \
3528 char *cp; \
3529 struct iscsi_cls_session *session = \
3530 iscsi_dev_to_session(dev->parent); \
3531 if ((session->state == ISCSI_SESSION_FREE) || \
3532 (session->state == ISCSI_SESSION_FAILED)) \
3533 return -EBUSY; \
3534 if (strncmp(buf, "off", 3) == 0) \
3535 session->field = -1; \
3536 else { \
3537 val = simple_strtoul(buf, &cp, 0); \
3538 if (*cp != '\0' && *cp != '\n') \
3539 return -EINVAL; \
3540 session->field = val; \
3541 } \
3542 return count; \
3543}
3544
3545#define iscsi_priv_session_rw_attr(field, format) \
fd7255f5 3546 iscsi_priv_session_attr_show(field, format) \
fe4f0bde 3547 iscsi_priv_session_attr_store(field) \
523f3c80 3548static ISCSI_CLASS_ATTR(priv_sess, field, S_IRUGO | S_IWUSR, \
fe4f0bde
VC		 3549 show_priv_session_##field, \
3550 store_priv_session_##field)
3551iscsi_priv_session_rw_attr(recovery_tmo, "%d");
fd7255f5 3552
1d063c17
MC		 3553static struct attribute *iscsi_session_attrs[] = {
3554 &dev_attr_sess_initial_r2t.attr,
3555 &dev_attr_sess_max_outstanding_r2t.attr,
3556 &dev_attr_sess_immediate_data.attr,
3557 &dev_attr_sess_first_burst_len.attr,
3558 &dev_attr_sess_max_burst_len.attr,
3559 &dev_attr_sess_data_pdu_in_order.attr,
3560 &dev_attr_sess_data_seq_in_order.attr,
3561 &dev_attr_sess_erl.attr,
3562 &dev_attr_sess_targetname.attr,
3563 &dev_attr_sess_tpgt.attr,
3564 &dev_attr_sess_password.attr,
3565 &dev_attr_sess_password_in.attr,
3566 &dev_attr_sess_username.attr,
3567 &dev_attr_sess_username_in.attr,
3568 &dev_attr_sess_fast_abort.attr,
3569 &dev_attr_sess_abort_tmo.attr,
3570 &dev_attr_sess_lu_reset_tmo.attr,
3571 &dev_attr_sess_tgt_reset_tmo.attr,
3572 &dev_attr_sess_ifacename.attr,
3573 &dev_attr_sess_initiatorname.attr,
3574 &dev_attr_sess_targetalias.attr,
3575 &dev_attr_priv_sess_recovery_tmo.attr,
3576 &dev_attr_priv_sess_state.attr,
0c70d84b 3577 &dev_attr_priv_sess_creator.attr,
30534952
MC		 3578 &dev_attr_sess_chap_out_idx.attr,
3579 &dev_attr_sess_chap_in_idx.attr,
930a9f04 3580 &dev_attr_priv_sess_target_id.attr,
1d063c17
MC		 3581 NULL,
3582};
3583
587a1f16 3584static umode_t iscsi_session_attr_is_visible(struct kobject *kobj,
1d063c17
MC		 3585 struct attribute *attr, int i)
3586{
3587 struct device *cdev = container_of(kobj, struct device, kobj);
3588 struct iscsi_cls_session *session = transport_class_to_session(cdev);
3589 struct iscsi_transport *t = session->transport;
3590 int param;
3591
3592 if (attr == &dev_attr_sess_initial_r2t.attr)
3593 param = ISCSI_PARAM_INITIAL_R2T_EN;
3594 else if (attr == &dev_attr_sess_max_outstanding_r2t.attr)
3595 param = ISCSI_PARAM_MAX_R2T;
3596 else if (attr == &dev_attr_sess_immediate_data.attr)
3597 param = ISCSI_PARAM_IMM_DATA_EN;
3598 else if (attr == &dev_attr_sess_first_burst_len.attr)
3599 param = ISCSI_PARAM_FIRST_BURST;
3600 else if (attr == &dev_attr_sess_max_burst_len.attr)
3601 param = ISCSI_PARAM_MAX_BURST;
3602 else if (attr == &dev_attr_sess_data_pdu_in_order.attr)
3603 param = ISCSI_PARAM_PDU_INORDER_EN;
3604 else if (attr == &dev_attr_sess_data_seq_in_order.attr)
3605 param = ISCSI_PARAM_DATASEQ_INORDER_EN;
3606 else if (attr == &dev_attr_sess_erl.attr)
3607 param = ISCSI_PARAM_ERL;
3608 else if (attr == &dev_attr_sess_targetname.attr)
3609 param = ISCSI_PARAM_TARGET_NAME;
3610 else if (attr == &dev_attr_sess_tpgt.attr)
3611 param = ISCSI_PARAM_TPGT;
30534952
MC		 3612 else if (attr == &dev_attr_sess_chap_in_idx.attr)
3613 param = ISCSI_PARAM_CHAP_IN_IDX;
3614 else if (attr == &dev_attr_sess_chap_out_idx.attr)
3615 param = ISCSI_PARAM_CHAP_OUT_IDX;
1d063c17
MC		 3616 else if (attr == &dev_attr_sess_password.attr)
3617 param = ISCSI_PARAM_USERNAME;
3618 else if (attr == &dev_attr_sess_password_in.attr)
3619 param = ISCSI_PARAM_USERNAME_IN;
3620 else if (attr == &dev_attr_sess_username.attr)
3621 param = ISCSI_PARAM_PASSWORD;
3622 else if (attr == &dev_attr_sess_username_in.attr)
3623 param = ISCSI_PARAM_PASSWORD_IN;
3624 else if (attr == &dev_attr_sess_fast_abort.attr)
3625 param = ISCSI_PARAM_FAST_ABORT;
3626 else if (attr == &dev_attr_sess_abort_tmo.attr)
3627 param = ISCSI_PARAM_ABORT_TMO;
3628 else if (attr == &dev_attr_sess_lu_reset_tmo.attr)
3629 param = ISCSI_PARAM_LU_RESET_TMO;
3630 else if (attr == &dev_attr_sess_tgt_reset_tmo.attr)
3631 param = ISCSI_PARAM_TGT_RESET_TMO;
3632 else if (attr == &dev_attr_sess_ifacename.attr)
3633 param = ISCSI_PARAM_IFACE_NAME;
3634 else if (attr == &dev_attr_sess_initiatorname.attr)
3635 param = ISCSI_PARAM_INITIATOR_NAME;
3636 else if (attr == &dev_attr_sess_targetalias.attr)
3637 param = ISCSI_PARAM_TARGET_ALIAS;
3638 else if (attr == &dev_attr_priv_sess_recovery_tmo.attr)
3639 return S_IRUGO | S_IWUSR;
3640 else if (attr == &dev_attr_priv_sess_state.attr)
3641 return S_IRUGO;
0c70d84b
MC		 3642 else if (attr == &dev_attr_priv_sess_creator.attr)
3643 return S_IRUGO;
930a9f04
MR		 3644 else if (attr == &dev_attr_priv_sess_target_id.attr)
3645 return S_IRUGO;
1d063c17
MC		 3646 else {
3647 WARN_ONCE(1, "Invalid session attr");
3648 return 0;
3649 }
3650
3651 return t->attr_is_visible(ISCSI_PARAM, param);
3652}
3653
3654static struct attribute_group iscsi_session_group = {
3655 .attrs = iscsi_session_attrs,
3656 .is_visible = iscsi_session_attr_is_visible,
3657};
3658
1819dc81
MC		 3659/*
3660 * iSCSI host attrs
3661 */
3662#define iscsi_host_attr_show(param) \
3663static ssize_t \
ee959b00
TJ		 3664show_host_param_##param(struct device *dev, \
3665 struct device_attribute *attr, char *buf) \
1819dc81 3666{ \
ee959b00 3667 struct Scsi_Host *shost = transport_class_to_shost(dev); \
1819dc81
MC		 3668 struct iscsi_internal *priv = to_iscsi_internal(shost->transportt); \
3669 return priv->iscsi_transport->get_host_param(shost, param, buf); \
3670}
3671
3672#define iscsi_host_attr(field, param) \
3673 iscsi_host_attr_show(param) \
3674static ISCSI_CLASS_ATTR(host, field, S_IRUGO, show_host_param_##param, \
3675 NULL);
3676
d8196ed2 3677iscsi_host_attr(netdev, ISCSI_HOST_PARAM_NETDEV_NAME);
1819dc81 3678iscsi_host_attr(hwaddress, ISCSI_HOST_PARAM_HWADDRESS);
d8196ed2 3679iscsi_host_attr(ipaddress, ISCSI_HOST_PARAM_IPADDRESS);
8ad5781a 3680iscsi_host_attr(initiatorname, ISCSI_HOST_PARAM_INITIATOR_NAME);
aeddde29
VC		 3681iscsi_host_attr(port_state, ISCSI_HOST_PARAM_PORT_STATE);
3682iscsi_host_attr(port_speed, ISCSI_HOST_PARAM_PORT_SPEED);
1819dc81 3683
f27fb2ef
MC		 3684static struct attribute *iscsi_host_attrs[] = {
3685 &dev_attr_host_netdev.attr,
3686 &dev_attr_host_hwaddress.attr,
3687 &dev_attr_host_ipaddress.attr,
3688 &dev_attr_host_initiatorname.attr,
aeddde29
VC		 3689 &dev_attr_host_port_state.attr,
3690 &dev_attr_host_port_speed.attr,
f27fb2ef
MC		 3691 NULL,
3692};
3693
587a1f16 3694static umode_t iscsi_host_attr_is_visible(struct kobject *kobj,
f27fb2ef
MC		 3695 struct attribute *attr, int i)
3696{
3697 struct device *cdev = container_of(kobj, struct device, kobj);
3698 struct Scsi_Host *shost = transport_class_to_shost(cdev);
3699 struct iscsi_internal *priv = to_iscsi_internal(shost->transportt);
3700 int param;
3701
3702 if (attr == &dev_attr_host_netdev.attr)
3703 param = ISCSI_HOST_PARAM_NETDEV_NAME;
3704 else if (attr == &dev_attr_host_hwaddress.attr)
3705 param = ISCSI_HOST_PARAM_HWADDRESS;
3706 else if (attr == &dev_attr_host_ipaddress.attr)
3707 param = ISCSI_HOST_PARAM_IPADDRESS;
3708 else if (attr == &dev_attr_host_initiatorname.attr)
3709 param = ISCSI_HOST_PARAM_INITIATOR_NAME;
aeddde29
VC		 3710 else if (attr == &dev_attr_host_port_state.attr)
3711 param = ISCSI_HOST_PARAM_PORT_STATE;
3712 else if (attr == &dev_attr_host_port_speed.attr)
3713 param = ISCSI_HOST_PARAM_PORT_SPEED;
f27fb2ef
MC		 3714 else {
3715 WARN_ONCE(1, "Invalid host attr");
3716 return 0;
3717 }
3718
3719 return priv->iscsi_transport->attr_is_visible(ISCSI_HOST_PARAM, param);
3720}
3721
3722static struct attribute_group iscsi_host_group = {
3723 .attrs = iscsi_host_attrs,
3724 .is_visible = iscsi_host_attr_is_visible,
3725};
1819dc81 3726
aeddde29
VC		 3727/* convert iscsi_port_speed values to ascii string name */
3728static const struct {
3729 enum iscsi_port_speed value;
3730 char *name;
3731} iscsi_port_speed_names[] = {
3732 {ISCSI_PORT_SPEED_UNKNOWN, "Unknown" },
3733 {ISCSI_PORT_SPEED_10MBPS, "10 Mbps" },
3734 {ISCSI_PORT_SPEED_100MBPS, "100 Mbps" },
3735 {ISCSI_PORT_SPEED_1GBPS, "1 Gbps" },
3736 {ISCSI_PORT_SPEED_10GBPS, "10 Gbps" },
3737};
3738
3739char *iscsi_get_port_speed_name(struct Scsi_Host *shost)
3740{
3741 int i;
3742 char *speed = "Unknown!";
3743 struct iscsi_cls_host *ihost = shost->shost_data;
3744 uint32_t port_speed = ihost->port_speed;
3745
3746 for (i = 0; i < ARRAY_SIZE(iscsi_port_speed_names); i++) {
3747 if (iscsi_port_speed_names[i].value & port_speed) {
3748 speed = iscsi_port_speed_names[i].name;
3749 break;
3750 }
3751 }
3752 return speed;
3753}
3754EXPORT_SYMBOL_GPL(iscsi_get_port_speed_name);
3755
3756/* convert iscsi_port_state values to ascii string name */
3757static const struct {
3758 enum iscsi_port_state value;
3759 char *name;
3760} iscsi_port_state_names[] = {
3761 {ISCSI_PORT_STATE_DOWN, "LINK DOWN" },
3762 {ISCSI_PORT_STATE_UP, "LINK UP" },
3763};
3764
3765char *iscsi_get_port_state_name(struct Scsi_Host *shost)
3766{
3767 int i;
3768 char *state = "Unknown!";
3769 struct iscsi_cls_host *ihost = shost->shost_data;
3770 uint32_t port_state = ihost->port_state;
3771
3772 for (i = 0; i < ARRAY_SIZE(iscsi_port_state_names); i++) {
3773 if (iscsi_port_state_names[i].value & port_state) {
3774 state = iscsi_port_state_names[i].name;
3775 break;
3776 }
3777 }
3778 return state;
3779}
3780EXPORT_SYMBOL_GPL(iscsi_get_port_state_name);
3781
0896b752
AA		 3782static int iscsi_session_match(struct attribute_container *cont,
3783 struct device *dev)
1da177e4 3784{
7b8631b5 3785 struct iscsi_cls_session *session;
1da177e4 3786 struct Scsi_Host *shost;
0896b752
AA		 3787 struct iscsi_internal *priv;
3788
3789 if (!iscsi_is_session_dev(dev))
3790 return 0;
1da177e4 3791
7b8631b5
MC		 3792 session = iscsi_dev_to_session(dev);
3793 shost = iscsi_session_to_shost(session);
0896b752 3794 if (!shost->transportt)
1da177e4
LT		 3795 return 0;
3796
0896b752
AA		 3797 priv = to_iscsi_internal(shost->transportt);
3798 if (priv->session_cont.ac.class != &iscsi_session_class.class)
1da177e4
LT		 3799 return 0;
3800
0896b752 3801 return &priv->session_cont.ac == cont;
1da177e4
LT		 3802}
3803
0896b752
AA		 3804static int iscsi_conn_match(struct attribute_container *cont,
3805 struct device *dev)
3806{
7b8631b5
MC		 3807 struct iscsi_cls_session *session;
3808 struct iscsi_cls_conn *conn;
1da177e4 3809 struct Scsi_Host *shost;
0896b752 3810 struct iscsi_internal *priv;
1da177e4 3811
0896b752 3812 if (!iscsi_is_conn_dev(dev))
1da177e4
LT		 3813 return 0;
3814
7b8631b5
MC		 3815 conn = iscsi_dev_to_conn(dev);
3816 session = iscsi_dev_to_session(conn->dev.parent);
3817 shost = iscsi_session_to_shost(session);
3818
0896b752 3819 if (!shost->transportt)
1da177e4
LT		 3820 return 0;
3821
0896b752
AA		 3822 priv = to_iscsi_internal(shost->transportt);
3823 if (priv->conn_cont.ac.class != &iscsi_connection_class.class)
3824 return 0;
1da177e4 3825
0896b752
AA		 3826 return &priv->conn_cont.ac == cont;
3827}
3828
30a6c652
MC		 3829static int iscsi_host_match(struct attribute_container *cont,
3830 struct device *dev)
3831{
3832 struct Scsi_Host *shost;
3833 struct iscsi_internal *priv;
3834
3835 if (!scsi_is_host_device(dev))
3836 return 0;
3837
3838 shost = dev_to_shost(dev);
3839 if (!shost->transportt ||
3840 shost->transportt->host_attrs.ac.class != &iscsi_host_class.class)
3841 return 0;
3842
3843 priv = to_iscsi_internal(shost->transportt);
3844 return &priv->t.host_attrs.ac == cont;
3845}
3846
7b8631b5
MC		 3847struct scsi_transport_template *
3848iscsi_register_transport(struct iscsi_transport *tt)
0896b752
AA		 3849{
3850 struct iscsi_internal *priv;
3851 unsigned long flags;
f27fb2ef 3852 int err;
0896b752
AA		 3853
3854 BUG_ON(!tt);
3855
3856 priv = iscsi_if_transport_lookup(tt);
3857 if (priv)
7b8631b5 3858 return NULL;
0896b752 3859
24669f75 3860 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
0896b752 3861 if (!priv)
7b8631b5 3862 return NULL;
0896b752 3863 INIT_LIST_HEAD(&priv->list);
0896b752 3864 priv->iscsi_transport = tt;
30a6c652 3865 priv->t.user_scan = iscsi_user_scan;
06d25af4 3866 priv->t.create_work_queue = 1;
0896b752 3867
ee959b00 3868 priv->dev.class = &iscsi_transport_class;
71610f55 3869 dev_set_name(&priv->dev, "%s", tt->name);
ee959b00 3870 err = device_register(&priv->dev);
0896b752
AA		 3871 if (err)
3872 goto free_priv;
3873
ee959b00 3874 err = sysfs_create_group(&priv->dev.kobj, &iscsi_transport_group);
0896b752 3875 if (err)
ee959b00 3876 goto unregister_dev;
0896b752 3877
30a6c652 3878 /* host parameters */
30a6c652
MC		 3879 priv->t.host_attrs.ac.class = &iscsi_host_class.class;
3880 priv->t.host_attrs.ac.match = iscsi_host_match;
f27fb2ef 3881 priv->t.host_attrs.ac.grp = &iscsi_host_group;
32c6e1b9 3882 priv->t.host_size = sizeof(struct iscsi_cls_host);
30a6c652
MC		 3883 transport_container_register(&priv->t.host_attrs);
3884
0896b752 3885 /* connection parameters */
0896b752
AA		 3886 priv->conn_cont.ac.class = &iscsi_connection_class.class;
3887 priv->conn_cont.ac.match = iscsi_conn_match;
3128c6c7 3888 priv->conn_cont.ac.grp = &iscsi_conn_group;
0896b752 3889 transport_container_register(&priv->conn_cont);
1da177e4 3890
0896b752 3891 /* session parameters */
0896b752
AA		 3892 priv->session_cont.ac.class = &iscsi_session_class.class;
3893 priv->session_cont.ac.match = iscsi_session_match;
1d063c17 3894 priv->session_cont.ac.grp = &iscsi_session_group;
0896b752
AA		 3895 transport_container_register(&priv->session_cont);
3896
0896b752
AA		 3897 spin_lock_irqsave(&iscsi_transport_lock, flags);
3898 list_add(&priv->list, &iscsi_transports);
3899 spin_unlock_irqrestore(&iscsi_transport_lock, flags);
3900
3901 printk(KERN_NOTICE "iscsi: registered transport (%s)\n", tt->name);
7b8631b5 3902 return &priv->t;
1da177e4 3903
ee959b00
TJ		 3904unregister_dev:
3905 device_unregister(&priv->dev);
d82ff9be 3906 return NULL;
0896b752
AA		 3907free_priv:
3908 kfree(priv);
7b8631b5 3909 return NULL;
1da177e4 3910}
0896b752
AA		 3911EXPORT_SYMBOL_GPL(iscsi_register_transport);
3912
3913int iscsi_unregister_transport(struct iscsi_transport *tt)
3914{
3915 struct iscsi_internal *priv;
3916 unsigned long flags;
3917
3918 BUG_ON(!tt);
3919
0b950672 3920 mutex_lock(&rx_queue_mutex);
0896b752
AA		 3921
3922 priv = iscsi_if_transport_lookup(tt);
3923 BUG_ON (!priv);
3924
0896b752
AA		 3925 spin_lock_irqsave(&iscsi_transport_lock, flags);
3926 list_del(&priv->list);
3927 spin_unlock_irqrestore(&iscsi_transport_lock, flags);
3928
3929 transport_container_unregister(&priv->conn_cont);
3930 transport_container_unregister(&priv->session_cont);
30a6c652 3931 transport_container_unregister(&priv->t.host_attrs);
0896b752 3932
ee959b00
TJ		 3933 sysfs_remove_group(&priv->dev.kobj, &iscsi_transport_group);
3934 device_unregister(&priv->dev);
0b950672 3935 mutex_unlock(&rx_queue_mutex);
1da177e4 3936
0896b752
AA		 3937 return 0;
3938}
3939EXPORT_SYMBOL_GPL(iscsi_unregister_transport);
1da177e4 3940
1da177e4
LT		 3941static __init int iscsi_transport_init(void)
3942{
0896b752 3943 int err;
a31f2d17
PNA		 3944 struct netlink_kernel_cfg cfg = {
3945 .groups = 1,
3946 .input = iscsi_if_rx,
3947 };
09492605 3948 printk(KERN_INFO "Loading iSCSI transport class v%s.\n",
f4246b33
MC		 3949 ISCSI_TRANSPORT_VERSION);
3950
41be1444
MC		 3951 atomic_set(&iscsi_session_nr, 0);
3952
0896b752 3953 err = class_register(&iscsi_transport_class);
1da177e4
LT		 3954 if (err)
3955 return err;
0896b752 3956
d82ff9be 3957 err = class_register(&iscsi_endpoint_class);
0896b752
AA		 3958 if (err)
3959 goto unregister_transport_class;
3960
8d07913d 3961 err = class_register(&iscsi_iface_class);
d82ff9be
MC		 3962 if (err)
3963 goto unregister_endpoint_class;
3964
8d07913d
MC		 3965 err = transport_class_register(&iscsi_host_class);
3966 if (err)
3967 goto unregister_iface_class;
3968
30a6c652
MC		 3969 err = transport_class_register(&iscsi_connection_class);
3970 if (err)
3971 goto unregister_host_class;
3972
0896b752
AA		 3973 err = transport_class_register(&iscsi_session_class);
3974 if (err)
3975 goto unregister_conn_class;
3976
c6a4bb2e
AC		 3977 err = bus_register(&iscsi_flashnode_bus);
3978 if (err)
3979 goto unregister_session_class;
3980
9f00d977 3981 nls = netlink_kernel_create(&init_net, NETLINK_ISCSI, &cfg);
0896b752
AA		 3982 if (!nls) {
3983 err = -ENOBUFS;
c6a4bb2e 3984 goto unregister_flashnode_bus;
0896b752
AA		 3985 }
3986
d8bf541e
MC		 3987 iscsi_eh_timer_workq = create_singlethread_workqueue("iscsi_eh");
3988 if (!iscsi_eh_timer_workq)
3989 goto release_nls;
3990
43a145a3 3991 return 0;
0896b752 3992
d8bf541e 3993release_nls:
b7c6ba6e 3994 netlink_kernel_release(nls);
c6a4bb2e
AC		 3995unregister_flashnode_bus:
3996 bus_unregister(&iscsi_flashnode_bus);
0896b752
AA		 3997unregister_session_class:
3998 transport_class_unregister(&iscsi_session_class);
3999unregister_conn_class:
4000 transport_class_unregister(&iscsi_connection_class);
30a6c652
MC		 4001unregister_host_class:
4002 transport_class_unregister(&iscsi_host_class);
8d07913d
MC		 4003unregister_iface_class:
4004 class_unregister(&iscsi_iface_class);
d82ff9be
MC		 4005unregister_endpoint_class:
4006 class_unregister(&iscsi_endpoint_class);
0896b752
AA		 4007unregister_transport_class:
4008 class_unregister(&iscsi_transport_class);
4009 return err;
1da177e4
LT		 4010}
4011
4012static void __exit iscsi_transport_exit(void)
4013{
d8bf541e 4014 destroy_workqueue(iscsi_eh_timer_workq);
b7c6ba6e 4015 netlink_kernel_release(nls);
c6a4bb2e 4016 bus_unregister(&iscsi_flashnode_bus);
0896b752
AA		 4017 transport_class_unregister(&iscsi_connection_class);
4018 transport_class_unregister(&iscsi_session_class);
30a6c652 4019 transport_class_unregister(&iscsi_host_class);
d82ff9be 4020 class_unregister(&iscsi_endpoint_class);
8d07913d 4021 class_unregister(&iscsi_iface_class);
0896b752 4022 class_unregister(&iscsi_transport_class);
1da177e4
LT		 4023}
4024
4025module_init(iscsi_transport_init);
4026module_exit(iscsi_transport_exit);
4027
0896b752
AA		 4028MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu>, "
4029 "Dmitry Yusupov <dmitry_yus@yahoo.com>, "
4030 "Alex Aizman <itn780@yahoo.com>");
4031MODULE_DESCRIPTION("iSCSI Transport Interface");
1da177e4 4032MODULE_LICENSE("GPL");
f4246b33 4033MODULE_VERSION(ISCSI_TRANSPORT_VERSION);
058548ae 4034MODULE_ALIAS_NET_PF_PROTO(PF_NETLINK, NETLINK_ISCSI);
Linux 6.x block layer and io_uring tree(s)