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