1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * iSCSI transport class definitions 4 * 5 * Copyright (C) IBM Corporation, 2004 6 * Copyright (C) Mike Christie, 2004 - 2005 7 * Copyright (C) Dmitry Yusupov, 2004 - 2005 8 * Copyright (C) Alex Aizman, 2004 - 2005 9 */ 10 #include <linux/module.h> 11 #include <linux/mutex.h> 12 #include <linux/slab.h> 13 #include <linux/bsg-lib.h> 14 #include <linux/idr.h> 15 #include <net/tcp.h> 16 #include <scsi/scsi.h> 17 #include <scsi/scsi_host.h> 18 #include <scsi/scsi_device.h> 19 #include <scsi/scsi_transport.h> 20 #include <scsi/scsi_transport_iscsi.h> 21 #include <scsi/iscsi_if.h> 22 #include <scsi/scsi_cmnd.h> 23 #include <scsi/scsi_bsg_iscsi.h> 24 25 #define ISCSI_TRANSPORT_VERSION "2.0-870" 26 27 #define ISCSI_SEND_MAX_ALLOWED 10 28 29 #define CREATE_TRACE_POINTS 30 #include <trace/events/iscsi.h> 31 32 /* 33 * Export tracepoint symbols to be used by other modules. 34 */ 35 EXPORT_TRACEPOINT_SYMBOL_GPL(iscsi_dbg_conn); 36 EXPORT_TRACEPOINT_SYMBOL_GPL(iscsi_dbg_eh); 37 EXPORT_TRACEPOINT_SYMBOL_GPL(iscsi_dbg_session); 38 EXPORT_TRACEPOINT_SYMBOL_GPL(iscsi_dbg_tcp); 39 EXPORT_TRACEPOINT_SYMBOL_GPL(iscsi_dbg_sw_tcp); 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 iscsi_dbg_trace(trace_iscsi_dbg_trans_session, \ 64 &(_session)->dev, \ 65 "%s " dbg_fmt, __func__, ##arg); \ 66 } while (0); 67 68 #define ISCSI_DBG_TRANS_CONN(_conn, dbg_fmt, arg...) \ 69 do { \ 70 if (dbg_conn) \ 71 iscsi_cls_conn_printk(KERN_INFO, _conn, \ 72 "%s: " dbg_fmt, \ 73 __func__, ##arg); \ 74 iscsi_dbg_trace(trace_iscsi_dbg_trans_conn, \ 75 &(_conn)->dev, \ 76 "%s " dbg_fmt, __func__, ##arg); \ 77 } while (0); 78 79 struct iscsi_internal { 80 struct scsi_transport_template t; 81 struct iscsi_transport *iscsi_transport; 82 struct list_head list; 83 struct device dev; 84 85 struct transport_container conn_cont; 86 struct transport_container session_cont; 87 }; 88 89 static atomic_t iscsi_session_nr; /* sysfs session id for next new session */ 90 static struct workqueue_struct *iscsi_eh_timer_workq; 91 92 static struct workqueue_struct *iscsi_conn_cleanup_workq; 93 94 static DEFINE_IDA(iscsi_sess_ida); 95 /* 96 * list of registered transports and lock that must 97 * be held while accessing list. The iscsi_transport_lock must 98 * be acquired after the rx_queue_mutex. 99 */ 100 static LIST_HEAD(iscsi_transports); 101 static DEFINE_SPINLOCK(iscsi_transport_lock); 102 103 #define to_iscsi_internal(tmpl) \ 104 container_of(tmpl, struct iscsi_internal, t) 105 106 #define dev_to_iscsi_internal(_dev) \ 107 container_of(_dev, struct iscsi_internal, dev) 108 109 static void iscsi_transport_release(struct device *dev) 110 { 111 struct iscsi_internal *priv = dev_to_iscsi_internal(dev); 112 kfree(priv); 113 } 114 115 /* 116 * iscsi_transport_class represents the iscsi_transports that are 117 * registered. 118 */ 119 static struct class iscsi_transport_class = { 120 .name = "iscsi_transport", 121 .dev_release = iscsi_transport_release, 122 }; 123 124 static ssize_t 125 show_transport_handle(struct device *dev, struct device_attribute *attr, 126 char *buf) 127 { 128 struct iscsi_internal *priv = dev_to_iscsi_internal(dev); 129 130 if (!capable(CAP_SYS_ADMIN)) 131 return -EACCES; 132 return sysfs_emit(buf, "%llu\n", 133 (unsigned long long)iscsi_handle(priv->iscsi_transport)); 134 } 135 static DEVICE_ATTR(handle, S_IRUGO, show_transport_handle, NULL); 136 137 #define show_transport_attr(name, format) \ 138 static ssize_t \ 139 show_transport_##name(struct device *dev, \ 140 struct device_attribute *attr,char *buf) \ 141 { \ 142 struct iscsi_internal *priv = dev_to_iscsi_internal(dev); \ 143 return sysfs_emit(buf, format"\n", priv->iscsi_transport->name);\ 144 } \ 145 static DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL); 146 147 show_transport_attr(caps, "0x%x"); 148 149 static struct attribute *iscsi_transport_attrs[] = { 150 &dev_attr_handle.attr, 151 &dev_attr_caps.attr, 152 NULL, 153 }; 154 155 static struct attribute_group iscsi_transport_group = { 156 .attrs = iscsi_transport_attrs, 157 }; 158 159 /* 160 * iSCSI endpoint attrs 161 */ 162 #define iscsi_dev_to_endpoint(_dev) \ 163 container_of(_dev, struct iscsi_endpoint, dev) 164 165 #define ISCSI_ATTR(_prefix,_name,_mode,_show,_store) \ 166 struct device_attribute dev_attr_##_prefix##_##_name = \ 167 __ATTR(_name,_mode,_show,_store) 168 169 static void iscsi_endpoint_release(struct device *dev) 170 { 171 struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev); 172 kfree(ep); 173 } 174 175 static struct class iscsi_endpoint_class = { 176 .name = "iscsi_endpoint", 177 .dev_release = iscsi_endpoint_release, 178 }; 179 180 static ssize_t 181 show_ep_handle(struct device *dev, struct device_attribute *attr, char *buf) 182 { 183 struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev); 184 return sysfs_emit(buf, "%llu\n", (unsigned long long) ep->id); 185 } 186 static ISCSI_ATTR(ep, handle, S_IRUGO, show_ep_handle, NULL); 187 188 static struct attribute *iscsi_endpoint_attrs[] = { 189 &dev_attr_ep_handle.attr, 190 NULL, 191 }; 192 193 static struct attribute_group iscsi_endpoint_group = { 194 .attrs = iscsi_endpoint_attrs, 195 }; 196 197 #define ISCSI_MAX_EPID -1 198 199 static int iscsi_match_epid(struct device *dev, const void *data) 200 { 201 struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev); 202 const uint64_t *epid = data; 203 204 return *epid == ep->id; 205 } 206 207 struct iscsi_endpoint * 208 iscsi_create_endpoint(int dd_size) 209 { 210 struct device *dev; 211 struct iscsi_endpoint *ep; 212 uint64_t id; 213 int err; 214 215 for (id = 1; id < ISCSI_MAX_EPID; id++) { 216 dev = class_find_device(&iscsi_endpoint_class, NULL, &id, 217 iscsi_match_epid); 218 if (!dev) 219 break; 220 else 221 put_device(dev); 222 } 223 if (id == ISCSI_MAX_EPID) { 224 printk(KERN_ERR "Too many connections. Max supported %u\n", 225 ISCSI_MAX_EPID - 1); 226 return NULL; 227 } 228 229 ep = kzalloc(sizeof(*ep) + dd_size, GFP_KERNEL); 230 if (!ep) 231 return NULL; 232 233 ep->id = id; 234 ep->dev.class = &iscsi_endpoint_class; 235 dev_set_name(&ep->dev, "ep-%llu", (unsigned long long) id); 236 err = device_register(&ep->dev); 237 if (err) 238 goto free_ep; 239 240 err = sysfs_create_group(&ep->dev.kobj, &iscsi_endpoint_group); 241 if (err) 242 goto unregister_dev; 243 244 if (dd_size) 245 ep->dd_data = &ep[1]; 246 return ep; 247 248 unregister_dev: 249 device_unregister(&ep->dev); 250 return NULL; 251 252 free_ep: 253 kfree(ep); 254 return NULL; 255 } 256 EXPORT_SYMBOL_GPL(iscsi_create_endpoint); 257 258 void iscsi_destroy_endpoint(struct iscsi_endpoint *ep) 259 { 260 sysfs_remove_group(&ep->dev.kobj, &iscsi_endpoint_group); 261 device_unregister(&ep->dev); 262 } 263 EXPORT_SYMBOL_GPL(iscsi_destroy_endpoint); 264 265 void iscsi_put_endpoint(struct iscsi_endpoint *ep) 266 { 267 put_device(&ep->dev); 268 } 269 EXPORT_SYMBOL_GPL(iscsi_put_endpoint); 270 271 /** 272 * iscsi_lookup_endpoint - get ep from handle 273 * @handle: endpoint handle 274 * 275 * Caller must do a iscsi_put_endpoint. 276 */ 277 struct iscsi_endpoint *iscsi_lookup_endpoint(u64 handle) 278 { 279 struct device *dev; 280 281 dev = class_find_device(&iscsi_endpoint_class, NULL, &handle, 282 iscsi_match_epid); 283 if (!dev) 284 return NULL; 285 286 return iscsi_dev_to_endpoint(dev); 287 } 288 EXPORT_SYMBOL_GPL(iscsi_lookup_endpoint); 289 290 /* 291 * Interface to display network param to sysfs 292 */ 293 294 static void iscsi_iface_release(struct device *dev) 295 { 296 struct iscsi_iface *iface = iscsi_dev_to_iface(dev); 297 struct device *parent = iface->dev.parent; 298 299 kfree(iface); 300 put_device(parent); 301 } 302 303 304 static struct class iscsi_iface_class = { 305 .name = "iscsi_iface", 306 .dev_release = iscsi_iface_release, 307 }; 308 309 #define ISCSI_IFACE_ATTR(_prefix, _name, _mode, _show, _store) \ 310 struct device_attribute dev_attr_##_prefix##_##_name = \ 311 __ATTR(_name, _mode, _show, _store) 312 313 /* iface attrs show */ 314 #define iscsi_iface_attr_show(type, name, param_type, param) \ 315 static ssize_t \ 316 show_##type##_##name(struct device *dev, struct device_attribute *attr, \ 317 char *buf) \ 318 { \ 319 struct iscsi_iface *iface = iscsi_dev_to_iface(dev); \ 320 struct iscsi_transport *t = iface->transport; \ 321 return t->get_iface_param(iface, param_type, param, buf); \ 322 } \ 323 324 #define iscsi_iface_net_attr(type, name, param) \ 325 iscsi_iface_attr_show(type, name, ISCSI_NET_PARAM, param) \ 326 static ISCSI_IFACE_ATTR(type, name, S_IRUGO, show_##type##_##name, NULL); 327 328 #define iscsi_iface_attr(type, name, param) \ 329 iscsi_iface_attr_show(type, name, ISCSI_IFACE_PARAM, param) \ 330 static ISCSI_IFACE_ATTR(type, name, S_IRUGO, show_##type##_##name, NULL); 331 332 /* generic read only ipv4 attribute */ 333 iscsi_iface_net_attr(ipv4_iface, ipaddress, ISCSI_NET_PARAM_IPV4_ADDR); 334 iscsi_iface_net_attr(ipv4_iface, gateway, ISCSI_NET_PARAM_IPV4_GW); 335 iscsi_iface_net_attr(ipv4_iface, subnet, ISCSI_NET_PARAM_IPV4_SUBNET); 336 iscsi_iface_net_attr(ipv4_iface, bootproto, ISCSI_NET_PARAM_IPV4_BOOTPROTO); 337 iscsi_iface_net_attr(ipv4_iface, dhcp_dns_address_en, 338 ISCSI_NET_PARAM_IPV4_DHCP_DNS_ADDR_EN); 339 iscsi_iface_net_attr(ipv4_iface, dhcp_slp_da_info_en, 340 ISCSI_NET_PARAM_IPV4_DHCP_SLP_DA_EN); 341 iscsi_iface_net_attr(ipv4_iface, tos_en, ISCSI_NET_PARAM_IPV4_TOS_EN); 342 iscsi_iface_net_attr(ipv4_iface, tos, ISCSI_NET_PARAM_IPV4_TOS); 343 iscsi_iface_net_attr(ipv4_iface, grat_arp_en, 344 ISCSI_NET_PARAM_IPV4_GRAT_ARP_EN); 345 iscsi_iface_net_attr(ipv4_iface, dhcp_alt_client_id_en, 346 ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID_EN); 347 iscsi_iface_net_attr(ipv4_iface, dhcp_alt_client_id, 348 ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID); 349 iscsi_iface_net_attr(ipv4_iface, dhcp_req_vendor_id_en, 350 ISCSI_NET_PARAM_IPV4_DHCP_REQ_VENDOR_ID_EN); 351 iscsi_iface_net_attr(ipv4_iface, dhcp_use_vendor_id_en, 352 ISCSI_NET_PARAM_IPV4_DHCP_USE_VENDOR_ID_EN); 353 iscsi_iface_net_attr(ipv4_iface, dhcp_vendor_id, 354 ISCSI_NET_PARAM_IPV4_DHCP_VENDOR_ID); 355 iscsi_iface_net_attr(ipv4_iface, dhcp_learn_iqn_en, 356 ISCSI_NET_PARAM_IPV4_DHCP_LEARN_IQN_EN); 357 iscsi_iface_net_attr(ipv4_iface, fragment_disable, 358 ISCSI_NET_PARAM_IPV4_FRAGMENT_DISABLE); 359 iscsi_iface_net_attr(ipv4_iface, incoming_forwarding_en, 360 ISCSI_NET_PARAM_IPV4_IN_FORWARD_EN); 361 iscsi_iface_net_attr(ipv4_iface, ttl, ISCSI_NET_PARAM_IPV4_TTL); 362 363 /* generic read only ipv6 attribute */ 364 iscsi_iface_net_attr(ipv6_iface, ipaddress, ISCSI_NET_PARAM_IPV6_ADDR); 365 iscsi_iface_net_attr(ipv6_iface, link_local_addr, 366 ISCSI_NET_PARAM_IPV6_LINKLOCAL); 367 iscsi_iface_net_attr(ipv6_iface, router_addr, ISCSI_NET_PARAM_IPV6_ROUTER); 368 iscsi_iface_net_attr(ipv6_iface, ipaddr_autocfg, 369 ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG); 370 iscsi_iface_net_attr(ipv6_iface, link_local_autocfg, 371 ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG); 372 iscsi_iface_net_attr(ipv6_iface, link_local_state, 373 ISCSI_NET_PARAM_IPV6_LINKLOCAL_STATE); 374 iscsi_iface_net_attr(ipv6_iface, router_state, 375 ISCSI_NET_PARAM_IPV6_ROUTER_STATE); 376 iscsi_iface_net_attr(ipv6_iface, grat_neighbor_adv_en, 377 ISCSI_NET_PARAM_IPV6_GRAT_NEIGHBOR_ADV_EN); 378 iscsi_iface_net_attr(ipv6_iface, mld_en, ISCSI_NET_PARAM_IPV6_MLD_EN); 379 iscsi_iface_net_attr(ipv6_iface, flow_label, ISCSI_NET_PARAM_IPV6_FLOW_LABEL); 380 iscsi_iface_net_attr(ipv6_iface, traffic_class, 381 ISCSI_NET_PARAM_IPV6_TRAFFIC_CLASS); 382 iscsi_iface_net_attr(ipv6_iface, hop_limit, ISCSI_NET_PARAM_IPV6_HOP_LIMIT); 383 iscsi_iface_net_attr(ipv6_iface, nd_reachable_tmo, 384 ISCSI_NET_PARAM_IPV6_ND_REACHABLE_TMO); 385 iscsi_iface_net_attr(ipv6_iface, nd_rexmit_time, 386 ISCSI_NET_PARAM_IPV6_ND_REXMIT_TIME); 387 iscsi_iface_net_attr(ipv6_iface, nd_stale_tmo, 388 ISCSI_NET_PARAM_IPV6_ND_STALE_TMO); 389 iscsi_iface_net_attr(ipv6_iface, dup_addr_detect_cnt, 390 ISCSI_NET_PARAM_IPV6_DUP_ADDR_DETECT_CNT); 391 iscsi_iface_net_attr(ipv6_iface, router_adv_link_mtu, 392 ISCSI_NET_PARAM_IPV6_RTR_ADV_LINK_MTU); 393 394 /* common read only iface attribute */ 395 iscsi_iface_net_attr(iface, enabled, ISCSI_NET_PARAM_IFACE_ENABLE); 396 iscsi_iface_net_attr(iface, vlan_id, ISCSI_NET_PARAM_VLAN_ID); 397 iscsi_iface_net_attr(iface, vlan_priority, ISCSI_NET_PARAM_VLAN_PRIORITY); 398 iscsi_iface_net_attr(iface, vlan_enabled, ISCSI_NET_PARAM_VLAN_ENABLED); 399 iscsi_iface_net_attr(iface, mtu, ISCSI_NET_PARAM_MTU); 400 iscsi_iface_net_attr(iface, port, ISCSI_NET_PARAM_PORT); 401 iscsi_iface_net_attr(iface, ipaddress_state, ISCSI_NET_PARAM_IPADDR_STATE); 402 iscsi_iface_net_attr(iface, delayed_ack_en, ISCSI_NET_PARAM_DELAYED_ACK_EN); 403 iscsi_iface_net_attr(iface, tcp_nagle_disable, 404 ISCSI_NET_PARAM_TCP_NAGLE_DISABLE); 405 iscsi_iface_net_attr(iface, tcp_wsf_disable, ISCSI_NET_PARAM_TCP_WSF_DISABLE); 406 iscsi_iface_net_attr(iface, tcp_wsf, ISCSI_NET_PARAM_TCP_WSF); 407 iscsi_iface_net_attr(iface, tcp_timer_scale, ISCSI_NET_PARAM_TCP_TIMER_SCALE); 408 iscsi_iface_net_attr(iface, tcp_timestamp_en, ISCSI_NET_PARAM_TCP_TIMESTAMP_EN); 409 iscsi_iface_net_attr(iface, cache_id, ISCSI_NET_PARAM_CACHE_ID); 410 iscsi_iface_net_attr(iface, redirect_en, ISCSI_NET_PARAM_REDIRECT_EN); 411 412 /* common iscsi specific settings attributes */ 413 iscsi_iface_attr(iface, def_taskmgmt_tmo, ISCSI_IFACE_PARAM_DEF_TASKMGMT_TMO); 414 iscsi_iface_attr(iface, header_digest, ISCSI_IFACE_PARAM_HDRDGST_EN); 415 iscsi_iface_attr(iface, data_digest, ISCSI_IFACE_PARAM_DATADGST_EN); 416 iscsi_iface_attr(iface, immediate_data, ISCSI_IFACE_PARAM_IMM_DATA_EN); 417 iscsi_iface_attr(iface, initial_r2t, ISCSI_IFACE_PARAM_INITIAL_R2T_EN); 418 iscsi_iface_attr(iface, data_seq_in_order, 419 ISCSI_IFACE_PARAM_DATASEQ_INORDER_EN); 420 iscsi_iface_attr(iface, data_pdu_in_order, ISCSI_IFACE_PARAM_PDU_INORDER_EN); 421 iscsi_iface_attr(iface, erl, ISCSI_IFACE_PARAM_ERL); 422 iscsi_iface_attr(iface, max_recv_dlength, ISCSI_IFACE_PARAM_MAX_RECV_DLENGTH); 423 iscsi_iface_attr(iface, first_burst_len, ISCSI_IFACE_PARAM_FIRST_BURST); 424 iscsi_iface_attr(iface, max_outstanding_r2t, ISCSI_IFACE_PARAM_MAX_R2T); 425 iscsi_iface_attr(iface, max_burst_len, ISCSI_IFACE_PARAM_MAX_BURST); 426 iscsi_iface_attr(iface, chap_auth, ISCSI_IFACE_PARAM_CHAP_AUTH_EN); 427 iscsi_iface_attr(iface, bidi_chap, ISCSI_IFACE_PARAM_BIDI_CHAP_EN); 428 iscsi_iface_attr(iface, discovery_auth_optional, 429 ISCSI_IFACE_PARAM_DISCOVERY_AUTH_OPTIONAL); 430 iscsi_iface_attr(iface, discovery_logout, 431 ISCSI_IFACE_PARAM_DISCOVERY_LOGOUT_EN); 432 iscsi_iface_attr(iface, strict_login_comp_en, 433 ISCSI_IFACE_PARAM_STRICT_LOGIN_COMP_EN); 434 iscsi_iface_attr(iface, initiator_name, ISCSI_IFACE_PARAM_INITIATOR_NAME); 435 436 static umode_t iscsi_iface_attr_is_visible(struct kobject *kobj, 437 struct attribute *attr, int i) 438 { 439 struct device *dev = container_of(kobj, struct device, kobj); 440 struct iscsi_iface *iface = iscsi_dev_to_iface(dev); 441 struct iscsi_transport *t = iface->transport; 442 int param = -1; 443 444 if (attr == &dev_attr_iface_enabled.attr) 445 param = ISCSI_NET_PARAM_IFACE_ENABLE; 446 else if (attr == &dev_attr_iface_def_taskmgmt_tmo.attr) 447 param = ISCSI_IFACE_PARAM_DEF_TASKMGMT_TMO; 448 else if (attr == &dev_attr_iface_header_digest.attr) 449 param = ISCSI_IFACE_PARAM_HDRDGST_EN; 450 else if (attr == &dev_attr_iface_data_digest.attr) 451 param = ISCSI_IFACE_PARAM_DATADGST_EN; 452 else if (attr == &dev_attr_iface_immediate_data.attr) 453 param = ISCSI_IFACE_PARAM_IMM_DATA_EN; 454 else if (attr == &dev_attr_iface_initial_r2t.attr) 455 param = ISCSI_IFACE_PARAM_INITIAL_R2T_EN; 456 else if (attr == &dev_attr_iface_data_seq_in_order.attr) 457 param = ISCSI_IFACE_PARAM_DATASEQ_INORDER_EN; 458 else if (attr == &dev_attr_iface_data_pdu_in_order.attr) 459 param = ISCSI_IFACE_PARAM_PDU_INORDER_EN; 460 else if (attr == &dev_attr_iface_erl.attr) 461 param = ISCSI_IFACE_PARAM_ERL; 462 else if (attr == &dev_attr_iface_max_recv_dlength.attr) 463 param = ISCSI_IFACE_PARAM_MAX_RECV_DLENGTH; 464 else if (attr == &dev_attr_iface_first_burst_len.attr) 465 param = ISCSI_IFACE_PARAM_FIRST_BURST; 466 else if (attr == &dev_attr_iface_max_outstanding_r2t.attr) 467 param = ISCSI_IFACE_PARAM_MAX_R2T; 468 else if (attr == &dev_attr_iface_max_burst_len.attr) 469 param = ISCSI_IFACE_PARAM_MAX_BURST; 470 else if (attr == &dev_attr_iface_chap_auth.attr) 471 param = ISCSI_IFACE_PARAM_CHAP_AUTH_EN; 472 else if (attr == &dev_attr_iface_bidi_chap.attr) 473 param = ISCSI_IFACE_PARAM_BIDI_CHAP_EN; 474 else if (attr == &dev_attr_iface_discovery_auth_optional.attr) 475 param = ISCSI_IFACE_PARAM_DISCOVERY_AUTH_OPTIONAL; 476 else if (attr == &dev_attr_iface_discovery_logout.attr) 477 param = ISCSI_IFACE_PARAM_DISCOVERY_LOGOUT_EN; 478 else if (attr == &dev_attr_iface_strict_login_comp_en.attr) 479 param = ISCSI_IFACE_PARAM_STRICT_LOGIN_COMP_EN; 480 else if (attr == &dev_attr_iface_initiator_name.attr) 481 param = ISCSI_IFACE_PARAM_INITIATOR_NAME; 482 483 if (param != -1) 484 return t->attr_is_visible(ISCSI_IFACE_PARAM, param); 485 486 if (attr == &dev_attr_iface_vlan_id.attr) 487 param = ISCSI_NET_PARAM_VLAN_ID; 488 else if (attr == &dev_attr_iface_vlan_priority.attr) 489 param = ISCSI_NET_PARAM_VLAN_PRIORITY; 490 else if (attr == &dev_attr_iface_vlan_enabled.attr) 491 param = ISCSI_NET_PARAM_VLAN_ENABLED; 492 else if (attr == &dev_attr_iface_mtu.attr) 493 param = ISCSI_NET_PARAM_MTU; 494 else if (attr == &dev_attr_iface_port.attr) 495 param = ISCSI_NET_PARAM_PORT; 496 else if (attr == &dev_attr_iface_ipaddress_state.attr) 497 param = ISCSI_NET_PARAM_IPADDR_STATE; 498 else if (attr == &dev_attr_iface_delayed_ack_en.attr) 499 param = ISCSI_NET_PARAM_DELAYED_ACK_EN; 500 else if (attr == &dev_attr_iface_tcp_nagle_disable.attr) 501 param = ISCSI_NET_PARAM_TCP_NAGLE_DISABLE; 502 else if (attr == &dev_attr_iface_tcp_wsf_disable.attr) 503 param = ISCSI_NET_PARAM_TCP_WSF_DISABLE; 504 else if (attr == &dev_attr_iface_tcp_wsf.attr) 505 param = ISCSI_NET_PARAM_TCP_WSF; 506 else if (attr == &dev_attr_iface_tcp_timer_scale.attr) 507 param = ISCSI_NET_PARAM_TCP_TIMER_SCALE; 508 else if (attr == &dev_attr_iface_tcp_timestamp_en.attr) 509 param = ISCSI_NET_PARAM_TCP_TIMESTAMP_EN; 510 else if (attr == &dev_attr_iface_cache_id.attr) 511 param = ISCSI_NET_PARAM_CACHE_ID; 512 else if (attr == &dev_attr_iface_redirect_en.attr) 513 param = ISCSI_NET_PARAM_REDIRECT_EN; 514 else if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) { 515 if (attr == &dev_attr_ipv4_iface_ipaddress.attr) 516 param = ISCSI_NET_PARAM_IPV4_ADDR; 517 else if (attr == &dev_attr_ipv4_iface_gateway.attr) 518 param = ISCSI_NET_PARAM_IPV4_GW; 519 else if (attr == &dev_attr_ipv4_iface_subnet.attr) 520 param = ISCSI_NET_PARAM_IPV4_SUBNET; 521 else if (attr == &dev_attr_ipv4_iface_bootproto.attr) 522 param = ISCSI_NET_PARAM_IPV4_BOOTPROTO; 523 else if (attr == 524 &dev_attr_ipv4_iface_dhcp_dns_address_en.attr) 525 param = ISCSI_NET_PARAM_IPV4_DHCP_DNS_ADDR_EN; 526 else if (attr == 527 &dev_attr_ipv4_iface_dhcp_slp_da_info_en.attr) 528 param = ISCSI_NET_PARAM_IPV4_DHCP_SLP_DA_EN; 529 else if (attr == &dev_attr_ipv4_iface_tos_en.attr) 530 param = ISCSI_NET_PARAM_IPV4_TOS_EN; 531 else if (attr == &dev_attr_ipv4_iface_tos.attr) 532 param = ISCSI_NET_PARAM_IPV4_TOS; 533 else if (attr == &dev_attr_ipv4_iface_grat_arp_en.attr) 534 param = ISCSI_NET_PARAM_IPV4_GRAT_ARP_EN; 535 else if (attr == 536 &dev_attr_ipv4_iface_dhcp_alt_client_id_en.attr) 537 param = ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID_EN; 538 else if (attr == &dev_attr_ipv4_iface_dhcp_alt_client_id.attr) 539 param = ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID; 540 else if (attr == 541 &dev_attr_ipv4_iface_dhcp_req_vendor_id_en.attr) 542 param = ISCSI_NET_PARAM_IPV4_DHCP_REQ_VENDOR_ID_EN; 543 else if (attr == 544 &dev_attr_ipv4_iface_dhcp_use_vendor_id_en.attr) 545 param = ISCSI_NET_PARAM_IPV4_DHCP_USE_VENDOR_ID_EN; 546 else if (attr == &dev_attr_ipv4_iface_dhcp_vendor_id.attr) 547 param = ISCSI_NET_PARAM_IPV4_DHCP_VENDOR_ID; 548 else if (attr == 549 &dev_attr_ipv4_iface_dhcp_learn_iqn_en.attr) 550 param = ISCSI_NET_PARAM_IPV4_DHCP_LEARN_IQN_EN; 551 else if (attr == 552 &dev_attr_ipv4_iface_fragment_disable.attr) 553 param = ISCSI_NET_PARAM_IPV4_FRAGMENT_DISABLE; 554 else if (attr == 555 &dev_attr_ipv4_iface_incoming_forwarding_en.attr) 556 param = ISCSI_NET_PARAM_IPV4_IN_FORWARD_EN; 557 else if (attr == &dev_attr_ipv4_iface_ttl.attr) 558 param = ISCSI_NET_PARAM_IPV4_TTL; 559 else 560 return 0; 561 } else if (iface->iface_type == ISCSI_IFACE_TYPE_IPV6) { 562 if (attr == &dev_attr_ipv6_iface_ipaddress.attr) 563 param = ISCSI_NET_PARAM_IPV6_ADDR; 564 else if (attr == &dev_attr_ipv6_iface_link_local_addr.attr) 565 param = ISCSI_NET_PARAM_IPV6_LINKLOCAL; 566 else if (attr == &dev_attr_ipv6_iface_router_addr.attr) 567 param = ISCSI_NET_PARAM_IPV6_ROUTER; 568 else if (attr == &dev_attr_ipv6_iface_ipaddr_autocfg.attr) 569 param = ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG; 570 else if (attr == &dev_attr_ipv6_iface_link_local_autocfg.attr) 571 param = ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG; 572 else if (attr == &dev_attr_ipv6_iface_link_local_state.attr) 573 param = ISCSI_NET_PARAM_IPV6_LINKLOCAL_STATE; 574 else if (attr == &dev_attr_ipv6_iface_router_state.attr) 575 param = ISCSI_NET_PARAM_IPV6_ROUTER_STATE; 576 else if (attr == 577 &dev_attr_ipv6_iface_grat_neighbor_adv_en.attr) 578 param = ISCSI_NET_PARAM_IPV6_GRAT_NEIGHBOR_ADV_EN; 579 else if (attr == &dev_attr_ipv6_iface_mld_en.attr) 580 param = ISCSI_NET_PARAM_IPV6_MLD_EN; 581 else if (attr == &dev_attr_ipv6_iface_flow_label.attr) 582 param = ISCSI_NET_PARAM_IPV6_FLOW_LABEL; 583 else if (attr == &dev_attr_ipv6_iface_traffic_class.attr) 584 param = ISCSI_NET_PARAM_IPV6_TRAFFIC_CLASS; 585 else if (attr == &dev_attr_ipv6_iface_hop_limit.attr) 586 param = ISCSI_NET_PARAM_IPV6_HOP_LIMIT; 587 else if (attr == &dev_attr_ipv6_iface_nd_reachable_tmo.attr) 588 param = ISCSI_NET_PARAM_IPV6_ND_REACHABLE_TMO; 589 else if (attr == &dev_attr_ipv6_iface_nd_rexmit_time.attr) 590 param = ISCSI_NET_PARAM_IPV6_ND_REXMIT_TIME; 591 else if (attr == &dev_attr_ipv6_iface_nd_stale_tmo.attr) 592 param = ISCSI_NET_PARAM_IPV6_ND_STALE_TMO; 593 else if (attr == &dev_attr_ipv6_iface_dup_addr_detect_cnt.attr) 594 param = ISCSI_NET_PARAM_IPV6_DUP_ADDR_DETECT_CNT; 595 else if (attr == &dev_attr_ipv6_iface_router_adv_link_mtu.attr) 596 param = ISCSI_NET_PARAM_IPV6_RTR_ADV_LINK_MTU; 597 else 598 return 0; 599 } else { 600 WARN_ONCE(1, "Invalid iface attr"); 601 return 0; 602 } 603 604 return t->attr_is_visible(ISCSI_NET_PARAM, param); 605 } 606 607 static struct attribute *iscsi_iface_attrs[] = { 608 &dev_attr_iface_enabled.attr, 609 &dev_attr_iface_vlan_id.attr, 610 &dev_attr_iface_vlan_priority.attr, 611 &dev_attr_iface_vlan_enabled.attr, 612 &dev_attr_ipv4_iface_ipaddress.attr, 613 &dev_attr_ipv4_iface_gateway.attr, 614 &dev_attr_ipv4_iface_subnet.attr, 615 &dev_attr_ipv4_iface_bootproto.attr, 616 &dev_attr_ipv6_iface_ipaddress.attr, 617 &dev_attr_ipv6_iface_link_local_addr.attr, 618 &dev_attr_ipv6_iface_router_addr.attr, 619 &dev_attr_ipv6_iface_ipaddr_autocfg.attr, 620 &dev_attr_ipv6_iface_link_local_autocfg.attr, 621 &dev_attr_iface_mtu.attr, 622 &dev_attr_iface_port.attr, 623 &dev_attr_iface_ipaddress_state.attr, 624 &dev_attr_iface_delayed_ack_en.attr, 625 &dev_attr_iface_tcp_nagle_disable.attr, 626 &dev_attr_iface_tcp_wsf_disable.attr, 627 &dev_attr_iface_tcp_wsf.attr, 628 &dev_attr_iface_tcp_timer_scale.attr, 629 &dev_attr_iface_tcp_timestamp_en.attr, 630 &dev_attr_iface_cache_id.attr, 631 &dev_attr_iface_redirect_en.attr, 632 &dev_attr_iface_def_taskmgmt_tmo.attr, 633 &dev_attr_iface_header_digest.attr, 634 &dev_attr_iface_data_digest.attr, 635 &dev_attr_iface_immediate_data.attr, 636 &dev_attr_iface_initial_r2t.attr, 637 &dev_attr_iface_data_seq_in_order.attr, 638 &dev_attr_iface_data_pdu_in_order.attr, 639 &dev_attr_iface_erl.attr, 640 &dev_attr_iface_max_recv_dlength.attr, 641 &dev_attr_iface_first_burst_len.attr, 642 &dev_attr_iface_max_outstanding_r2t.attr, 643 &dev_attr_iface_max_burst_len.attr, 644 &dev_attr_iface_chap_auth.attr, 645 &dev_attr_iface_bidi_chap.attr, 646 &dev_attr_iface_discovery_auth_optional.attr, 647 &dev_attr_iface_discovery_logout.attr, 648 &dev_attr_iface_strict_login_comp_en.attr, 649 &dev_attr_iface_initiator_name.attr, 650 &dev_attr_ipv4_iface_dhcp_dns_address_en.attr, 651 &dev_attr_ipv4_iface_dhcp_slp_da_info_en.attr, 652 &dev_attr_ipv4_iface_tos_en.attr, 653 &dev_attr_ipv4_iface_tos.attr, 654 &dev_attr_ipv4_iface_grat_arp_en.attr, 655 &dev_attr_ipv4_iface_dhcp_alt_client_id_en.attr, 656 &dev_attr_ipv4_iface_dhcp_alt_client_id.attr, 657 &dev_attr_ipv4_iface_dhcp_req_vendor_id_en.attr, 658 &dev_attr_ipv4_iface_dhcp_use_vendor_id_en.attr, 659 &dev_attr_ipv4_iface_dhcp_vendor_id.attr, 660 &dev_attr_ipv4_iface_dhcp_learn_iqn_en.attr, 661 &dev_attr_ipv4_iface_fragment_disable.attr, 662 &dev_attr_ipv4_iface_incoming_forwarding_en.attr, 663 &dev_attr_ipv4_iface_ttl.attr, 664 &dev_attr_ipv6_iface_link_local_state.attr, 665 &dev_attr_ipv6_iface_router_state.attr, 666 &dev_attr_ipv6_iface_grat_neighbor_adv_en.attr, 667 &dev_attr_ipv6_iface_mld_en.attr, 668 &dev_attr_ipv6_iface_flow_label.attr, 669 &dev_attr_ipv6_iface_traffic_class.attr, 670 &dev_attr_ipv6_iface_hop_limit.attr, 671 &dev_attr_ipv6_iface_nd_reachable_tmo.attr, 672 &dev_attr_ipv6_iface_nd_rexmit_time.attr, 673 &dev_attr_ipv6_iface_nd_stale_tmo.attr, 674 &dev_attr_ipv6_iface_dup_addr_detect_cnt.attr, 675 &dev_attr_ipv6_iface_router_adv_link_mtu.attr, 676 NULL, 677 }; 678 679 static struct attribute_group iscsi_iface_group = { 680 .attrs = iscsi_iface_attrs, 681 .is_visible = iscsi_iface_attr_is_visible, 682 }; 683 684 /* convert iscsi_ipaddress_state values to ascii string name */ 685 static const struct { 686 enum iscsi_ipaddress_state value; 687 char *name; 688 } iscsi_ipaddress_state_names[] = { 689 {ISCSI_IPDDRESS_STATE_UNCONFIGURED, "Unconfigured" }, 690 {ISCSI_IPDDRESS_STATE_ACQUIRING, "Acquiring" }, 691 {ISCSI_IPDDRESS_STATE_TENTATIVE, "Tentative" }, 692 {ISCSI_IPDDRESS_STATE_VALID, "Valid" }, 693 {ISCSI_IPDDRESS_STATE_DISABLING, "Disabling" }, 694 {ISCSI_IPDDRESS_STATE_INVALID, "Invalid" }, 695 {ISCSI_IPDDRESS_STATE_DEPRECATED, "Deprecated" }, 696 }; 697 698 char *iscsi_get_ipaddress_state_name(enum iscsi_ipaddress_state port_state) 699 { 700 int i; 701 char *state = NULL; 702 703 for (i = 0; i < ARRAY_SIZE(iscsi_ipaddress_state_names); i++) { 704 if (iscsi_ipaddress_state_names[i].value == port_state) { 705 state = iscsi_ipaddress_state_names[i].name; 706 break; 707 } 708 } 709 return state; 710 } 711 EXPORT_SYMBOL_GPL(iscsi_get_ipaddress_state_name); 712 713 /* convert iscsi_router_state values to ascii string name */ 714 static const struct { 715 enum iscsi_router_state value; 716 char *name; 717 } iscsi_router_state_names[] = { 718 {ISCSI_ROUTER_STATE_UNKNOWN, "Unknown" }, 719 {ISCSI_ROUTER_STATE_ADVERTISED, "Advertised" }, 720 {ISCSI_ROUTER_STATE_MANUAL, "Manual" }, 721 {ISCSI_ROUTER_STATE_STALE, "Stale" }, 722 }; 723 724 char *iscsi_get_router_state_name(enum iscsi_router_state router_state) 725 { 726 int i; 727 char *state = NULL; 728 729 for (i = 0; i < ARRAY_SIZE(iscsi_router_state_names); i++) { 730 if (iscsi_router_state_names[i].value == router_state) { 731 state = iscsi_router_state_names[i].name; 732 break; 733 } 734 } 735 return state; 736 } 737 EXPORT_SYMBOL_GPL(iscsi_get_router_state_name); 738 739 struct iscsi_iface * 740 iscsi_create_iface(struct Scsi_Host *shost, struct iscsi_transport *transport, 741 uint32_t iface_type, uint32_t iface_num, int dd_size) 742 { 743 struct iscsi_iface *iface; 744 int err; 745 746 iface = kzalloc(sizeof(*iface) + dd_size, GFP_KERNEL); 747 if (!iface) 748 return NULL; 749 750 iface->transport = transport; 751 iface->iface_type = iface_type; 752 iface->iface_num = iface_num; 753 iface->dev.release = iscsi_iface_release; 754 iface->dev.class = &iscsi_iface_class; 755 /* parent reference released in iscsi_iface_release */ 756 iface->dev.parent = get_device(&shost->shost_gendev); 757 if (iface_type == ISCSI_IFACE_TYPE_IPV4) 758 dev_set_name(&iface->dev, "ipv4-iface-%u-%u", shost->host_no, 759 iface_num); 760 else 761 dev_set_name(&iface->dev, "ipv6-iface-%u-%u", shost->host_no, 762 iface_num); 763 764 err = device_register(&iface->dev); 765 if (err) 766 goto free_iface; 767 768 err = sysfs_create_group(&iface->dev.kobj, &iscsi_iface_group); 769 if (err) 770 goto unreg_iface; 771 772 if (dd_size) 773 iface->dd_data = &iface[1]; 774 return iface; 775 776 unreg_iface: 777 device_unregister(&iface->dev); 778 return NULL; 779 780 free_iface: 781 put_device(iface->dev.parent); 782 kfree(iface); 783 return NULL; 784 } 785 EXPORT_SYMBOL_GPL(iscsi_create_iface); 786 787 void iscsi_destroy_iface(struct iscsi_iface *iface) 788 { 789 sysfs_remove_group(&iface->dev.kobj, &iscsi_iface_group); 790 device_unregister(&iface->dev); 791 } 792 EXPORT_SYMBOL_GPL(iscsi_destroy_iface); 793 794 /* 795 * Interface to display flash node params to sysfs 796 */ 797 798 #define ISCSI_FLASHNODE_ATTR(_prefix, _name, _mode, _show, _store) \ 799 struct device_attribute dev_attr_##_prefix##_##_name = \ 800 __ATTR(_name, _mode, _show, _store) 801 802 /* flash node session attrs show */ 803 #define iscsi_flashnode_sess_attr_show(type, name, param) \ 804 static ssize_t \ 805 show_##type##_##name(struct device *dev, struct device_attribute *attr, \ 806 char *buf) \ 807 { \ 808 struct iscsi_bus_flash_session *fnode_sess = \ 809 iscsi_dev_to_flash_session(dev);\ 810 struct iscsi_transport *t = fnode_sess->transport; \ 811 return t->get_flashnode_param(fnode_sess, param, buf); \ 812 } \ 813 814 815 #define iscsi_flashnode_sess_attr(type, name, param) \ 816 iscsi_flashnode_sess_attr_show(type, name, param) \ 817 static ISCSI_FLASHNODE_ATTR(type, name, S_IRUGO, \ 818 show_##type##_##name, NULL); 819 820 /* Flash node session attributes */ 821 822 iscsi_flashnode_sess_attr(fnode, auto_snd_tgt_disable, 823 ISCSI_FLASHNODE_AUTO_SND_TGT_DISABLE); 824 iscsi_flashnode_sess_attr(fnode, discovery_session, 825 ISCSI_FLASHNODE_DISCOVERY_SESS); 826 iscsi_flashnode_sess_attr(fnode, portal_type, ISCSI_FLASHNODE_PORTAL_TYPE); 827 iscsi_flashnode_sess_attr(fnode, entry_enable, ISCSI_FLASHNODE_ENTRY_EN); 828 iscsi_flashnode_sess_attr(fnode, immediate_data, ISCSI_FLASHNODE_IMM_DATA_EN); 829 iscsi_flashnode_sess_attr(fnode, initial_r2t, ISCSI_FLASHNODE_INITIAL_R2T_EN); 830 iscsi_flashnode_sess_attr(fnode, data_seq_in_order, 831 ISCSI_FLASHNODE_DATASEQ_INORDER); 832 iscsi_flashnode_sess_attr(fnode, data_pdu_in_order, 833 ISCSI_FLASHNODE_PDU_INORDER); 834 iscsi_flashnode_sess_attr(fnode, chap_auth, ISCSI_FLASHNODE_CHAP_AUTH_EN); 835 iscsi_flashnode_sess_attr(fnode, discovery_logout, 836 ISCSI_FLASHNODE_DISCOVERY_LOGOUT_EN); 837 iscsi_flashnode_sess_attr(fnode, bidi_chap, ISCSI_FLASHNODE_BIDI_CHAP_EN); 838 iscsi_flashnode_sess_attr(fnode, discovery_auth_optional, 839 ISCSI_FLASHNODE_DISCOVERY_AUTH_OPTIONAL); 840 iscsi_flashnode_sess_attr(fnode, erl, ISCSI_FLASHNODE_ERL); 841 iscsi_flashnode_sess_attr(fnode, first_burst_len, ISCSI_FLASHNODE_FIRST_BURST); 842 iscsi_flashnode_sess_attr(fnode, def_time2wait, ISCSI_FLASHNODE_DEF_TIME2WAIT); 843 iscsi_flashnode_sess_attr(fnode, def_time2retain, 844 ISCSI_FLASHNODE_DEF_TIME2RETAIN); 845 iscsi_flashnode_sess_attr(fnode, max_outstanding_r2t, ISCSI_FLASHNODE_MAX_R2T); 846 iscsi_flashnode_sess_attr(fnode, isid, ISCSI_FLASHNODE_ISID); 847 iscsi_flashnode_sess_attr(fnode, tsid, ISCSI_FLASHNODE_TSID); 848 iscsi_flashnode_sess_attr(fnode, max_burst_len, ISCSI_FLASHNODE_MAX_BURST); 849 iscsi_flashnode_sess_attr(fnode, def_taskmgmt_tmo, 850 ISCSI_FLASHNODE_DEF_TASKMGMT_TMO); 851 iscsi_flashnode_sess_attr(fnode, targetalias, ISCSI_FLASHNODE_ALIAS); 852 iscsi_flashnode_sess_attr(fnode, targetname, ISCSI_FLASHNODE_NAME); 853 iscsi_flashnode_sess_attr(fnode, tpgt, ISCSI_FLASHNODE_TPGT); 854 iscsi_flashnode_sess_attr(fnode, discovery_parent_idx, 855 ISCSI_FLASHNODE_DISCOVERY_PARENT_IDX); 856 iscsi_flashnode_sess_attr(fnode, discovery_parent_type, 857 ISCSI_FLASHNODE_DISCOVERY_PARENT_TYPE); 858 iscsi_flashnode_sess_attr(fnode, chap_in_idx, ISCSI_FLASHNODE_CHAP_IN_IDX); 859 iscsi_flashnode_sess_attr(fnode, chap_out_idx, ISCSI_FLASHNODE_CHAP_OUT_IDX); 860 iscsi_flashnode_sess_attr(fnode, username, ISCSI_FLASHNODE_USERNAME); 861 iscsi_flashnode_sess_attr(fnode, username_in, ISCSI_FLASHNODE_USERNAME_IN); 862 iscsi_flashnode_sess_attr(fnode, password, ISCSI_FLASHNODE_PASSWORD); 863 iscsi_flashnode_sess_attr(fnode, password_in, ISCSI_FLASHNODE_PASSWORD_IN); 864 iscsi_flashnode_sess_attr(fnode, is_boot_target, ISCSI_FLASHNODE_IS_BOOT_TGT); 865 866 static struct attribute *iscsi_flashnode_sess_attrs[] = { 867 &dev_attr_fnode_auto_snd_tgt_disable.attr, 868 &dev_attr_fnode_discovery_session.attr, 869 &dev_attr_fnode_portal_type.attr, 870 &dev_attr_fnode_entry_enable.attr, 871 &dev_attr_fnode_immediate_data.attr, 872 &dev_attr_fnode_initial_r2t.attr, 873 &dev_attr_fnode_data_seq_in_order.attr, 874 &dev_attr_fnode_data_pdu_in_order.attr, 875 &dev_attr_fnode_chap_auth.attr, 876 &dev_attr_fnode_discovery_logout.attr, 877 &dev_attr_fnode_bidi_chap.attr, 878 &dev_attr_fnode_discovery_auth_optional.attr, 879 &dev_attr_fnode_erl.attr, 880 &dev_attr_fnode_first_burst_len.attr, 881 &dev_attr_fnode_def_time2wait.attr, 882 &dev_attr_fnode_def_time2retain.attr, 883 &dev_attr_fnode_max_outstanding_r2t.attr, 884 &dev_attr_fnode_isid.attr, 885 &dev_attr_fnode_tsid.attr, 886 &dev_attr_fnode_max_burst_len.attr, 887 &dev_attr_fnode_def_taskmgmt_tmo.attr, 888 &dev_attr_fnode_targetalias.attr, 889 &dev_attr_fnode_targetname.attr, 890 &dev_attr_fnode_tpgt.attr, 891 &dev_attr_fnode_discovery_parent_idx.attr, 892 &dev_attr_fnode_discovery_parent_type.attr, 893 &dev_attr_fnode_chap_in_idx.attr, 894 &dev_attr_fnode_chap_out_idx.attr, 895 &dev_attr_fnode_username.attr, 896 &dev_attr_fnode_username_in.attr, 897 &dev_attr_fnode_password.attr, 898 &dev_attr_fnode_password_in.attr, 899 &dev_attr_fnode_is_boot_target.attr, 900 NULL, 901 }; 902 903 static umode_t iscsi_flashnode_sess_attr_is_visible(struct kobject *kobj, 904 struct attribute *attr, 905 int i) 906 { 907 struct device *dev = container_of(kobj, struct device, kobj); 908 struct iscsi_bus_flash_session *fnode_sess = 909 iscsi_dev_to_flash_session(dev); 910 struct iscsi_transport *t = fnode_sess->transport; 911 int param; 912 913 if (attr == &dev_attr_fnode_auto_snd_tgt_disable.attr) { 914 param = ISCSI_FLASHNODE_AUTO_SND_TGT_DISABLE; 915 } else if (attr == &dev_attr_fnode_discovery_session.attr) { 916 param = ISCSI_FLASHNODE_DISCOVERY_SESS; 917 } else if (attr == &dev_attr_fnode_portal_type.attr) { 918 param = ISCSI_FLASHNODE_PORTAL_TYPE; 919 } else if (attr == &dev_attr_fnode_entry_enable.attr) { 920 param = ISCSI_FLASHNODE_ENTRY_EN; 921 } else if (attr == &dev_attr_fnode_immediate_data.attr) { 922 param = ISCSI_FLASHNODE_IMM_DATA_EN; 923 } else if (attr == &dev_attr_fnode_initial_r2t.attr) { 924 param = ISCSI_FLASHNODE_INITIAL_R2T_EN; 925 } else if (attr == &dev_attr_fnode_data_seq_in_order.attr) { 926 param = ISCSI_FLASHNODE_DATASEQ_INORDER; 927 } else if (attr == &dev_attr_fnode_data_pdu_in_order.attr) { 928 param = ISCSI_FLASHNODE_PDU_INORDER; 929 } else if (attr == &dev_attr_fnode_chap_auth.attr) { 930 param = ISCSI_FLASHNODE_CHAP_AUTH_EN; 931 } else if (attr == &dev_attr_fnode_discovery_logout.attr) { 932 param = ISCSI_FLASHNODE_DISCOVERY_LOGOUT_EN; 933 } else if (attr == &dev_attr_fnode_bidi_chap.attr) { 934 param = ISCSI_FLASHNODE_BIDI_CHAP_EN; 935 } else if (attr == &dev_attr_fnode_discovery_auth_optional.attr) { 936 param = ISCSI_FLASHNODE_DISCOVERY_AUTH_OPTIONAL; 937 } else if (attr == &dev_attr_fnode_erl.attr) { 938 param = ISCSI_FLASHNODE_ERL; 939 } else if (attr == &dev_attr_fnode_first_burst_len.attr) { 940 param = ISCSI_FLASHNODE_FIRST_BURST; 941 } else if (attr == &dev_attr_fnode_def_time2wait.attr) { 942 param = ISCSI_FLASHNODE_DEF_TIME2WAIT; 943 } else if (attr == &dev_attr_fnode_def_time2retain.attr) { 944 param = ISCSI_FLASHNODE_DEF_TIME2RETAIN; 945 } else if (attr == &dev_attr_fnode_max_outstanding_r2t.attr) { 946 param = ISCSI_FLASHNODE_MAX_R2T; 947 } else if (attr == &dev_attr_fnode_isid.attr) { 948 param = ISCSI_FLASHNODE_ISID; 949 } else if (attr == &dev_attr_fnode_tsid.attr) { 950 param = ISCSI_FLASHNODE_TSID; 951 } else if (attr == &dev_attr_fnode_max_burst_len.attr) { 952 param = ISCSI_FLASHNODE_MAX_BURST; 953 } else if (attr == &dev_attr_fnode_def_taskmgmt_tmo.attr) { 954 param = ISCSI_FLASHNODE_DEF_TASKMGMT_TMO; 955 } else if (attr == &dev_attr_fnode_targetalias.attr) { 956 param = ISCSI_FLASHNODE_ALIAS; 957 } else if (attr == &dev_attr_fnode_targetname.attr) { 958 param = ISCSI_FLASHNODE_NAME; 959 } else if (attr == &dev_attr_fnode_tpgt.attr) { 960 param = ISCSI_FLASHNODE_TPGT; 961 } else if (attr == &dev_attr_fnode_discovery_parent_idx.attr) { 962 param = ISCSI_FLASHNODE_DISCOVERY_PARENT_IDX; 963 } else if (attr == &dev_attr_fnode_discovery_parent_type.attr) { 964 param = ISCSI_FLASHNODE_DISCOVERY_PARENT_TYPE; 965 } else if (attr == &dev_attr_fnode_chap_in_idx.attr) { 966 param = ISCSI_FLASHNODE_CHAP_IN_IDX; 967 } else if (attr == &dev_attr_fnode_chap_out_idx.attr) { 968 param = ISCSI_FLASHNODE_CHAP_OUT_IDX; 969 } else if (attr == &dev_attr_fnode_username.attr) { 970 param = ISCSI_FLASHNODE_USERNAME; 971 } else if (attr == &dev_attr_fnode_username_in.attr) { 972 param = ISCSI_FLASHNODE_USERNAME_IN; 973 } else if (attr == &dev_attr_fnode_password.attr) { 974 param = ISCSI_FLASHNODE_PASSWORD; 975 } else if (attr == &dev_attr_fnode_password_in.attr) { 976 param = ISCSI_FLASHNODE_PASSWORD_IN; 977 } else if (attr == &dev_attr_fnode_is_boot_target.attr) { 978 param = ISCSI_FLASHNODE_IS_BOOT_TGT; 979 } else { 980 WARN_ONCE(1, "Invalid flashnode session attr"); 981 return 0; 982 } 983 984 return t->attr_is_visible(ISCSI_FLASHNODE_PARAM, param); 985 } 986 987 static struct attribute_group iscsi_flashnode_sess_attr_group = { 988 .attrs = iscsi_flashnode_sess_attrs, 989 .is_visible = iscsi_flashnode_sess_attr_is_visible, 990 }; 991 992 static const struct attribute_group *iscsi_flashnode_sess_attr_groups[] = { 993 &iscsi_flashnode_sess_attr_group, 994 NULL, 995 }; 996 997 static void iscsi_flashnode_sess_release(struct device *dev) 998 { 999 struct iscsi_bus_flash_session *fnode_sess = 1000 iscsi_dev_to_flash_session(dev); 1001 1002 kfree(fnode_sess->targetname); 1003 kfree(fnode_sess->targetalias); 1004 kfree(fnode_sess->portal_type); 1005 kfree(fnode_sess); 1006 } 1007 1008 static const struct device_type iscsi_flashnode_sess_dev_type = { 1009 .name = "iscsi_flashnode_sess_dev_type", 1010 .groups = iscsi_flashnode_sess_attr_groups, 1011 .release = iscsi_flashnode_sess_release, 1012 }; 1013 1014 /* flash node connection attrs show */ 1015 #define iscsi_flashnode_conn_attr_show(type, name, param) \ 1016 static ssize_t \ 1017 show_##type##_##name(struct device *dev, struct device_attribute *attr, \ 1018 char *buf) \ 1019 { \ 1020 struct iscsi_bus_flash_conn *fnode_conn = iscsi_dev_to_flash_conn(dev);\ 1021 struct iscsi_bus_flash_session *fnode_sess = \ 1022 iscsi_flash_conn_to_flash_session(fnode_conn);\ 1023 struct iscsi_transport *t = fnode_conn->transport; \ 1024 return t->get_flashnode_param(fnode_sess, param, buf); \ 1025 } \ 1026 1027 1028 #define iscsi_flashnode_conn_attr(type, name, param) \ 1029 iscsi_flashnode_conn_attr_show(type, name, param) \ 1030 static ISCSI_FLASHNODE_ATTR(type, name, S_IRUGO, \ 1031 show_##type##_##name, NULL); 1032 1033 /* Flash node connection attributes */ 1034 1035 iscsi_flashnode_conn_attr(fnode, is_fw_assigned_ipv6, 1036 ISCSI_FLASHNODE_IS_FW_ASSIGNED_IPV6); 1037 iscsi_flashnode_conn_attr(fnode, header_digest, ISCSI_FLASHNODE_HDR_DGST_EN); 1038 iscsi_flashnode_conn_attr(fnode, data_digest, ISCSI_FLASHNODE_DATA_DGST_EN); 1039 iscsi_flashnode_conn_attr(fnode, snack_req, ISCSI_FLASHNODE_SNACK_REQ_EN); 1040 iscsi_flashnode_conn_attr(fnode, tcp_timestamp_stat, 1041 ISCSI_FLASHNODE_TCP_TIMESTAMP_STAT); 1042 iscsi_flashnode_conn_attr(fnode, tcp_nagle_disable, 1043 ISCSI_FLASHNODE_TCP_NAGLE_DISABLE); 1044 iscsi_flashnode_conn_attr(fnode, tcp_wsf_disable, 1045 ISCSI_FLASHNODE_TCP_WSF_DISABLE); 1046 iscsi_flashnode_conn_attr(fnode, tcp_timer_scale, 1047 ISCSI_FLASHNODE_TCP_TIMER_SCALE); 1048 iscsi_flashnode_conn_attr(fnode, tcp_timestamp_enable, 1049 ISCSI_FLASHNODE_TCP_TIMESTAMP_EN); 1050 iscsi_flashnode_conn_attr(fnode, fragment_disable, 1051 ISCSI_FLASHNODE_IP_FRAG_DISABLE); 1052 iscsi_flashnode_conn_attr(fnode, keepalive_tmo, ISCSI_FLASHNODE_KEEPALIVE_TMO); 1053 iscsi_flashnode_conn_attr(fnode, port, ISCSI_FLASHNODE_PORT); 1054 iscsi_flashnode_conn_attr(fnode, ipaddress, ISCSI_FLASHNODE_IPADDR); 1055 iscsi_flashnode_conn_attr(fnode, max_recv_dlength, 1056 ISCSI_FLASHNODE_MAX_RECV_DLENGTH); 1057 iscsi_flashnode_conn_attr(fnode, max_xmit_dlength, 1058 ISCSI_FLASHNODE_MAX_XMIT_DLENGTH); 1059 iscsi_flashnode_conn_attr(fnode, local_port, ISCSI_FLASHNODE_LOCAL_PORT); 1060 iscsi_flashnode_conn_attr(fnode, ipv4_tos, ISCSI_FLASHNODE_IPV4_TOS); 1061 iscsi_flashnode_conn_attr(fnode, ipv6_traffic_class, ISCSI_FLASHNODE_IPV6_TC); 1062 iscsi_flashnode_conn_attr(fnode, ipv6_flow_label, 1063 ISCSI_FLASHNODE_IPV6_FLOW_LABEL); 1064 iscsi_flashnode_conn_attr(fnode, redirect_ipaddr, 1065 ISCSI_FLASHNODE_REDIRECT_IPADDR); 1066 iscsi_flashnode_conn_attr(fnode, max_segment_size, 1067 ISCSI_FLASHNODE_MAX_SEGMENT_SIZE); 1068 iscsi_flashnode_conn_attr(fnode, link_local_ipv6, 1069 ISCSI_FLASHNODE_LINK_LOCAL_IPV6); 1070 iscsi_flashnode_conn_attr(fnode, tcp_xmit_wsf, ISCSI_FLASHNODE_TCP_XMIT_WSF); 1071 iscsi_flashnode_conn_attr(fnode, tcp_recv_wsf, ISCSI_FLASHNODE_TCP_RECV_WSF); 1072 iscsi_flashnode_conn_attr(fnode, statsn, ISCSI_FLASHNODE_STATSN); 1073 iscsi_flashnode_conn_attr(fnode, exp_statsn, ISCSI_FLASHNODE_EXP_STATSN); 1074 1075 static struct attribute *iscsi_flashnode_conn_attrs[] = { 1076 &dev_attr_fnode_is_fw_assigned_ipv6.attr, 1077 &dev_attr_fnode_header_digest.attr, 1078 &dev_attr_fnode_data_digest.attr, 1079 &dev_attr_fnode_snack_req.attr, 1080 &dev_attr_fnode_tcp_timestamp_stat.attr, 1081 &dev_attr_fnode_tcp_nagle_disable.attr, 1082 &dev_attr_fnode_tcp_wsf_disable.attr, 1083 &dev_attr_fnode_tcp_timer_scale.attr, 1084 &dev_attr_fnode_tcp_timestamp_enable.attr, 1085 &dev_attr_fnode_fragment_disable.attr, 1086 &dev_attr_fnode_max_recv_dlength.attr, 1087 &dev_attr_fnode_max_xmit_dlength.attr, 1088 &dev_attr_fnode_keepalive_tmo.attr, 1089 &dev_attr_fnode_port.attr, 1090 &dev_attr_fnode_ipaddress.attr, 1091 &dev_attr_fnode_redirect_ipaddr.attr, 1092 &dev_attr_fnode_max_segment_size.attr, 1093 &dev_attr_fnode_local_port.attr, 1094 &dev_attr_fnode_ipv4_tos.attr, 1095 &dev_attr_fnode_ipv6_traffic_class.attr, 1096 &dev_attr_fnode_ipv6_flow_label.attr, 1097 &dev_attr_fnode_link_local_ipv6.attr, 1098 &dev_attr_fnode_tcp_xmit_wsf.attr, 1099 &dev_attr_fnode_tcp_recv_wsf.attr, 1100 &dev_attr_fnode_statsn.attr, 1101 &dev_attr_fnode_exp_statsn.attr, 1102 NULL, 1103 }; 1104 1105 static umode_t iscsi_flashnode_conn_attr_is_visible(struct kobject *kobj, 1106 struct attribute *attr, 1107 int i) 1108 { 1109 struct device *dev = container_of(kobj, struct device, kobj); 1110 struct iscsi_bus_flash_conn *fnode_conn = iscsi_dev_to_flash_conn(dev); 1111 struct iscsi_transport *t = fnode_conn->transport; 1112 int param; 1113 1114 if (attr == &dev_attr_fnode_is_fw_assigned_ipv6.attr) { 1115 param = ISCSI_FLASHNODE_IS_FW_ASSIGNED_IPV6; 1116 } else if (attr == &dev_attr_fnode_header_digest.attr) { 1117 param = ISCSI_FLASHNODE_HDR_DGST_EN; 1118 } else if (attr == &dev_attr_fnode_data_digest.attr) { 1119 param = ISCSI_FLASHNODE_DATA_DGST_EN; 1120 } else if (attr == &dev_attr_fnode_snack_req.attr) { 1121 param = ISCSI_FLASHNODE_SNACK_REQ_EN; 1122 } else if (attr == &dev_attr_fnode_tcp_timestamp_stat.attr) { 1123 param = ISCSI_FLASHNODE_TCP_TIMESTAMP_STAT; 1124 } else if (attr == &dev_attr_fnode_tcp_nagle_disable.attr) { 1125 param = ISCSI_FLASHNODE_TCP_NAGLE_DISABLE; 1126 } else if (attr == &dev_attr_fnode_tcp_wsf_disable.attr) { 1127 param = ISCSI_FLASHNODE_TCP_WSF_DISABLE; 1128 } else if (attr == &dev_attr_fnode_tcp_timer_scale.attr) { 1129 param = ISCSI_FLASHNODE_TCP_TIMER_SCALE; 1130 } else if (attr == &dev_attr_fnode_tcp_timestamp_enable.attr) { 1131 param = ISCSI_FLASHNODE_TCP_TIMESTAMP_EN; 1132 } else if (attr == &dev_attr_fnode_fragment_disable.attr) { 1133 param = ISCSI_FLASHNODE_IP_FRAG_DISABLE; 1134 } else if (attr == &dev_attr_fnode_max_recv_dlength.attr) { 1135 param = ISCSI_FLASHNODE_MAX_RECV_DLENGTH; 1136 } else if (attr == &dev_attr_fnode_max_xmit_dlength.attr) { 1137 param = ISCSI_FLASHNODE_MAX_XMIT_DLENGTH; 1138 } else if (attr == &dev_attr_fnode_keepalive_tmo.attr) { 1139 param = ISCSI_FLASHNODE_KEEPALIVE_TMO; 1140 } else if (attr == &dev_attr_fnode_port.attr) { 1141 param = ISCSI_FLASHNODE_PORT; 1142 } else if (attr == &dev_attr_fnode_ipaddress.attr) { 1143 param = ISCSI_FLASHNODE_IPADDR; 1144 } else if (attr == &dev_attr_fnode_redirect_ipaddr.attr) { 1145 param = ISCSI_FLASHNODE_REDIRECT_IPADDR; 1146 } else if (attr == &dev_attr_fnode_max_segment_size.attr) { 1147 param = ISCSI_FLASHNODE_MAX_SEGMENT_SIZE; 1148 } else if (attr == &dev_attr_fnode_local_port.attr) { 1149 param = ISCSI_FLASHNODE_LOCAL_PORT; 1150 } else if (attr == &dev_attr_fnode_ipv4_tos.attr) { 1151 param = ISCSI_FLASHNODE_IPV4_TOS; 1152 } else if (attr == &dev_attr_fnode_ipv6_traffic_class.attr) { 1153 param = ISCSI_FLASHNODE_IPV6_TC; 1154 } else if (attr == &dev_attr_fnode_ipv6_flow_label.attr) { 1155 param = ISCSI_FLASHNODE_IPV6_FLOW_LABEL; 1156 } else if (attr == &dev_attr_fnode_link_local_ipv6.attr) { 1157 param = ISCSI_FLASHNODE_LINK_LOCAL_IPV6; 1158 } else if (attr == &dev_attr_fnode_tcp_xmit_wsf.attr) { 1159 param = ISCSI_FLASHNODE_TCP_XMIT_WSF; 1160 } else if (attr == &dev_attr_fnode_tcp_recv_wsf.attr) { 1161 param = ISCSI_FLASHNODE_TCP_RECV_WSF; 1162 } else if (attr == &dev_attr_fnode_statsn.attr) { 1163 param = ISCSI_FLASHNODE_STATSN; 1164 } else if (attr == &dev_attr_fnode_exp_statsn.attr) { 1165 param = ISCSI_FLASHNODE_EXP_STATSN; 1166 } else { 1167 WARN_ONCE(1, "Invalid flashnode connection attr"); 1168 return 0; 1169 } 1170 1171 return t->attr_is_visible(ISCSI_FLASHNODE_PARAM, param); 1172 } 1173 1174 static struct attribute_group iscsi_flashnode_conn_attr_group = { 1175 .attrs = iscsi_flashnode_conn_attrs, 1176 .is_visible = iscsi_flashnode_conn_attr_is_visible, 1177 }; 1178 1179 static const struct attribute_group *iscsi_flashnode_conn_attr_groups[] = { 1180 &iscsi_flashnode_conn_attr_group, 1181 NULL, 1182 }; 1183 1184 static void iscsi_flashnode_conn_release(struct device *dev) 1185 { 1186 struct iscsi_bus_flash_conn *fnode_conn = iscsi_dev_to_flash_conn(dev); 1187 1188 kfree(fnode_conn->ipaddress); 1189 kfree(fnode_conn->redirect_ipaddr); 1190 kfree(fnode_conn->link_local_ipv6_addr); 1191 kfree(fnode_conn); 1192 } 1193 1194 static const struct device_type iscsi_flashnode_conn_dev_type = { 1195 .name = "iscsi_flashnode_conn_dev_type", 1196 .groups = iscsi_flashnode_conn_attr_groups, 1197 .release = iscsi_flashnode_conn_release, 1198 }; 1199 1200 static struct bus_type iscsi_flashnode_bus; 1201 1202 int iscsi_flashnode_bus_match(struct device *dev, 1203 struct device_driver *drv) 1204 { 1205 if (dev->bus == &iscsi_flashnode_bus) 1206 return 1; 1207 return 0; 1208 } 1209 EXPORT_SYMBOL_GPL(iscsi_flashnode_bus_match); 1210 1211 static struct bus_type iscsi_flashnode_bus = { 1212 .name = "iscsi_flashnode", 1213 .match = &iscsi_flashnode_bus_match, 1214 }; 1215 1216 /** 1217 * iscsi_create_flashnode_sess - Add flashnode session entry in sysfs 1218 * @shost: pointer to host data 1219 * @index: index of flashnode to add in sysfs 1220 * @transport: pointer to transport data 1221 * @dd_size: total size to allocate 1222 * 1223 * Adds a sysfs entry for the flashnode session attributes 1224 * 1225 * Returns: 1226 * pointer to allocated flashnode sess on success 1227 * %NULL on failure 1228 */ 1229 struct iscsi_bus_flash_session * 1230 iscsi_create_flashnode_sess(struct Scsi_Host *shost, int index, 1231 struct iscsi_transport *transport, 1232 int dd_size) 1233 { 1234 struct iscsi_bus_flash_session *fnode_sess; 1235 int err; 1236 1237 fnode_sess = kzalloc(sizeof(*fnode_sess) + dd_size, GFP_KERNEL); 1238 if (!fnode_sess) 1239 return NULL; 1240 1241 fnode_sess->transport = transport; 1242 fnode_sess->target_id = index; 1243 fnode_sess->dev.type = &iscsi_flashnode_sess_dev_type; 1244 fnode_sess->dev.bus = &iscsi_flashnode_bus; 1245 fnode_sess->dev.parent = &shost->shost_gendev; 1246 dev_set_name(&fnode_sess->dev, "flashnode_sess-%u:%u", 1247 shost->host_no, index); 1248 1249 err = device_register(&fnode_sess->dev); 1250 if (err) 1251 goto free_fnode_sess; 1252 1253 if (dd_size) 1254 fnode_sess->dd_data = &fnode_sess[1]; 1255 1256 return fnode_sess; 1257 1258 free_fnode_sess: 1259 kfree(fnode_sess); 1260 return NULL; 1261 } 1262 EXPORT_SYMBOL_GPL(iscsi_create_flashnode_sess); 1263 1264 /** 1265 * iscsi_create_flashnode_conn - Add flashnode conn entry in sysfs 1266 * @shost: pointer to host data 1267 * @fnode_sess: pointer to the parent flashnode session entry 1268 * @transport: pointer to transport data 1269 * @dd_size: total size to allocate 1270 * 1271 * Adds a sysfs entry for the flashnode connection attributes 1272 * 1273 * Returns: 1274 * pointer to allocated flashnode conn on success 1275 * %NULL on failure 1276 */ 1277 struct iscsi_bus_flash_conn * 1278 iscsi_create_flashnode_conn(struct Scsi_Host *shost, 1279 struct iscsi_bus_flash_session *fnode_sess, 1280 struct iscsi_transport *transport, 1281 int dd_size) 1282 { 1283 struct iscsi_bus_flash_conn *fnode_conn; 1284 int err; 1285 1286 fnode_conn = kzalloc(sizeof(*fnode_conn) + dd_size, GFP_KERNEL); 1287 if (!fnode_conn) 1288 return NULL; 1289 1290 fnode_conn->transport = transport; 1291 fnode_conn->dev.type = &iscsi_flashnode_conn_dev_type; 1292 fnode_conn->dev.bus = &iscsi_flashnode_bus; 1293 fnode_conn->dev.parent = &fnode_sess->dev; 1294 dev_set_name(&fnode_conn->dev, "flashnode_conn-%u:%u:0", 1295 shost->host_no, fnode_sess->target_id); 1296 1297 err = device_register(&fnode_conn->dev); 1298 if (err) 1299 goto free_fnode_conn; 1300 1301 if (dd_size) 1302 fnode_conn->dd_data = &fnode_conn[1]; 1303 1304 return fnode_conn; 1305 1306 free_fnode_conn: 1307 kfree(fnode_conn); 1308 return NULL; 1309 } 1310 EXPORT_SYMBOL_GPL(iscsi_create_flashnode_conn); 1311 1312 /** 1313 * iscsi_is_flashnode_conn_dev - verify passed device is to be flashnode conn 1314 * @dev: device to verify 1315 * @data: pointer to data containing value to use for verification 1316 * 1317 * Verifies if the passed device is flashnode conn device 1318 * 1319 * Returns: 1320 * 1 on success 1321 * 0 on failure 1322 */ 1323 static int iscsi_is_flashnode_conn_dev(struct device *dev, void *data) 1324 { 1325 return dev->bus == &iscsi_flashnode_bus; 1326 } 1327 1328 static int iscsi_destroy_flashnode_conn(struct iscsi_bus_flash_conn *fnode_conn) 1329 { 1330 device_unregister(&fnode_conn->dev); 1331 return 0; 1332 } 1333 1334 static int flashnode_match_index(struct device *dev, void *data) 1335 { 1336 struct iscsi_bus_flash_session *fnode_sess = NULL; 1337 int ret = 0; 1338 1339 if (!iscsi_flashnode_bus_match(dev, NULL)) 1340 goto exit_match_index; 1341 1342 fnode_sess = iscsi_dev_to_flash_session(dev); 1343 ret = (fnode_sess->target_id == *((int *)data)) ? 1 : 0; 1344 1345 exit_match_index: 1346 return ret; 1347 } 1348 1349 /** 1350 * iscsi_get_flashnode_by_index -finds flashnode session entry by index 1351 * @shost: pointer to host data 1352 * @idx: index to match 1353 * 1354 * Finds the flashnode session object for the passed index 1355 * 1356 * Returns: 1357 * pointer to found flashnode session object on success 1358 * %NULL on failure 1359 */ 1360 static struct iscsi_bus_flash_session * 1361 iscsi_get_flashnode_by_index(struct Scsi_Host *shost, uint32_t idx) 1362 { 1363 struct iscsi_bus_flash_session *fnode_sess = NULL; 1364 struct device *dev; 1365 1366 dev = device_find_child(&shost->shost_gendev, &idx, 1367 flashnode_match_index); 1368 if (dev) 1369 fnode_sess = iscsi_dev_to_flash_session(dev); 1370 1371 return fnode_sess; 1372 } 1373 1374 /** 1375 * iscsi_find_flashnode_sess - finds flashnode session entry 1376 * @shost: pointer to host data 1377 * @data: pointer to data containing value to use for comparison 1378 * @fn: function pointer that does actual comparison 1379 * 1380 * Finds the flashnode session object comparing the data passed using logic 1381 * defined in passed function pointer 1382 * 1383 * Returns: 1384 * pointer to found flashnode session device object on success 1385 * %NULL on failure 1386 */ 1387 struct device * 1388 iscsi_find_flashnode_sess(struct Scsi_Host *shost, void *data, 1389 int (*fn)(struct device *dev, void *data)) 1390 { 1391 return device_find_child(&shost->shost_gendev, data, fn); 1392 } 1393 EXPORT_SYMBOL_GPL(iscsi_find_flashnode_sess); 1394 1395 /** 1396 * iscsi_find_flashnode_conn - finds flashnode connection entry 1397 * @fnode_sess: pointer to parent flashnode session entry 1398 * 1399 * Finds the flashnode connection object comparing the data passed using logic 1400 * defined in passed function pointer 1401 * 1402 * Returns: 1403 * pointer to found flashnode connection device object on success 1404 * %NULL on failure 1405 */ 1406 struct device * 1407 iscsi_find_flashnode_conn(struct iscsi_bus_flash_session *fnode_sess) 1408 { 1409 return device_find_child(&fnode_sess->dev, NULL, 1410 iscsi_is_flashnode_conn_dev); 1411 } 1412 EXPORT_SYMBOL_GPL(iscsi_find_flashnode_conn); 1413 1414 static int iscsi_iter_destroy_flashnode_conn_fn(struct device *dev, void *data) 1415 { 1416 if (!iscsi_is_flashnode_conn_dev(dev, NULL)) 1417 return 0; 1418 1419 return iscsi_destroy_flashnode_conn(iscsi_dev_to_flash_conn(dev)); 1420 } 1421 1422 /** 1423 * iscsi_destroy_flashnode_sess - destroy flashnode session entry 1424 * @fnode_sess: pointer to flashnode session entry to be destroyed 1425 * 1426 * Deletes the flashnode session entry and all children flashnode connection 1427 * entries from sysfs 1428 */ 1429 void iscsi_destroy_flashnode_sess(struct iscsi_bus_flash_session *fnode_sess) 1430 { 1431 int err; 1432 1433 err = device_for_each_child(&fnode_sess->dev, NULL, 1434 iscsi_iter_destroy_flashnode_conn_fn); 1435 if (err) 1436 pr_err("Could not delete all connections for %s. Error %d.\n", 1437 fnode_sess->dev.kobj.name, err); 1438 1439 device_unregister(&fnode_sess->dev); 1440 } 1441 EXPORT_SYMBOL_GPL(iscsi_destroy_flashnode_sess); 1442 1443 static int iscsi_iter_destroy_flashnode_fn(struct device *dev, void *data) 1444 { 1445 if (!iscsi_flashnode_bus_match(dev, NULL)) 1446 return 0; 1447 1448 iscsi_destroy_flashnode_sess(iscsi_dev_to_flash_session(dev)); 1449 return 0; 1450 } 1451 1452 /** 1453 * iscsi_destroy_all_flashnode - destroy all flashnode session entries 1454 * @shost: pointer to host data 1455 * 1456 * Destroys all the flashnode session entries and all corresponding children 1457 * flashnode connection entries from sysfs 1458 */ 1459 void iscsi_destroy_all_flashnode(struct Scsi_Host *shost) 1460 { 1461 device_for_each_child(&shost->shost_gendev, NULL, 1462 iscsi_iter_destroy_flashnode_fn); 1463 } 1464 EXPORT_SYMBOL_GPL(iscsi_destroy_all_flashnode); 1465 1466 /* 1467 * BSG support 1468 */ 1469 /** 1470 * iscsi_bsg_host_dispatch - Dispatch command to LLD. 1471 * @job: bsg job to be processed 1472 */ 1473 static int iscsi_bsg_host_dispatch(struct bsg_job *job) 1474 { 1475 struct Scsi_Host *shost = iscsi_job_to_shost(job); 1476 struct iscsi_bsg_request *req = job->request; 1477 struct iscsi_bsg_reply *reply = job->reply; 1478 struct iscsi_internal *i = to_iscsi_internal(shost->transportt); 1479 int cmdlen = sizeof(uint32_t); /* start with length of msgcode */ 1480 int ret; 1481 1482 /* check if we have the msgcode value at least */ 1483 if (job->request_len < sizeof(uint32_t)) { 1484 ret = -ENOMSG; 1485 goto fail_host_msg; 1486 } 1487 1488 /* Validate the host command */ 1489 switch (req->msgcode) { 1490 case ISCSI_BSG_HST_VENDOR: 1491 cmdlen += sizeof(struct iscsi_bsg_host_vendor); 1492 if ((shost->hostt->vendor_id == 0L) || 1493 (req->rqst_data.h_vendor.vendor_id != 1494 shost->hostt->vendor_id)) { 1495 ret = -ESRCH; 1496 goto fail_host_msg; 1497 } 1498 break; 1499 default: 1500 ret = -EBADR; 1501 goto fail_host_msg; 1502 } 1503 1504 /* check if we really have all the request data needed */ 1505 if (job->request_len < cmdlen) { 1506 ret = -ENOMSG; 1507 goto fail_host_msg; 1508 } 1509 1510 ret = i->iscsi_transport->bsg_request(job); 1511 if (!ret) 1512 return 0; 1513 1514 fail_host_msg: 1515 /* return the errno failure code as the only status */ 1516 BUG_ON(job->reply_len < sizeof(uint32_t)); 1517 reply->reply_payload_rcv_len = 0; 1518 reply->result = ret; 1519 job->reply_len = sizeof(uint32_t); 1520 bsg_job_done(job, ret, 0); 1521 return 0; 1522 } 1523 1524 /** 1525 * iscsi_bsg_host_add - Create and add the bsg hooks to receive requests 1526 * @shost: shost for iscsi_host 1527 * @ihost: iscsi_cls_host adding the structures to 1528 */ 1529 static int 1530 iscsi_bsg_host_add(struct Scsi_Host *shost, struct iscsi_cls_host *ihost) 1531 { 1532 struct device *dev = &shost->shost_gendev; 1533 struct iscsi_internal *i = to_iscsi_internal(shost->transportt); 1534 struct request_queue *q; 1535 char bsg_name[20]; 1536 1537 if (!i->iscsi_transport->bsg_request) 1538 return -ENOTSUPP; 1539 1540 snprintf(bsg_name, sizeof(bsg_name), "iscsi_host%d", shost->host_no); 1541 q = bsg_setup_queue(dev, bsg_name, iscsi_bsg_host_dispatch, NULL, 0); 1542 if (IS_ERR(q)) { 1543 shost_printk(KERN_ERR, shost, "bsg interface failed to " 1544 "initialize - no request queue\n"); 1545 return PTR_ERR(q); 1546 } 1547 __scsi_init_queue(shost, q); 1548 1549 ihost->bsg_q = q; 1550 return 0; 1551 } 1552 1553 static int iscsi_setup_host(struct transport_container *tc, struct device *dev, 1554 struct device *cdev) 1555 { 1556 struct Scsi_Host *shost = dev_to_shost(dev); 1557 struct iscsi_cls_host *ihost = shost->shost_data; 1558 1559 memset(ihost, 0, sizeof(*ihost)); 1560 atomic_set(&ihost->nr_scans, 0); 1561 mutex_init(&ihost->mutex); 1562 1563 iscsi_bsg_host_add(shost, ihost); 1564 /* ignore any bsg add error - we just can't do sgio */ 1565 1566 return 0; 1567 } 1568 1569 static int iscsi_remove_host(struct transport_container *tc, 1570 struct device *dev, struct device *cdev) 1571 { 1572 struct Scsi_Host *shost = dev_to_shost(dev); 1573 struct iscsi_cls_host *ihost = shost->shost_data; 1574 1575 bsg_remove_queue(ihost->bsg_q); 1576 return 0; 1577 } 1578 1579 static DECLARE_TRANSPORT_CLASS(iscsi_host_class, 1580 "iscsi_host", 1581 iscsi_setup_host, 1582 iscsi_remove_host, 1583 NULL); 1584 1585 static DECLARE_TRANSPORT_CLASS(iscsi_session_class, 1586 "iscsi_session", 1587 NULL, 1588 NULL, 1589 NULL); 1590 1591 static DECLARE_TRANSPORT_CLASS(iscsi_connection_class, 1592 "iscsi_connection", 1593 NULL, 1594 NULL, 1595 NULL); 1596 1597 static struct sock *nls; 1598 static DEFINE_MUTEX(rx_queue_mutex); 1599 1600 static LIST_HEAD(sesslist); 1601 static DEFINE_SPINLOCK(sesslock); 1602 static LIST_HEAD(connlist); 1603 static LIST_HEAD(connlist_err); 1604 static DEFINE_SPINLOCK(connlock); 1605 1606 static uint32_t iscsi_conn_get_sid(struct iscsi_cls_conn *conn) 1607 { 1608 struct iscsi_cls_session *sess = iscsi_dev_to_session(conn->dev.parent); 1609 return sess->sid; 1610 } 1611 1612 /* 1613 * Returns the matching session to a given sid 1614 */ 1615 static struct iscsi_cls_session *iscsi_session_lookup(uint32_t sid) 1616 { 1617 unsigned long flags; 1618 struct iscsi_cls_session *sess; 1619 1620 spin_lock_irqsave(&sesslock, flags); 1621 list_for_each_entry(sess, &sesslist, sess_list) { 1622 if (sess->sid == sid) { 1623 spin_unlock_irqrestore(&sesslock, flags); 1624 return sess; 1625 } 1626 } 1627 spin_unlock_irqrestore(&sesslock, flags); 1628 return NULL; 1629 } 1630 1631 /* 1632 * Returns the matching connection to a given sid / cid tuple 1633 */ 1634 static struct iscsi_cls_conn *iscsi_conn_lookup(uint32_t sid, uint32_t cid) 1635 { 1636 unsigned long flags; 1637 struct iscsi_cls_conn *conn; 1638 1639 spin_lock_irqsave(&connlock, flags); 1640 list_for_each_entry(conn, &connlist, conn_list) { 1641 if ((conn->cid == cid) && (iscsi_conn_get_sid(conn) == sid)) { 1642 spin_unlock_irqrestore(&connlock, flags); 1643 return conn; 1644 } 1645 } 1646 spin_unlock_irqrestore(&connlock, flags); 1647 return NULL; 1648 } 1649 1650 /* 1651 * The following functions can be used by LLDs that allocate 1652 * their own scsi_hosts or by software iscsi LLDs 1653 */ 1654 static struct { 1655 int value; 1656 char *name; 1657 } iscsi_session_state_names[] = { 1658 { ISCSI_SESSION_LOGGED_IN, "LOGGED_IN" }, 1659 { ISCSI_SESSION_FAILED, "FAILED" }, 1660 { ISCSI_SESSION_FREE, "FREE" }, 1661 }; 1662 1663 static const char *iscsi_session_state_name(int state) 1664 { 1665 int i; 1666 char *name = NULL; 1667 1668 for (i = 0; i < ARRAY_SIZE(iscsi_session_state_names); i++) { 1669 if (iscsi_session_state_names[i].value == state) { 1670 name = iscsi_session_state_names[i].name; 1671 break; 1672 } 1673 } 1674 return name; 1675 } 1676 1677 int iscsi_session_chkready(struct iscsi_cls_session *session) 1678 { 1679 int err; 1680 1681 switch (session->state) { 1682 case ISCSI_SESSION_LOGGED_IN: 1683 err = 0; 1684 break; 1685 case ISCSI_SESSION_FAILED: 1686 err = DID_IMM_RETRY << 16; 1687 break; 1688 case ISCSI_SESSION_FREE: 1689 err = DID_TRANSPORT_FAILFAST << 16; 1690 break; 1691 default: 1692 err = DID_NO_CONNECT << 16; 1693 break; 1694 } 1695 return err; 1696 } 1697 EXPORT_SYMBOL_GPL(iscsi_session_chkready); 1698 1699 int iscsi_is_session_online(struct iscsi_cls_session *session) 1700 { 1701 unsigned long flags; 1702 int ret = 0; 1703 1704 spin_lock_irqsave(&session->lock, flags); 1705 if (session->state == ISCSI_SESSION_LOGGED_IN) 1706 ret = 1; 1707 spin_unlock_irqrestore(&session->lock, flags); 1708 return ret; 1709 } 1710 EXPORT_SYMBOL_GPL(iscsi_is_session_online); 1711 1712 static void iscsi_session_release(struct device *dev) 1713 { 1714 struct iscsi_cls_session *session = iscsi_dev_to_session(dev); 1715 struct Scsi_Host *shost; 1716 1717 shost = iscsi_session_to_shost(session); 1718 scsi_host_put(shost); 1719 ISCSI_DBG_TRANS_SESSION(session, "Completing session release\n"); 1720 kfree(session); 1721 } 1722 1723 int iscsi_is_session_dev(const struct device *dev) 1724 { 1725 return dev->release == iscsi_session_release; 1726 } 1727 EXPORT_SYMBOL_GPL(iscsi_is_session_dev); 1728 1729 static int iscsi_iter_session_fn(struct device *dev, void *data) 1730 { 1731 void (* fn) (struct iscsi_cls_session *) = data; 1732 1733 if (!iscsi_is_session_dev(dev)) 1734 return 0; 1735 fn(iscsi_dev_to_session(dev)); 1736 return 0; 1737 } 1738 1739 void iscsi_host_for_each_session(struct Scsi_Host *shost, 1740 void (*fn)(struct iscsi_cls_session *)) 1741 { 1742 device_for_each_child(&shost->shost_gendev, fn, 1743 iscsi_iter_session_fn); 1744 } 1745 EXPORT_SYMBOL_GPL(iscsi_host_for_each_session); 1746 1747 /** 1748 * iscsi_scan_finished - helper to report when running scans are done 1749 * @shost: scsi host 1750 * @time: scan run time 1751 * 1752 * This function can be used by drives like qla4xxx to report to the scsi 1753 * layer when the scans it kicked off at module load time are done. 1754 */ 1755 int iscsi_scan_finished(struct Scsi_Host *shost, unsigned long time) 1756 { 1757 struct iscsi_cls_host *ihost = shost->shost_data; 1758 /* 1759 * qla4xxx will have kicked off some session unblocks before calling 1760 * scsi_scan_host, so just wait for them to complete. 1761 */ 1762 return !atomic_read(&ihost->nr_scans); 1763 } 1764 EXPORT_SYMBOL_GPL(iscsi_scan_finished); 1765 1766 struct iscsi_scan_data { 1767 unsigned int channel; 1768 unsigned int id; 1769 u64 lun; 1770 enum scsi_scan_mode rescan; 1771 }; 1772 1773 static int iscsi_user_scan_session(struct device *dev, void *data) 1774 { 1775 struct iscsi_scan_data *scan_data = data; 1776 struct iscsi_cls_session *session; 1777 struct Scsi_Host *shost; 1778 struct iscsi_cls_host *ihost; 1779 unsigned long flags; 1780 unsigned int id; 1781 1782 if (!iscsi_is_session_dev(dev)) 1783 return 0; 1784 1785 session = iscsi_dev_to_session(dev); 1786 1787 ISCSI_DBG_TRANS_SESSION(session, "Scanning session\n"); 1788 1789 shost = iscsi_session_to_shost(session); 1790 ihost = shost->shost_data; 1791 1792 mutex_lock(&ihost->mutex); 1793 spin_lock_irqsave(&session->lock, flags); 1794 if (session->state != ISCSI_SESSION_LOGGED_IN) { 1795 spin_unlock_irqrestore(&session->lock, flags); 1796 goto user_scan_exit; 1797 } 1798 id = session->target_id; 1799 spin_unlock_irqrestore(&session->lock, flags); 1800 1801 if (id != ISCSI_MAX_TARGET) { 1802 if ((scan_data->channel == SCAN_WILD_CARD || 1803 scan_data->channel == 0) && 1804 (scan_data->id == SCAN_WILD_CARD || 1805 scan_data->id == id)) 1806 scsi_scan_target(&session->dev, 0, id, 1807 scan_data->lun, scan_data->rescan); 1808 } 1809 1810 user_scan_exit: 1811 mutex_unlock(&ihost->mutex); 1812 ISCSI_DBG_TRANS_SESSION(session, "Completed session scan\n"); 1813 return 0; 1814 } 1815 1816 static int iscsi_user_scan(struct Scsi_Host *shost, uint channel, 1817 uint id, u64 lun) 1818 { 1819 struct iscsi_scan_data scan_data; 1820 1821 scan_data.channel = channel; 1822 scan_data.id = id; 1823 scan_data.lun = lun; 1824 scan_data.rescan = SCSI_SCAN_MANUAL; 1825 1826 return device_for_each_child(&shost->shost_gendev, &scan_data, 1827 iscsi_user_scan_session); 1828 } 1829 1830 static void iscsi_scan_session(struct work_struct *work) 1831 { 1832 struct iscsi_cls_session *session = 1833 container_of(work, struct iscsi_cls_session, scan_work); 1834 struct Scsi_Host *shost = iscsi_session_to_shost(session); 1835 struct iscsi_cls_host *ihost = shost->shost_data; 1836 struct iscsi_scan_data scan_data; 1837 1838 scan_data.channel = 0; 1839 scan_data.id = SCAN_WILD_CARD; 1840 scan_data.lun = SCAN_WILD_CARD; 1841 scan_data.rescan = SCSI_SCAN_RESCAN; 1842 1843 iscsi_user_scan_session(&session->dev, &scan_data); 1844 atomic_dec(&ihost->nr_scans); 1845 } 1846 1847 /** 1848 * iscsi_block_scsi_eh - block scsi eh until session state has transistioned 1849 * @cmd: scsi cmd passed to scsi eh handler 1850 * 1851 * If the session is down this function will wait for the recovery 1852 * timer to fire or for the session to be logged back in. If the 1853 * recovery timer fires then FAST_IO_FAIL is returned. The caller 1854 * should pass this error value to the scsi eh. 1855 */ 1856 int iscsi_block_scsi_eh(struct scsi_cmnd *cmd) 1857 { 1858 struct iscsi_cls_session *session = 1859 starget_to_session(scsi_target(cmd->device)); 1860 unsigned long flags; 1861 int ret = 0; 1862 1863 spin_lock_irqsave(&session->lock, flags); 1864 while (session->state != ISCSI_SESSION_LOGGED_IN) { 1865 if (session->state == ISCSI_SESSION_FREE) { 1866 ret = FAST_IO_FAIL; 1867 break; 1868 } 1869 spin_unlock_irqrestore(&session->lock, flags); 1870 msleep(1000); 1871 spin_lock_irqsave(&session->lock, flags); 1872 } 1873 spin_unlock_irqrestore(&session->lock, flags); 1874 return ret; 1875 } 1876 EXPORT_SYMBOL_GPL(iscsi_block_scsi_eh); 1877 1878 static void session_recovery_timedout(struct work_struct *work) 1879 { 1880 struct iscsi_cls_session *session = 1881 container_of(work, struct iscsi_cls_session, 1882 recovery_work.work); 1883 unsigned long flags; 1884 1885 iscsi_cls_session_printk(KERN_INFO, session, 1886 "session recovery timed out after %d secs\n", 1887 session->recovery_tmo); 1888 1889 spin_lock_irqsave(&session->lock, flags); 1890 switch (session->state) { 1891 case ISCSI_SESSION_FAILED: 1892 session->state = ISCSI_SESSION_FREE; 1893 break; 1894 case ISCSI_SESSION_LOGGED_IN: 1895 case ISCSI_SESSION_FREE: 1896 /* we raced with the unblock's flush */ 1897 spin_unlock_irqrestore(&session->lock, flags); 1898 return; 1899 } 1900 spin_unlock_irqrestore(&session->lock, flags); 1901 1902 if (session->transport->session_recovery_timedout) 1903 session->transport->session_recovery_timedout(session); 1904 1905 ISCSI_DBG_TRANS_SESSION(session, "Unblocking SCSI target\n"); 1906 scsi_target_unblock(&session->dev, SDEV_TRANSPORT_OFFLINE); 1907 ISCSI_DBG_TRANS_SESSION(session, "Completed unblocking SCSI target\n"); 1908 } 1909 1910 static void __iscsi_unblock_session(struct work_struct *work) 1911 { 1912 struct iscsi_cls_session *session = 1913 container_of(work, struct iscsi_cls_session, 1914 unblock_work); 1915 struct Scsi_Host *shost = iscsi_session_to_shost(session); 1916 struct iscsi_cls_host *ihost = shost->shost_data; 1917 unsigned long flags; 1918 1919 ISCSI_DBG_TRANS_SESSION(session, "Unblocking session\n"); 1920 /* 1921 * The recovery and unblock work get run from the same workqueue, 1922 * so try to cancel it if it was going to run after this unblock. 1923 */ 1924 cancel_delayed_work(&session->recovery_work); 1925 spin_lock_irqsave(&session->lock, flags); 1926 session->state = ISCSI_SESSION_LOGGED_IN; 1927 spin_unlock_irqrestore(&session->lock, flags); 1928 /* start IO */ 1929 scsi_target_unblock(&session->dev, SDEV_RUNNING); 1930 /* 1931 * Only do kernel scanning if the driver is properly hooked into 1932 * the async scanning code (drivers like iscsi_tcp do login and 1933 * scanning from userspace). 1934 */ 1935 if (shost->hostt->scan_finished) { 1936 if (scsi_queue_work(shost, &session->scan_work)) 1937 atomic_inc(&ihost->nr_scans); 1938 } 1939 ISCSI_DBG_TRANS_SESSION(session, "Completed unblocking session\n"); 1940 } 1941 1942 /** 1943 * iscsi_unblock_session - set a session as logged in and start IO. 1944 * @session: iscsi session 1945 * 1946 * Mark a session as ready to accept IO. 1947 */ 1948 void iscsi_unblock_session(struct iscsi_cls_session *session) 1949 { 1950 flush_work(&session->block_work); 1951 1952 queue_work(iscsi_eh_timer_workq, &session->unblock_work); 1953 /* 1954 * Blocking the session can be done from any context so we only 1955 * queue the block work. Make sure the unblock work has completed 1956 * because it flushes/cancels the other works and updates the state. 1957 */ 1958 flush_work(&session->unblock_work); 1959 } 1960 EXPORT_SYMBOL_GPL(iscsi_unblock_session); 1961 1962 static void __iscsi_block_session(struct work_struct *work) 1963 { 1964 struct iscsi_cls_session *session = 1965 container_of(work, struct iscsi_cls_session, 1966 block_work); 1967 unsigned long flags; 1968 1969 ISCSI_DBG_TRANS_SESSION(session, "Blocking session\n"); 1970 spin_lock_irqsave(&session->lock, flags); 1971 session->state = ISCSI_SESSION_FAILED; 1972 spin_unlock_irqrestore(&session->lock, flags); 1973 scsi_target_block(&session->dev); 1974 ISCSI_DBG_TRANS_SESSION(session, "Completed SCSI target blocking\n"); 1975 if (session->recovery_tmo >= 0) 1976 queue_delayed_work(iscsi_eh_timer_workq, 1977 &session->recovery_work, 1978 session->recovery_tmo * HZ); 1979 } 1980 1981 void iscsi_block_session(struct iscsi_cls_session *session) 1982 { 1983 queue_work(iscsi_eh_timer_workq, &session->block_work); 1984 } 1985 EXPORT_SYMBOL_GPL(iscsi_block_session); 1986 1987 static void __iscsi_unbind_session(struct work_struct *work) 1988 { 1989 struct iscsi_cls_session *session = 1990 container_of(work, struct iscsi_cls_session, 1991 unbind_work); 1992 struct Scsi_Host *shost = iscsi_session_to_shost(session); 1993 struct iscsi_cls_host *ihost = shost->shost_data; 1994 unsigned long flags; 1995 unsigned int target_id; 1996 1997 ISCSI_DBG_TRANS_SESSION(session, "Unbinding session\n"); 1998 1999 /* Prevent new scans and make sure scanning is not in progress */ 2000 mutex_lock(&ihost->mutex); 2001 spin_lock_irqsave(&session->lock, flags); 2002 if (session->target_id == ISCSI_MAX_TARGET) { 2003 spin_unlock_irqrestore(&session->lock, flags); 2004 mutex_unlock(&ihost->mutex); 2005 goto unbind_session_exit; 2006 } 2007 2008 target_id = session->target_id; 2009 session->target_id = ISCSI_MAX_TARGET; 2010 spin_unlock_irqrestore(&session->lock, flags); 2011 mutex_unlock(&ihost->mutex); 2012 2013 scsi_remove_target(&session->dev); 2014 2015 if (session->ida_used) 2016 ida_simple_remove(&iscsi_sess_ida, target_id); 2017 2018 unbind_session_exit: 2019 iscsi_session_event(session, ISCSI_KEVENT_UNBIND_SESSION); 2020 ISCSI_DBG_TRANS_SESSION(session, "Completed target removal\n"); 2021 } 2022 2023 static void __iscsi_destroy_session(struct work_struct *work) 2024 { 2025 struct iscsi_cls_session *session = 2026 container_of(work, struct iscsi_cls_session, destroy_work); 2027 2028 session->transport->destroy_session(session); 2029 } 2030 2031 struct iscsi_cls_session * 2032 iscsi_alloc_session(struct Scsi_Host *shost, struct iscsi_transport *transport, 2033 int dd_size) 2034 { 2035 struct iscsi_cls_session *session; 2036 2037 session = kzalloc(sizeof(*session) + dd_size, 2038 GFP_KERNEL); 2039 if (!session) 2040 return NULL; 2041 2042 session->transport = transport; 2043 session->creator = -1; 2044 session->recovery_tmo = 120; 2045 session->recovery_tmo_sysfs_override = false; 2046 session->state = ISCSI_SESSION_FREE; 2047 INIT_DELAYED_WORK(&session->recovery_work, session_recovery_timedout); 2048 INIT_LIST_HEAD(&session->sess_list); 2049 INIT_WORK(&session->unblock_work, __iscsi_unblock_session); 2050 INIT_WORK(&session->block_work, __iscsi_block_session); 2051 INIT_WORK(&session->unbind_work, __iscsi_unbind_session); 2052 INIT_WORK(&session->scan_work, iscsi_scan_session); 2053 INIT_WORK(&session->destroy_work, __iscsi_destroy_session); 2054 spin_lock_init(&session->lock); 2055 2056 /* this is released in the dev's release function */ 2057 scsi_host_get(shost); 2058 session->dev.parent = &shost->shost_gendev; 2059 session->dev.release = iscsi_session_release; 2060 device_initialize(&session->dev); 2061 if (dd_size) 2062 session->dd_data = &session[1]; 2063 2064 ISCSI_DBG_TRANS_SESSION(session, "Completed session allocation\n"); 2065 return session; 2066 } 2067 EXPORT_SYMBOL_GPL(iscsi_alloc_session); 2068 2069 int iscsi_add_session(struct iscsi_cls_session *session, unsigned int target_id) 2070 { 2071 unsigned long flags; 2072 int id = 0; 2073 int err; 2074 2075 session->sid = atomic_add_return(1, &iscsi_session_nr); 2076 2077 if (target_id == ISCSI_MAX_TARGET) { 2078 id = ida_simple_get(&iscsi_sess_ida, 0, 0, GFP_KERNEL); 2079 2080 if (id < 0) { 2081 iscsi_cls_session_printk(KERN_ERR, session, 2082 "Failure in Target ID Allocation\n"); 2083 return id; 2084 } 2085 session->target_id = (unsigned int)id; 2086 session->ida_used = true; 2087 } else 2088 session->target_id = target_id; 2089 2090 dev_set_name(&session->dev, "session%u", session->sid); 2091 err = device_add(&session->dev); 2092 if (err) { 2093 iscsi_cls_session_printk(KERN_ERR, session, 2094 "could not register session's dev\n"); 2095 goto release_ida; 2096 } 2097 err = transport_register_device(&session->dev); 2098 if (err) { 2099 iscsi_cls_session_printk(KERN_ERR, session, 2100 "could not register transport's dev\n"); 2101 goto release_dev; 2102 } 2103 2104 spin_lock_irqsave(&sesslock, flags); 2105 list_add(&session->sess_list, &sesslist); 2106 spin_unlock_irqrestore(&sesslock, flags); 2107 2108 iscsi_session_event(session, ISCSI_KEVENT_CREATE_SESSION); 2109 ISCSI_DBG_TRANS_SESSION(session, "Completed session adding\n"); 2110 return 0; 2111 2112 release_dev: 2113 device_del(&session->dev); 2114 release_ida: 2115 if (session->ida_used) 2116 ida_simple_remove(&iscsi_sess_ida, session->target_id); 2117 2118 return err; 2119 } 2120 EXPORT_SYMBOL_GPL(iscsi_add_session); 2121 2122 /** 2123 * iscsi_create_session - create iscsi class session 2124 * @shost: scsi host 2125 * @transport: iscsi transport 2126 * @dd_size: private driver data size 2127 * @target_id: which target 2128 * 2129 * This can be called from a LLD or iscsi_transport. 2130 */ 2131 struct iscsi_cls_session * 2132 iscsi_create_session(struct Scsi_Host *shost, struct iscsi_transport *transport, 2133 int dd_size, unsigned int target_id) 2134 { 2135 struct iscsi_cls_session *session; 2136 2137 session = iscsi_alloc_session(shost, transport, dd_size); 2138 if (!session) 2139 return NULL; 2140 2141 if (iscsi_add_session(session, target_id)) { 2142 iscsi_free_session(session); 2143 return NULL; 2144 } 2145 return session; 2146 } 2147 EXPORT_SYMBOL_GPL(iscsi_create_session); 2148 2149 static void iscsi_conn_release(struct device *dev) 2150 { 2151 struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev); 2152 struct device *parent = conn->dev.parent; 2153 2154 ISCSI_DBG_TRANS_CONN(conn, "Releasing conn\n"); 2155 kfree(conn); 2156 put_device(parent); 2157 } 2158 2159 static int iscsi_is_conn_dev(const struct device *dev) 2160 { 2161 return dev->release == iscsi_conn_release; 2162 } 2163 2164 static int iscsi_iter_destroy_conn_fn(struct device *dev, void *data) 2165 { 2166 if (!iscsi_is_conn_dev(dev)) 2167 return 0; 2168 return iscsi_destroy_conn(iscsi_dev_to_conn(dev)); 2169 } 2170 2171 void iscsi_remove_session(struct iscsi_cls_session *session) 2172 { 2173 unsigned long flags; 2174 int err; 2175 2176 ISCSI_DBG_TRANS_SESSION(session, "Removing session\n"); 2177 2178 spin_lock_irqsave(&sesslock, flags); 2179 if (!list_empty(&session->sess_list)) 2180 list_del(&session->sess_list); 2181 spin_unlock_irqrestore(&sesslock, flags); 2182 2183 flush_work(&session->block_work); 2184 flush_work(&session->unblock_work); 2185 cancel_delayed_work_sync(&session->recovery_work); 2186 /* 2187 * If we are blocked let commands flow again. The lld or iscsi 2188 * layer should set up the queuecommand to fail commands. 2189 * We assume that LLD will not be calling block/unblock while 2190 * removing the session. 2191 */ 2192 spin_lock_irqsave(&session->lock, flags); 2193 session->state = ISCSI_SESSION_FREE; 2194 spin_unlock_irqrestore(&session->lock, flags); 2195 2196 scsi_target_unblock(&session->dev, SDEV_TRANSPORT_OFFLINE); 2197 /* flush running scans then delete devices */ 2198 flush_work(&session->scan_work); 2199 /* flush running unbind operations */ 2200 flush_work(&session->unbind_work); 2201 __iscsi_unbind_session(&session->unbind_work); 2202 2203 /* hw iscsi may not have removed all connections from session */ 2204 err = device_for_each_child(&session->dev, NULL, 2205 iscsi_iter_destroy_conn_fn); 2206 if (err) 2207 iscsi_cls_session_printk(KERN_ERR, session, 2208 "Could not delete all connections " 2209 "for session. Error %d.\n", err); 2210 2211 transport_unregister_device(&session->dev); 2212 2213 ISCSI_DBG_TRANS_SESSION(session, "Completing session removal\n"); 2214 device_del(&session->dev); 2215 } 2216 EXPORT_SYMBOL_GPL(iscsi_remove_session); 2217 2218 static void iscsi_stop_conn(struct iscsi_cls_conn *conn, int flag) 2219 { 2220 ISCSI_DBG_TRANS_CONN(conn, "Stopping conn.\n"); 2221 2222 switch (flag) { 2223 case STOP_CONN_RECOVER: 2224 conn->state = ISCSI_CONN_FAILED; 2225 break; 2226 case STOP_CONN_TERM: 2227 conn->state = ISCSI_CONN_DOWN; 2228 break; 2229 default: 2230 iscsi_cls_conn_printk(KERN_ERR, conn, "invalid stop flag %d\n", 2231 flag); 2232 return; 2233 } 2234 2235 conn->transport->stop_conn(conn, flag); 2236 ISCSI_DBG_TRANS_CONN(conn, "Stopping conn done.\n"); 2237 } 2238 2239 static int iscsi_if_stop_conn(struct iscsi_transport *transport, 2240 struct iscsi_uevent *ev) 2241 { 2242 int flag = ev->u.stop_conn.flag; 2243 struct iscsi_cls_conn *conn; 2244 2245 conn = iscsi_conn_lookup(ev->u.stop_conn.sid, ev->u.stop_conn.cid); 2246 if (!conn) 2247 return -EINVAL; 2248 2249 ISCSI_DBG_TRANS_CONN(conn, "iscsi if conn stop.\n"); 2250 /* 2251 * If this is a termination we have to call stop_conn with that flag 2252 * so the correct states get set. If we haven't run the work yet try to 2253 * avoid the extra run. 2254 */ 2255 if (flag == STOP_CONN_TERM) { 2256 cancel_work_sync(&conn->cleanup_work); 2257 iscsi_stop_conn(conn, flag); 2258 } else { 2259 /* 2260 * Figure out if it was the kernel or userspace initiating this. 2261 */ 2262 if (!test_and_set_bit(ISCSI_CLS_CONN_BIT_CLEANUP, &conn->flags)) { 2263 iscsi_stop_conn(conn, flag); 2264 } else { 2265 ISCSI_DBG_TRANS_CONN(conn, 2266 "flush kernel conn cleanup.\n"); 2267 flush_work(&conn->cleanup_work); 2268 } 2269 /* 2270 * Only clear for recovery to avoid extra cleanup runs during 2271 * termination. 2272 */ 2273 clear_bit(ISCSI_CLS_CONN_BIT_CLEANUP, &conn->flags); 2274 } 2275 ISCSI_DBG_TRANS_CONN(conn, "iscsi if conn stop done.\n"); 2276 return 0; 2277 } 2278 2279 static void iscsi_ep_disconnect(struct iscsi_cls_conn *conn, bool is_active) 2280 { 2281 struct iscsi_cls_session *session = iscsi_conn_to_session(conn); 2282 struct iscsi_endpoint *ep; 2283 2284 ISCSI_DBG_TRANS_CONN(conn, "disconnect ep.\n"); 2285 conn->state = ISCSI_CONN_FAILED; 2286 2287 if (!conn->ep || !session->transport->ep_disconnect) 2288 return; 2289 2290 ep = conn->ep; 2291 conn->ep = NULL; 2292 2293 session->transport->unbind_conn(conn, is_active); 2294 session->transport->ep_disconnect(ep); 2295 ISCSI_DBG_TRANS_CONN(conn, "disconnect ep done.\n"); 2296 } 2297 2298 static void iscsi_cleanup_conn_work_fn(struct work_struct *work) 2299 { 2300 struct iscsi_cls_conn *conn = container_of(work, struct iscsi_cls_conn, 2301 cleanup_work); 2302 struct iscsi_cls_session *session = iscsi_conn_to_session(conn); 2303 2304 mutex_lock(&conn->ep_mutex); 2305 /* 2306 * If we are not at least bound there is nothing for us to do. Userspace 2307 * will do a ep_disconnect call if offload is used, but will not be 2308 * doing a stop since there is nothing to clean up, so we have to clear 2309 * the cleanup bit here. 2310 */ 2311 if (conn->state != ISCSI_CONN_BOUND && conn->state != ISCSI_CONN_UP) { 2312 ISCSI_DBG_TRANS_CONN(conn, "Got error while conn is already failed. Ignoring.\n"); 2313 clear_bit(ISCSI_CLS_CONN_BIT_CLEANUP, &conn->flags); 2314 mutex_unlock(&conn->ep_mutex); 2315 return; 2316 } 2317 2318 iscsi_ep_disconnect(conn, false); 2319 2320 if (system_state != SYSTEM_RUNNING) { 2321 /* 2322 * If the user has set up for the session to never timeout 2323 * then hang like they wanted. For all other cases fail right 2324 * away since userspace is not going to relogin. 2325 */ 2326 if (session->recovery_tmo > 0) 2327 session->recovery_tmo = 0; 2328 } 2329 2330 iscsi_stop_conn(conn, STOP_CONN_RECOVER); 2331 mutex_unlock(&conn->ep_mutex); 2332 ISCSI_DBG_TRANS_CONN(conn, "cleanup done.\n"); 2333 } 2334 2335 void iscsi_free_session(struct iscsi_cls_session *session) 2336 { 2337 ISCSI_DBG_TRANS_SESSION(session, "Freeing session\n"); 2338 iscsi_session_event(session, ISCSI_KEVENT_DESTROY_SESSION); 2339 put_device(&session->dev); 2340 } 2341 EXPORT_SYMBOL_GPL(iscsi_free_session); 2342 2343 /** 2344 * iscsi_create_conn - create iscsi class connection 2345 * @session: iscsi cls session 2346 * @dd_size: private driver data size 2347 * @cid: connection id 2348 * 2349 * This can be called from a LLD or iscsi_transport. The connection 2350 * is child of the session so cid must be unique for all connections 2351 * on the session. 2352 * 2353 * Since we do not support MCS, cid will normally be zero. In some cases 2354 * for software iscsi we could be trying to preallocate a connection struct 2355 * in which case there could be two connection structs and cid would be 2356 * non-zero. 2357 */ 2358 struct iscsi_cls_conn * 2359 iscsi_create_conn(struct iscsi_cls_session *session, int dd_size, uint32_t cid) 2360 { 2361 struct iscsi_transport *transport = session->transport; 2362 struct iscsi_cls_conn *conn; 2363 unsigned long flags; 2364 int err; 2365 2366 conn = kzalloc(sizeof(*conn) + dd_size, GFP_KERNEL); 2367 if (!conn) 2368 return NULL; 2369 if (dd_size) 2370 conn->dd_data = &conn[1]; 2371 2372 mutex_init(&conn->ep_mutex); 2373 INIT_LIST_HEAD(&conn->conn_list); 2374 INIT_WORK(&conn->cleanup_work, iscsi_cleanup_conn_work_fn); 2375 conn->transport = transport; 2376 conn->cid = cid; 2377 conn->state = ISCSI_CONN_DOWN; 2378 2379 /* this is released in the dev's release function */ 2380 if (!get_device(&session->dev)) 2381 goto free_conn; 2382 2383 dev_set_name(&conn->dev, "connection%d:%u", session->sid, cid); 2384 conn->dev.parent = &session->dev; 2385 conn->dev.release = iscsi_conn_release; 2386 err = device_register(&conn->dev); 2387 if (err) { 2388 iscsi_cls_session_printk(KERN_ERR, session, "could not " 2389 "register connection's dev\n"); 2390 goto release_parent_ref; 2391 } 2392 err = transport_register_device(&conn->dev); 2393 if (err) { 2394 iscsi_cls_session_printk(KERN_ERR, session, "could not " 2395 "register transport's dev\n"); 2396 goto release_conn_ref; 2397 } 2398 2399 spin_lock_irqsave(&connlock, flags); 2400 list_add(&conn->conn_list, &connlist); 2401 spin_unlock_irqrestore(&connlock, flags); 2402 2403 ISCSI_DBG_TRANS_CONN(conn, "Completed conn creation\n"); 2404 return conn; 2405 2406 release_conn_ref: 2407 device_unregister(&conn->dev); 2408 put_device(&session->dev); 2409 return NULL; 2410 release_parent_ref: 2411 put_device(&session->dev); 2412 free_conn: 2413 kfree(conn); 2414 return NULL; 2415 } 2416 2417 EXPORT_SYMBOL_GPL(iscsi_create_conn); 2418 2419 /** 2420 * iscsi_destroy_conn - destroy iscsi class connection 2421 * @conn: iscsi cls session 2422 * 2423 * This can be called from a LLD or iscsi_transport. 2424 */ 2425 int iscsi_destroy_conn(struct iscsi_cls_conn *conn) 2426 { 2427 unsigned long flags; 2428 2429 spin_lock_irqsave(&connlock, flags); 2430 list_del(&conn->conn_list); 2431 spin_unlock_irqrestore(&connlock, flags); 2432 2433 transport_unregister_device(&conn->dev); 2434 ISCSI_DBG_TRANS_CONN(conn, "Completing conn destruction\n"); 2435 device_unregister(&conn->dev); 2436 return 0; 2437 } 2438 EXPORT_SYMBOL_GPL(iscsi_destroy_conn); 2439 2440 void iscsi_put_conn(struct iscsi_cls_conn *conn) 2441 { 2442 put_device(&conn->dev); 2443 } 2444 EXPORT_SYMBOL_GPL(iscsi_put_conn); 2445 2446 void iscsi_get_conn(struct iscsi_cls_conn *conn) 2447 { 2448 get_device(&conn->dev); 2449 } 2450 EXPORT_SYMBOL_GPL(iscsi_get_conn); 2451 2452 /* 2453 * iscsi interface functions 2454 */ 2455 static struct iscsi_internal * 2456 iscsi_if_transport_lookup(struct iscsi_transport *tt) 2457 { 2458 struct iscsi_internal *priv; 2459 unsigned long flags; 2460 2461 spin_lock_irqsave(&iscsi_transport_lock, flags); 2462 list_for_each_entry(priv, &iscsi_transports, list) { 2463 if (tt == priv->iscsi_transport) { 2464 spin_unlock_irqrestore(&iscsi_transport_lock, flags); 2465 return priv; 2466 } 2467 } 2468 spin_unlock_irqrestore(&iscsi_transport_lock, flags); 2469 return NULL; 2470 } 2471 2472 static int 2473 iscsi_multicast_skb(struct sk_buff *skb, uint32_t group, gfp_t gfp) 2474 { 2475 return nlmsg_multicast(nls, skb, 0, group, gfp); 2476 } 2477 2478 static int 2479 iscsi_unicast_skb(struct sk_buff *skb, u32 portid) 2480 { 2481 return nlmsg_unicast(nls, skb, portid); 2482 } 2483 2484 int iscsi_recv_pdu(struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr, 2485 char *data, uint32_t data_size) 2486 { 2487 struct nlmsghdr *nlh; 2488 struct sk_buff *skb; 2489 struct iscsi_uevent *ev; 2490 char *pdu; 2491 struct iscsi_internal *priv; 2492 int len = nlmsg_total_size(sizeof(*ev) + sizeof(struct iscsi_hdr) + 2493 data_size); 2494 2495 priv = iscsi_if_transport_lookup(conn->transport); 2496 if (!priv) 2497 return -EINVAL; 2498 2499 skb = alloc_skb(len, GFP_ATOMIC); 2500 if (!skb) { 2501 iscsi_conn_error_event(conn, ISCSI_ERR_CONN_FAILED); 2502 iscsi_cls_conn_printk(KERN_ERR, conn, "can not deliver " 2503 "control PDU: OOM\n"); 2504 return -ENOMEM; 2505 } 2506 2507 nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0); 2508 ev = nlmsg_data(nlh); 2509 memset(ev, 0, sizeof(*ev)); 2510 ev->transport_handle = iscsi_handle(conn->transport); 2511 ev->type = ISCSI_KEVENT_RECV_PDU; 2512 ev->r.recv_req.cid = conn->cid; 2513 ev->r.recv_req.sid = iscsi_conn_get_sid(conn); 2514 pdu = (char*)ev + sizeof(*ev); 2515 memcpy(pdu, hdr, sizeof(struct iscsi_hdr)); 2516 memcpy(pdu + sizeof(struct iscsi_hdr), data, data_size); 2517 2518 return iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_ATOMIC); 2519 } 2520 EXPORT_SYMBOL_GPL(iscsi_recv_pdu); 2521 2522 int iscsi_offload_mesg(struct Scsi_Host *shost, 2523 struct iscsi_transport *transport, uint32_t type, 2524 char *data, uint16_t data_size) 2525 { 2526 struct nlmsghdr *nlh; 2527 struct sk_buff *skb; 2528 struct iscsi_uevent *ev; 2529 int len = nlmsg_total_size(sizeof(*ev) + data_size); 2530 2531 skb = alloc_skb(len, GFP_ATOMIC); 2532 if (!skb) { 2533 printk(KERN_ERR "can not deliver iscsi offload message:OOM\n"); 2534 return -ENOMEM; 2535 } 2536 2537 nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0); 2538 ev = nlmsg_data(nlh); 2539 memset(ev, 0, sizeof(*ev)); 2540 ev->type = type; 2541 ev->transport_handle = iscsi_handle(transport); 2542 switch (type) { 2543 case ISCSI_KEVENT_PATH_REQ: 2544 ev->r.req_path.host_no = shost->host_no; 2545 break; 2546 case ISCSI_KEVENT_IF_DOWN: 2547 ev->r.notify_if_down.host_no = shost->host_no; 2548 break; 2549 } 2550 2551 memcpy((char *)ev + sizeof(*ev), data, data_size); 2552 2553 return iscsi_multicast_skb(skb, ISCSI_NL_GRP_UIP, GFP_ATOMIC); 2554 } 2555 EXPORT_SYMBOL_GPL(iscsi_offload_mesg); 2556 2557 void iscsi_conn_error_event(struct iscsi_cls_conn *conn, enum iscsi_err error) 2558 { 2559 struct nlmsghdr *nlh; 2560 struct sk_buff *skb; 2561 struct iscsi_uevent *ev; 2562 struct iscsi_internal *priv; 2563 int len = nlmsg_total_size(sizeof(*ev)); 2564 2565 if (!test_and_set_bit(ISCSI_CLS_CONN_BIT_CLEANUP, &conn->flags)) 2566 queue_work(iscsi_conn_cleanup_workq, &conn->cleanup_work); 2567 2568 priv = iscsi_if_transport_lookup(conn->transport); 2569 if (!priv) 2570 return; 2571 2572 skb = alloc_skb(len, GFP_ATOMIC); 2573 if (!skb) { 2574 iscsi_cls_conn_printk(KERN_ERR, conn, "gracefully ignored " 2575 "conn error (%d)\n", error); 2576 return; 2577 } 2578 2579 nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0); 2580 ev = nlmsg_data(nlh); 2581 ev->transport_handle = iscsi_handle(conn->transport); 2582 ev->type = ISCSI_KEVENT_CONN_ERROR; 2583 ev->r.connerror.error = error; 2584 ev->r.connerror.cid = conn->cid; 2585 ev->r.connerror.sid = iscsi_conn_get_sid(conn); 2586 2587 iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_ATOMIC); 2588 2589 iscsi_cls_conn_printk(KERN_INFO, conn, "detected conn error (%d)\n", 2590 error); 2591 } 2592 EXPORT_SYMBOL_GPL(iscsi_conn_error_event); 2593 2594 void iscsi_conn_login_event(struct iscsi_cls_conn *conn, 2595 enum iscsi_conn_state state) 2596 { 2597 struct nlmsghdr *nlh; 2598 struct sk_buff *skb; 2599 struct iscsi_uevent *ev; 2600 struct iscsi_internal *priv; 2601 int len = nlmsg_total_size(sizeof(*ev)); 2602 2603 priv = iscsi_if_transport_lookup(conn->transport); 2604 if (!priv) 2605 return; 2606 2607 skb = alloc_skb(len, GFP_ATOMIC); 2608 if (!skb) { 2609 iscsi_cls_conn_printk(KERN_ERR, conn, "gracefully ignored " 2610 "conn login (%d)\n", state); 2611 return; 2612 } 2613 2614 nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0); 2615 ev = nlmsg_data(nlh); 2616 ev->transport_handle = iscsi_handle(conn->transport); 2617 ev->type = ISCSI_KEVENT_CONN_LOGIN_STATE; 2618 ev->r.conn_login.state = state; 2619 ev->r.conn_login.cid = conn->cid; 2620 ev->r.conn_login.sid = iscsi_conn_get_sid(conn); 2621 iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_ATOMIC); 2622 2623 iscsi_cls_conn_printk(KERN_INFO, conn, "detected conn login (%d)\n", 2624 state); 2625 } 2626 EXPORT_SYMBOL_GPL(iscsi_conn_login_event); 2627 2628 void iscsi_post_host_event(uint32_t host_no, struct iscsi_transport *transport, 2629 enum iscsi_host_event_code code, uint32_t data_size, 2630 uint8_t *data) 2631 { 2632 struct nlmsghdr *nlh; 2633 struct sk_buff *skb; 2634 struct iscsi_uevent *ev; 2635 int len = nlmsg_total_size(sizeof(*ev) + data_size); 2636 2637 skb = alloc_skb(len, GFP_NOIO); 2638 if (!skb) { 2639 printk(KERN_ERR "gracefully ignored host event (%d):%d OOM\n", 2640 host_no, code); 2641 return; 2642 } 2643 2644 nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0); 2645 ev = nlmsg_data(nlh); 2646 ev->transport_handle = iscsi_handle(transport); 2647 ev->type = ISCSI_KEVENT_HOST_EVENT; 2648 ev->r.host_event.host_no = host_no; 2649 ev->r.host_event.code = code; 2650 ev->r.host_event.data_size = data_size; 2651 2652 if (data_size) 2653 memcpy((char *)ev + sizeof(*ev), data, data_size); 2654 2655 iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_NOIO); 2656 } 2657 EXPORT_SYMBOL_GPL(iscsi_post_host_event); 2658 2659 void iscsi_ping_comp_event(uint32_t host_no, struct iscsi_transport *transport, 2660 uint32_t status, uint32_t pid, uint32_t data_size, 2661 uint8_t *data) 2662 { 2663 struct nlmsghdr *nlh; 2664 struct sk_buff *skb; 2665 struct iscsi_uevent *ev; 2666 int len = nlmsg_total_size(sizeof(*ev) + data_size); 2667 2668 skb = alloc_skb(len, GFP_NOIO); 2669 if (!skb) { 2670 printk(KERN_ERR "gracefully ignored ping comp: OOM\n"); 2671 return; 2672 } 2673 2674 nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0); 2675 ev = nlmsg_data(nlh); 2676 ev->transport_handle = iscsi_handle(transport); 2677 ev->type = ISCSI_KEVENT_PING_COMP; 2678 ev->r.ping_comp.host_no = host_no; 2679 ev->r.ping_comp.status = status; 2680 ev->r.ping_comp.pid = pid; 2681 ev->r.ping_comp.data_size = data_size; 2682 memcpy((char *)ev + sizeof(*ev), data, data_size); 2683 2684 iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_NOIO); 2685 } 2686 EXPORT_SYMBOL_GPL(iscsi_ping_comp_event); 2687 2688 static int 2689 iscsi_if_send_reply(u32 portid, int type, void *payload, int size) 2690 { 2691 struct sk_buff *skb; 2692 struct nlmsghdr *nlh; 2693 int len = nlmsg_total_size(size); 2694 2695 skb = alloc_skb(len, GFP_ATOMIC); 2696 if (!skb) { 2697 printk(KERN_ERR "Could not allocate skb to send reply.\n"); 2698 return -ENOMEM; 2699 } 2700 2701 nlh = __nlmsg_put(skb, 0, 0, type, (len - sizeof(*nlh)), 0); 2702 memcpy(nlmsg_data(nlh), payload, size); 2703 return iscsi_unicast_skb(skb, portid); 2704 } 2705 2706 static int 2707 iscsi_if_get_stats(struct iscsi_transport *transport, struct nlmsghdr *nlh) 2708 { 2709 struct iscsi_uevent *ev = nlmsg_data(nlh); 2710 struct iscsi_stats *stats; 2711 struct sk_buff *skbstat; 2712 struct iscsi_cls_conn *conn; 2713 struct nlmsghdr *nlhstat; 2714 struct iscsi_uevent *evstat; 2715 struct iscsi_internal *priv; 2716 int len = nlmsg_total_size(sizeof(*ev) + 2717 sizeof(struct iscsi_stats) + 2718 sizeof(struct iscsi_stats_custom) * 2719 ISCSI_STATS_CUSTOM_MAX); 2720 int err = 0; 2721 2722 priv = iscsi_if_transport_lookup(transport); 2723 if (!priv) 2724 return -EINVAL; 2725 2726 conn = iscsi_conn_lookup(ev->u.get_stats.sid, ev->u.get_stats.cid); 2727 if (!conn) 2728 return -EEXIST; 2729 2730 do { 2731 int actual_size; 2732 2733 skbstat = alloc_skb(len, GFP_ATOMIC); 2734 if (!skbstat) { 2735 iscsi_cls_conn_printk(KERN_ERR, conn, "can not " 2736 "deliver stats: OOM\n"); 2737 return -ENOMEM; 2738 } 2739 2740 nlhstat = __nlmsg_put(skbstat, 0, 0, 0, 2741 (len - sizeof(*nlhstat)), 0); 2742 evstat = nlmsg_data(nlhstat); 2743 memset(evstat, 0, sizeof(*evstat)); 2744 evstat->transport_handle = iscsi_handle(conn->transport); 2745 evstat->type = nlh->nlmsg_type; 2746 evstat->u.get_stats.cid = 2747 ev->u.get_stats.cid; 2748 evstat->u.get_stats.sid = 2749 ev->u.get_stats.sid; 2750 stats = (struct iscsi_stats *) 2751 ((char*)evstat + sizeof(*evstat)); 2752 memset(stats, 0, sizeof(*stats)); 2753 2754 transport->get_stats(conn, stats); 2755 actual_size = nlmsg_total_size(sizeof(struct iscsi_uevent) + 2756 sizeof(struct iscsi_stats) + 2757 sizeof(struct iscsi_stats_custom) * 2758 stats->custom_length); 2759 actual_size -= sizeof(*nlhstat); 2760 actual_size = nlmsg_msg_size(actual_size); 2761 skb_trim(skbstat, NLMSG_ALIGN(actual_size)); 2762 nlhstat->nlmsg_len = actual_size; 2763 2764 err = iscsi_multicast_skb(skbstat, ISCSI_NL_GRP_ISCSID, 2765 GFP_ATOMIC); 2766 } while (err < 0 && err != -ECONNREFUSED); 2767 2768 return err; 2769 } 2770 2771 /** 2772 * iscsi_session_event - send session destr. completion event 2773 * @session: iscsi class session 2774 * @event: type of event 2775 */ 2776 int iscsi_session_event(struct iscsi_cls_session *session, 2777 enum iscsi_uevent_e event) 2778 { 2779 struct iscsi_internal *priv; 2780 struct Scsi_Host *shost; 2781 struct iscsi_uevent *ev; 2782 struct sk_buff *skb; 2783 struct nlmsghdr *nlh; 2784 int rc, len = nlmsg_total_size(sizeof(*ev)); 2785 2786 priv = iscsi_if_transport_lookup(session->transport); 2787 if (!priv) 2788 return -EINVAL; 2789 shost = iscsi_session_to_shost(session); 2790 2791 skb = alloc_skb(len, GFP_KERNEL); 2792 if (!skb) { 2793 iscsi_cls_session_printk(KERN_ERR, session, 2794 "Cannot notify userspace of session " 2795 "event %u\n", event); 2796 return -ENOMEM; 2797 } 2798 2799 nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0); 2800 ev = nlmsg_data(nlh); 2801 ev->transport_handle = iscsi_handle(session->transport); 2802 2803 ev->type = event; 2804 switch (event) { 2805 case ISCSI_KEVENT_DESTROY_SESSION: 2806 ev->r.d_session.host_no = shost->host_no; 2807 ev->r.d_session.sid = session->sid; 2808 break; 2809 case ISCSI_KEVENT_CREATE_SESSION: 2810 ev->r.c_session_ret.host_no = shost->host_no; 2811 ev->r.c_session_ret.sid = session->sid; 2812 break; 2813 case ISCSI_KEVENT_UNBIND_SESSION: 2814 ev->r.unbind_session.host_no = shost->host_no; 2815 ev->r.unbind_session.sid = session->sid; 2816 break; 2817 default: 2818 iscsi_cls_session_printk(KERN_ERR, session, "Invalid event " 2819 "%u.\n", event); 2820 kfree_skb(skb); 2821 return -EINVAL; 2822 } 2823 2824 /* 2825 * this will occur if the daemon is not up, so we just warn 2826 * the user and when the daemon is restarted it will handle it 2827 */ 2828 rc = iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_KERNEL); 2829 if (rc == -ESRCH) 2830 iscsi_cls_session_printk(KERN_ERR, session, 2831 "Cannot notify userspace of session " 2832 "event %u. Check iscsi daemon\n", 2833 event); 2834 2835 ISCSI_DBG_TRANS_SESSION(session, "Completed handling event %d rc %d\n", 2836 event, rc); 2837 return rc; 2838 } 2839 EXPORT_SYMBOL_GPL(iscsi_session_event); 2840 2841 static int 2842 iscsi_if_create_session(struct iscsi_internal *priv, struct iscsi_endpoint *ep, 2843 struct iscsi_uevent *ev, pid_t pid, 2844 uint32_t initial_cmdsn, uint16_t cmds_max, 2845 uint16_t queue_depth) 2846 { 2847 struct iscsi_transport *transport = priv->iscsi_transport; 2848 struct iscsi_cls_session *session; 2849 struct Scsi_Host *shost; 2850 2851 session = transport->create_session(ep, cmds_max, queue_depth, 2852 initial_cmdsn); 2853 if (!session) 2854 return -ENOMEM; 2855 2856 session->creator = pid; 2857 shost = iscsi_session_to_shost(session); 2858 ev->r.c_session_ret.host_no = shost->host_no; 2859 ev->r.c_session_ret.sid = session->sid; 2860 ISCSI_DBG_TRANS_SESSION(session, 2861 "Completed creating transport session\n"); 2862 return 0; 2863 } 2864 2865 static int 2866 iscsi_if_create_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev) 2867 { 2868 struct iscsi_cls_conn *conn; 2869 struct iscsi_cls_session *session; 2870 2871 session = iscsi_session_lookup(ev->u.c_conn.sid); 2872 if (!session) { 2873 printk(KERN_ERR "iscsi: invalid session %d.\n", 2874 ev->u.c_conn.sid); 2875 return -EINVAL; 2876 } 2877 2878 conn = transport->create_conn(session, ev->u.c_conn.cid); 2879 if (!conn) { 2880 iscsi_cls_session_printk(KERN_ERR, session, 2881 "couldn't create a new connection."); 2882 return -ENOMEM; 2883 } 2884 2885 ev->r.c_conn_ret.sid = session->sid; 2886 ev->r.c_conn_ret.cid = conn->cid; 2887 2888 ISCSI_DBG_TRANS_CONN(conn, "Completed creating transport conn\n"); 2889 return 0; 2890 } 2891 2892 static int 2893 iscsi_if_destroy_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev) 2894 { 2895 struct iscsi_cls_conn *conn; 2896 2897 conn = iscsi_conn_lookup(ev->u.d_conn.sid, ev->u.d_conn.cid); 2898 if (!conn) 2899 return -EINVAL; 2900 2901 ISCSI_DBG_TRANS_CONN(conn, "Flushing cleanup during destruction\n"); 2902 flush_work(&conn->cleanup_work); 2903 ISCSI_DBG_TRANS_CONN(conn, "Destroying transport conn\n"); 2904 2905 if (transport->destroy_conn) 2906 transport->destroy_conn(conn); 2907 return 0; 2908 } 2909 2910 static int 2911 iscsi_set_param(struct iscsi_transport *transport, struct iscsi_uevent *ev) 2912 { 2913 char *data = (char*)ev + sizeof(*ev); 2914 struct iscsi_cls_conn *conn; 2915 struct iscsi_cls_session *session; 2916 int err = 0, value = 0; 2917 2918 if (ev->u.set_param.len > PAGE_SIZE) 2919 return -EINVAL; 2920 2921 session = iscsi_session_lookup(ev->u.set_param.sid); 2922 conn = iscsi_conn_lookup(ev->u.set_param.sid, ev->u.set_param.cid); 2923 if (!conn || !session) 2924 return -EINVAL; 2925 2926 switch (ev->u.set_param.param) { 2927 case ISCSI_PARAM_SESS_RECOVERY_TMO: 2928 sscanf(data, "%d", &value); 2929 if (!session->recovery_tmo_sysfs_override) 2930 session->recovery_tmo = value; 2931 break; 2932 default: 2933 err = transport->set_param(conn, ev->u.set_param.param, 2934 data, ev->u.set_param.len); 2935 if ((conn->state == ISCSI_CONN_BOUND) || 2936 (conn->state == ISCSI_CONN_UP)) { 2937 err = transport->set_param(conn, ev->u.set_param.param, 2938 data, ev->u.set_param.len); 2939 } else { 2940 return -ENOTCONN; 2941 } 2942 } 2943 2944 return err; 2945 } 2946 2947 static int iscsi_if_ep_connect(struct iscsi_transport *transport, 2948 struct iscsi_uevent *ev, int msg_type) 2949 { 2950 struct iscsi_endpoint *ep; 2951 struct sockaddr *dst_addr; 2952 struct Scsi_Host *shost = NULL; 2953 int non_blocking, err = 0; 2954 2955 if (!transport->ep_connect) 2956 return -EINVAL; 2957 2958 if (msg_type == ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST) { 2959 shost = scsi_host_lookup(ev->u.ep_connect_through_host.host_no); 2960 if (!shost) { 2961 printk(KERN_ERR "ep connect failed. Could not find " 2962 "host no %u\n", 2963 ev->u.ep_connect_through_host.host_no); 2964 return -ENODEV; 2965 } 2966 non_blocking = ev->u.ep_connect_through_host.non_blocking; 2967 } else 2968 non_blocking = ev->u.ep_connect.non_blocking; 2969 2970 dst_addr = (struct sockaddr *)((char*)ev + sizeof(*ev)); 2971 ep = transport->ep_connect(shost, dst_addr, non_blocking); 2972 if (IS_ERR(ep)) { 2973 err = PTR_ERR(ep); 2974 goto release_host; 2975 } 2976 2977 ev->r.ep_connect_ret.handle = ep->id; 2978 release_host: 2979 if (shost) 2980 scsi_host_put(shost); 2981 return err; 2982 } 2983 2984 static int iscsi_if_ep_disconnect(struct iscsi_transport *transport, 2985 u64 ep_handle) 2986 { 2987 struct iscsi_cls_conn *conn; 2988 struct iscsi_endpoint *ep; 2989 2990 if (!transport->ep_disconnect) 2991 return -EINVAL; 2992 2993 ep = iscsi_lookup_endpoint(ep_handle); 2994 if (!ep) 2995 return -EINVAL; 2996 2997 conn = ep->conn; 2998 if (!conn) { 2999 /* 3000 * conn was not even bound yet, so we can't get iscsi conn 3001 * failures yet. 3002 */ 3003 transport->ep_disconnect(ep); 3004 goto put_ep; 3005 } 3006 3007 mutex_lock(&conn->ep_mutex); 3008 /* Check if this was a conn error and the kernel took ownership */ 3009 if (test_bit(ISCSI_CLS_CONN_BIT_CLEANUP, &conn->flags)) { 3010 ISCSI_DBG_TRANS_CONN(conn, "flush kernel conn cleanup.\n"); 3011 mutex_unlock(&conn->ep_mutex); 3012 3013 flush_work(&conn->cleanup_work); 3014 goto put_ep; 3015 } 3016 3017 iscsi_ep_disconnect(conn, false); 3018 mutex_unlock(&conn->ep_mutex); 3019 put_ep: 3020 iscsi_put_endpoint(ep); 3021 return 0; 3022 } 3023 3024 static int 3025 iscsi_if_transport_ep(struct iscsi_transport *transport, 3026 struct iscsi_uevent *ev, int msg_type) 3027 { 3028 struct iscsi_endpoint *ep; 3029 int rc = 0; 3030 3031 switch (msg_type) { 3032 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST: 3033 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT: 3034 rc = iscsi_if_ep_connect(transport, ev, msg_type); 3035 break; 3036 case ISCSI_UEVENT_TRANSPORT_EP_POLL: 3037 if (!transport->ep_poll) 3038 return -EINVAL; 3039 3040 ep = iscsi_lookup_endpoint(ev->u.ep_poll.ep_handle); 3041 if (!ep) 3042 return -EINVAL; 3043 3044 ev->r.retcode = transport->ep_poll(ep, 3045 ev->u.ep_poll.timeout_ms); 3046 iscsi_put_endpoint(ep); 3047 break; 3048 case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT: 3049 rc = iscsi_if_ep_disconnect(transport, 3050 ev->u.ep_disconnect.ep_handle); 3051 break; 3052 } 3053 return rc; 3054 } 3055 3056 static int 3057 iscsi_tgt_dscvr(struct iscsi_transport *transport, 3058 struct iscsi_uevent *ev) 3059 { 3060 struct Scsi_Host *shost; 3061 struct sockaddr *dst_addr; 3062 int err; 3063 3064 if (!transport->tgt_dscvr) 3065 return -EINVAL; 3066 3067 shost = scsi_host_lookup(ev->u.tgt_dscvr.host_no); 3068 if (!shost) { 3069 printk(KERN_ERR "target discovery could not find host no %u\n", 3070 ev->u.tgt_dscvr.host_no); 3071 return -ENODEV; 3072 } 3073 3074 3075 dst_addr = (struct sockaddr *)((char*)ev + sizeof(*ev)); 3076 err = transport->tgt_dscvr(shost, ev->u.tgt_dscvr.type, 3077 ev->u.tgt_dscvr.enable, dst_addr); 3078 scsi_host_put(shost); 3079 return err; 3080 } 3081 3082 static int 3083 iscsi_set_host_param(struct iscsi_transport *transport, 3084 struct iscsi_uevent *ev) 3085 { 3086 char *data = (char*)ev + sizeof(*ev); 3087 struct Scsi_Host *shost; 3088 int err; 3089 3090 if (!transport->set_host_param) 3091 return -ENOSYS; 3092 3093 if (ev->u.set_host_param.len > PAGE_SIZE) 3094 return -EINVAL; 3095 3096 shost = scsi_host_lookup(ev->u.set_host_param.host_no); 3097 if (!shost) { 3098 printk(KERN_ERR "set_host_param could not find host no %u\n", 3099 ev->u.set_host_param.host_no); 3100 return -ENODEV; 3101 } 3102 3103 err = transport->set_host_param(shost, ev->u.set_host_param.param, 3104 data, ev->u.set_host_param.len); 3105 scsi_host_put(shost); 3106 return err; 3107 } 3108 3109 static int 3110 iscsi_set_path(struct iscsi_transport *transport, struct iscsi_uevent *ev) 3111 { 3112 struct Scsi_Host *shost; 3113 struct iscsi_path *params; 3114 int err; 3115 3116 if (!transport->set_path) 3117 return -ENOSYS; 3118 3119 shost = scsi_host_lookup(ev->u.set_path.host_no); 3120 if (!shost) { 3121 printk(KERN_ERR "set path could not find host no %u\n", 3122 ev->u.set_path.host_no); 3123 return -ENODEV; 3124 } 3125 3126 params = (struct iscsi_path *)((char *)ev + sizeof(*ev)); 3127 err = transport->set_path(shost, params); 3128 3129 scsi_host_put(shost); 3130 return err; 3131 } 3132 3133 static int iscsi_session_has_conns(int sid) 3134 { 3135 struct iscsi_cls_conn *conn; 3136 unsigned long flags; 3137 int found = 0; 3138 3139 spin_lock_irqsave(&connlock, flags); 3140 list_for_each_entry(conn, &connlist, conn_list) { 3141 if (iscsi_conn_get_sid(conn) == sid) { 3142 found = 1; 3143 break; 3144 } 3145 } 3146 spin_unlock_irqrestore(&connlock, flags); 3147 3148 return found; 3149 } 3150 3151 static int 3152 iscsi_set_iface_params(struct iscsi_transport *transport, 3153 struct iscsi_uevent *ev, uint32_t len) 3154 { 3155 char *data = (char *)ev + sizeof(*ev); 3156 struct Scsi_Host *shost; 3157 int err; 3158 3159 if (!transport->set_iface_param) 3160 return -ENOSYS; 3161 3162 shost = scsi_host_lookup(ev->u.set_iface_params.host_no); 3163 if (!shost) { 3164 printk(KERN_ERR "set_iface_params could not find host no %u\n", 3165 ev->u.set_iface_params.host_no); 3166 return -ENODEV; 3167 } 3168 3169 err = transport->set_iface_param(shost, data, len); 3170 scsi_host_put(shost); 3171 return err; 3172 } 3173 3174 static int 3175 iscsi_send_ping(struct iscsi_transport *transport, struct iscsi_uevent *ev) 3176 { 3177 struct Scsi_Host *shost; 3178 struct sockaddr *dst_addr; 3179 int err; 3180 3181 if (!transport->send_ping) 3182 return -ENOSYS; 3183 3184 shost = scsi_host_lookup(ev->u.iscsi_ping.host_no); 3185 if (!shost) { 3186 printk(KERN_ERR "iscsi_ping could not find host no %u\n", 3187 ev->u.iscsi_ping.host_no); 3188 return -ENODEV; 3189 } 3190 3191 dst_addr = (struct sockaddr *)((char *)ev + sizeof(*ev)); 3192 err = transport->send_ping(shost, ev->u.iscsi_ping.iface_num, 3193 ev->u.iscsi_ping.iface_type, 3194 ev->u.iscsi_ping.payload_size, 3195 ev->u.iscsi_ping.pid, 3196 dst_addr); 3197 scsi_host_put(shost); 3198 return err; 3199 } 3200 3201 static int 3202 iscsi_get_chap(struct iscsi_transport *transport, struct nlmsghdr *nlh) 3203 { 3204 struct iscsi_uevent *ev = nlmsg_data(nlh); 3205 struct Scsi_Host *shost = NULL; 3206 struct iscsi_chap_rec *chap_rec; 3207 struct iscsi_internal *priv; 3208 struct sk_buff *skbchap; 3209 struct nlmsghdr *nlhchap; 3210 struct iscsi_uevent *evchap; 3211 uint32_t chap_buf_size; 3212 int len, err = 0; 3213 char *buf; 3214 3215 if (!transport->get_chap) 3216 return -EINVAL; 3217 3218 priv = iscsi_if_transport_lookup(transport); 3219 if (!priv) 3220 return -EINVAL; 3221 3222 chap_buf_size = (ev->u.get_chap.num_entries * sizeof(*chap_rec)); 3223 len = nlmsg_total_size(sizeof(*ev) + chap_buf_size); 3224 3225 shost = scsi_host_lookup(ev->u.get_chap.host_no); 3226 if (!shost) { 3227 printk(KERN_ERR "%s: failed. Could not find host no %u\n", 3228 __func__, ev->u.get_chap.host_no); 3229 return -ENODEV; 3230 } 3231 3232 do { 3233 int actual_size; 3234 3235 skbchap = alloc_skb(len, GFP_KERNEL); 3236 if (!skbchap) { 3237 printk(KERN_ERR "can not deliver chap: OOM\n"); 3238 err = -ENOMEM; 3239 goto exit_get_chap; 3240 } 3241 3242 nlhchap = __nlmsg_put(skbchap, 0, 0, 0, 3243 (len - sizeof(*nlhchap)), 0); 3244 evchap = nlmsg_data(nlhchap); 3245 memset(evchap, 0, sizeof(*evchap)); 3246 evchap->transport_handle = iscsi_handle(transport); 3247 evchap->type = nlh->nlmsg_type; 3248 evchap->u.get_chap.host_no = ev->u.get_chap.host_no; 3249 evchap->u.get_chap.chap_tbl_idx = ev->u.get_chap.chap_tbl_idx; 3250 evchap->u.get_chap.num_entries = ev->u.get_chap.num_entries; 3251 buf = (char *)evchap + sizeof(*evchap); 3252 memset(buf, 0, chap_buf_size); 3253 3254 err = transport->get_chap(shost, ev->u.get_chap.chap_tbl_idx, 3255 &evchap->u.get_chap.num_entries, buf); 3256 3257 actual_size = nlmsg_total_size(sizeof(*ev) + chap_buf_size); 3258 skb_trim(skbchap, NLMSG_ALIGN(actual_size)); 3259 nlhchap->nlmsg_len = actual_size; 3260 3261 err = iscsi_multicast_skb(skbchap, ISCSI_NL_GRP_ISCSID, 3262 GFP_KERNEL); 3263 } while (err < 0 && err != -ECONNREFUSED); 3264 3265 exit_get_chap: 3266 scsi_host_put(shost); 3267 return err; 3268 } 3269 3270 static int iscsi_set_chap(struct iscsi_transport *transport, 3271 struct iscsi_uevent *ev, uint32_t len) 3272 { 3273 char *data = (char *)ev + sizeof(*ev); 3274 struct Scsi_Host *shost; 3275 int err = 0; 3276 3277 if (!transport->set_chap) 3278 return -ENOSYS; 3279 3280 shost = scsi_host_lookup(ev->u.set_path.host_no); 3281 if (!shost) { 3282 pr_err("%s could not find host no %u\n", 3283 __func__, ev->u.set_path.host_no); 3284 return -ENODEV; 3285 } 3286 3287 err = transport->set_chap(shost, data, len); 3288 scsi_host_put(shost); 3289 return err; 3290 } 3291 3292 static int iscsi_delete_chap(struct iscsi_transport *transport, 3293 struct iscsi_uevent *ev) 3294 { 3295 struct Scsi_Host *shost; 3296 int err = 0; 3297 3298 if (!transport->delete_chap) 3299 return -ENOSYS; 3300 3301 shost = scsi_host_lookup(ev->u.delete_chap.host_no); 3302 if (!shost) { 3303 printk(KERN_ERR "%s could not find host no %u\n", 3304 __func__, ev->u.delete_chap.host_no); 3305 return -ENODEV; 3306 } 3307 3308 err = transport->delete_chap(shost, ev->u.delete_chap.chap_tbl_idx); 3309 scsi_host_put(shost); 3310 return err; 3311 } 3312 3313 static const struct { 3314 enum iscsi_discovery_parent_type value; 3315 char *name; 3316 } iscsi_discovery_parent_names[] = { 3317 {ISCSI_DISC_PARENT_UNKNOWN, "Unknown" }, 3318 {ISCSI_DISC_PARENT_SENDTGT, "Sendtarget" }, 3319 {ISCSI_DISC_PARENT_ISNS, "isns" }, 3320 }; 3321 3322 char *iscsi_get_discovery_parent_name(int parent_type) 3323 { 3324 int i; 3325 char *state = "Unknown!"; 3326 3327 for (i = 0; i < ARRAY_SIZE(iscsi_discovery_parent_names); i++) { 3328 if (iscsi_discovery_parent_names[i].value & parent_type) { 3329 state = iscsi_discovery_parent_names[i].name; 3330 break; 3331 } 3332 } 3333 return state; 3334 } 3335 EXPORT_SYMBOL_GPL(iscsi_get_discovery_parent_name); 3336 3337 static int iscsi_set_flashnode_param(struct iscsi_transport *transport, 3338 struct iscsi_uevent *ev, uint32_t len) 3339 { 3340 char *data = (char *)ev + sizeof(*ev); 3341 struct Scsi_Host *shost; 3342 struct iscsi_bus_flash_session *fnode_sess; 3343 struct iscsi_bus_flash_conn *fnode_conn; 3344 struct device *dev; 3345 uint32_t idx; 3346 int err = 0; 3347 3348 if (!transport->set_flashnode_param) { 3349 err = -ENOSYS; 3350 goto exit_set_fnode; 3351 } 3352 3353 shost = scsi_host_lookup(ev->u.set_flashnode.host_no); 3354 if (!shost) { 3355 pr_err("%s could not find host no %u\n", 3356 __func__, ev->u.set_flashnode.host_no); 3357 err = -ENODEV; 3358 goto exit_set_fnode; 3359 } 3360 3361 idx = ev->u.set_flashnode.flashnode_idx; 3362 fnode_sess = iscsi_get_flashnode_by_index(shost, idx); 3363 if (!fnode_sess) { 3364 pr_err("%s could not find flashnode %u for host no %u\n", 3365 __func__, idx, ev->u.set_flashnode.host_no); 3366 err = -ENODEV; 3367 goto put_host; 3368 } 3369 3370 dev = iscsi_find_flashnode_conn(fnode_sess); 3371 if (!dev) { 3372 err = -ENODEV; 3373 goto put_sess; 3374 } 3375 3376 fnode_conn = iscsi_dev_to_flash_conn(dev); 3377 err = transport->set_flashnode_param(fnode_sess, fnode_conn, data, len); 3378 put_device(dev); 3379 3380 put_sess: 3381 put_device(&fnode_sess->dev); 3382 3383 put_host: 3384 scsi_host_put(shost); 3385 3386 exit_set_fnode: 3387 return err; 3388 } 3389 3390 static int iscsi_new_flashnode(struct iscsi_transport *transport, 3391 struct iscsi_uevent *ev, uint32_t len) 3392 { 3393 char *data = (char *)ev + sizeof(*ev); 3394 struct Scsi_Host *shost; 3395 int index; 3396 int err = 0; 3397 3398 if (!transport->new_flashnode) { 3399 err = -ENOSYS; 3400 goto exit_new_fnode; 3401 } 3402 3403 shost = scsi_host_lookup(ev->u.new_flashnode.host_no); 3404 if (!shost) { 3405 pr_err("%s could not find host no %u\n", 3406 __func__, ev->u.new_flashnode.host_no); 3407 err = -ENODEV; 3408 goto put_host; 3409 } 3410 3411 index = transport->new_flashnode(shost, data, len); 3412 3413 if (index >= 0) 3414 ev->r.new_flashnode_ret.flashnode_idx = index; 3415 else 3416 err = -EIO; 3417 3418 put_host: 3419 scsi_host_put(shost); 3420 3421 exit_new_fnode: 3422 return err; 3423 } 3424 3425 static int iscsi_del_flashnode(struct iscsi_transport *transport, 3426 struct iscsi_uevent *ev) 3427 { 3428 struct Scsi_Host *shost; 3429 struct iscsi_bus_flash_session *fnode_sess; 3430 uint32_t idx; 3431 int err = 0; 3432 3433 if (!transport->del_flashnode) { 3434 err = -ENOSYS; 3435 goto exit_del_fnode; 3436 } 3437 3438 shost = scsi_host_lookup(ev->u.del_flashnode.host_no); 3439 if (!shost) { 3440 pr_err("%s could not find host no %u\n", 3441 __func__, ev->u.del_flashnode.host_no); 3442 err = -ENODEV; 3443 goto put_host; 3444 } 3445 3446 idx = ev->u.del_flashnode.flashnode_idx; 3447 fnode_sess = iscsi_get_flashnode_by_index(shost, idx); 3448 if (!fnode_sess) { 3449 pr_err("%s could not find flashnode %u for host no %u\n", 3450 __func__, idx, ev->u.del_flashnode.host_no); 3451 err = -ENODEV; 3452 goto put_host; 3453 } 3454 3455 err = transport->del_flashnode(fnode_sess); 3456 put_device(&fnode_sess->dev); 3457 3458 put_host: 3459 scsi_host_put(shost); 3460 3461 exit_del_fnode: 3462 return err; 3463 } 3464 3465 static int iscsi_login_flashnode(struct iscsi_transport *transport, 3466 struct iscsi_uevent *ev) 3467 { 3468 struct Scsi_Host *shost; 3469 struct iscsi_bus_flash_session *fnode_sess; 3470 struct iscsi_bus_flash_conn *fnode_conn; 3471 struct device *dev; 3472 uint32_t idx; 3473 int err = 0; 3474 3475 if (!transport->login_flashnode) { 3476 err = -ENOSYS; 3477 goto exit_login_fnode; 3478 } 3479 3480 shost = scsi_host_lookup(ev->u.login_flashnode.host_no); 3481 if (!shost) { 3482 pr_err("%s could not find host no %u\n", 3483 __func__, ev->u.login_flashnode.host_no); 3484 err = -ENODEV; 3485 goto put_host; 3486 } 3487 3488 idx = ev->u.login_flashnode.flashnode_idx; 3489 fnode_sess = iscsi_get_flashnode_by_index(shost, idx); 3490 if (!fnode_sess) { 3491 pr_err("%s could not find flashnode %u for host no %u\n", 3492 __func__, idx, ev->u.login_flashnode.host_no); 3493 err = -ENODEV; 3494 goto put_host; 3495 } 3496 3497 dev = iscsi_find_flashnode_conn(fnode_sess); 3498 if (!dev) { 3499 err = -ENODEV; 3500 goto put_sess; 3501 } 3502 3503 fnode_conn = iscsi_dev_to_flash_conn(dev); 3504 err = transport->login_flashnode(fnode_sess, fnode_conn); 3505 put_device(dev); 3506 3507 put_sess: 3508 put_device(&fnode_sess->dev); 3509 3510 put_host: 3511 scsi_host_put(shost); 3512 3513 exit_login_fnode: 3514 return err; 3515 } 3516 3517 static int iscsi_logout_flashnode(struct iscsi_transport *transport, 3518 struct iscsi_uevent *ev) 3519 { 3520 struct Scsi_Host *shost; 3521 struct iscsi_bus_flash_session *fnode_sess; 3522 struct iscsi_bus_flash_conn *fnode_conn; 3523 struct device *dev; 3524 uint32_t idx; 3525 int err = 0; 3526 3527 if (!transport->logout_flashnode) { 3528 err = -ENOSYS; 3529 goto exit_logout_fnode; 3530 } 3531 3532 shost = scsi_host_lookup(ev->u.logout_flashnode.host_no); 3533 if (!shost) { 3534 pr_err("%s could not find host no %u\n", 3535 __func__, ev->u.logout_flashnode.host_no); 3536 err = -ENODEV; 3537 goto put_host; 3538 } 3539 3540 idx = ev->u.logout_flashnode.flashnode_idx; 3541 fnode_sess = iscsi_get_flashnode_by_index(shost, idx); 3542 if (!fnode_sess) { 3543 pr_err("%s could not find flashnode %u for host no %u\n", 3544 __func__, idx, ev->u.logout_flashnode.host_no); 3545 err = -ENODEV; 3546 goto put_host; 3547 } 3548 3549 dev = iscsi_find_flashnode_conn(fnode_sess); 3550 if (!dev) { 3551 err = -ENODEV; 3552 goto put_sess; 3553 } 3554 3555 fnode_conn = iscsi_dev_to_flash_conn(dev); 3556 3557 err = transport->logout_flashnode(fnode_sess, fnode_conn); 3558 put_device(dev); 3559 3560 put_sess: 3561 put_device(&fnode_sess->dev); 3562 3563 put_host: 3564 scsi_host_put(shost); 3565 3566 exit_logout_fnode: 3567 return err; 3568 } 3569 3570 static int iscsi_logout_flashnode_sid(struct iscsi_transport *transport, 3571 struct iscsi_uevent *ev) 3572 { 3573 struct Scsi_Host *shost; 3574 struct iscsi_cls_session *session; 3575 int err = 0; 3576 3577 if (!transport->logout_flashnode_sid) { 3578 err = -ENOSYS; 3579 goto exit_logout_sid; 3580 } 3581 3582 shost = scsi_host_lookup(ev->u.logout_flashnode_sid.host_no); 3583 if (!shost) { 3584 pr_err("%s could not find host no %u\n", 3585 __func__, ev->u.logout_flashnode.host_no); 3586 err = -ENODEV; 3587 goto put_host; 3588 } 3589 3590 session = iscsi_session_lookup(ev->u.logout_flashnode_sid.sid); 3591 if (!session) { 3592 pr_err("%s could not find session id %u\n", 3593 __func__, ev->u.logout_flashnode_sid.sid); 3594 err = -EINVAL; 3595 goto put_host; 3596 } 3597 3598 err = transport->logout_flashnode_sid(session); 3599 3600 put_host: 3601 scsi_host_put(shost); 3602 3603 exit_logout_sid: 3604 return err; 3605 } 3606 3607 static int 3608 iscsi_get_host_stats(struct iscsi_transport *transport, struct nlmsghdr *nlh) 3609 { 3610 struct iscsi_uevent *ev = nlmsg_data(nlh); 3611 struct Scsi_Host *shost = NULL; 3612 struct iscsi_internal *priv; 3613 struct sk_buff *skbhost_stats; 3614 struct nlmsghdr *nlhhost_stats; 3615 struct iscsi_uevent *evhost_stats; 3616 int host_stats_size = 0; 3617 int len, err = 0; 3618 char *buf; 3619 3620 if (!transport->get_host_stats) 3621 return -ENOSYS; 3622 3623 priv = iscsi_if_transport_lookup(transport); 3624 if (!priv) 3625 return -EINVAL; 3626 3627 host_stats_size = sizeof(struct iscsi_offload_host_stats); 3628 len = nlmsg_total_size(sizeof(*ev) + host_stats_size); 3629 3630 shost = scsi_host_lookup(ev->u.get_host_stats.host_no); 3631 if (!shost) { 3632 pr_err("%s: failed. Could not find host no %u\n", 3633 __func__, ev->u.get_host_stats.host_no); 3634 return -ENODEV; 3635 } 3636 3637 do { 3638 int actual_size; 3639 3640 skbhost_stats = alloc_skb(len, GFP_KERNEL); 3641 if (!skbhost_stats) { 3642 pr_err("cannot deliver host stats: OOM\n"); 3643 err = -ENOMEM; 3644 goto exit_host_stats; 3645 } 3646 3647 nlhhost_stats = __nlmsg_put(skbhost_stats, 0, 0, 0, 3648 (len - sizeof(*nlhhost_stats)), 0); 3649 evhost_stats = nlmsg_data(nlhhost_stats); 3650 memset(evhost_stats, 0, sizeof(*evhost_stats)); 3651 evhost_stats->transport_handle = iscsi_handle(transport); 3652 evhost_stats->type = nlh->nlmsg_type; 3653 evhost_stats->u.get_host_stats.host_no = 3654 ev->u.get_host_stats.host_no; 3655 buf = (char *)evhost_stats + sizeof(*evhost_stats); 3656 memset(buf, 0, host_stats_size); 3657 3658 err = transport->get_host_stats(shost, buf, host_stats_size); 3659 if (err) { 3660 kfree_skb(skbhost_stats); 3661 goto exit_host_stats; 3662 } 3663 3664 actual_size = nlmsg_total_size(sizeof(*ev) + host_stats_size); 3665 skb_trim(skbhost_stats, NLMSG_ALIGN(actual_size)); 3666 nlhhost_stats->nlmsg_len = actual_size; 3667 3668 err = iscsi_multicast_skb(skbhost_stats, ISCSI_NL_GRP_ISCSID, 3669 GFP_KERNEL); 3670 } while (err < 0 && err != -ECONNREFUSED); 3671 3672 exit_host_stats: 3673 scsi_host_put(shost); 3674 return err; 3675 } 3676 3677 static int iscsi_if_transport_conn(struct iscsi_transport *transport, 3678 struct nlmsghdr *nlh) 3679 { 3680 struct iscsi_uevent *ev = nlmsg_data(nlh); 3681 struct iscsi_cls_session *session; 3682 struct iscsi_cls_conn *conn = NULL; 3683 struct iscsi_endpoint *ep; 3684 uint32_t pdu_len; 3685 int err = 0; 3686 3687 switch (nlh->nlmsg_type) { 3688 case ISCSI_UEVENT_CREATE_CONN: 3689 return iscsi_if_create_conn(transport, ev); 3690 case ISCSI_UEVENT_DESTROY_CONN: 3691 return iscsi_if_destroy_conn(transport, ev); 3692 case ISCSI_UEVENT_STOP_CONN: 3693 return iscsi_if_stop_conn(transport, ev); 3694 } 3695 3696 /* 3697 * The following cmds need to be run under the ep_mutex so in kernel 3698 * conn cleanup (ep_disconnect + unbind and conn) is not done while 3699 * these are running. They also must not run if we have just run a conn 3700 * cleanup because they would set the state in a way that might allow 3701 * IO or send IO themselves. 3702 */ 3703 switch (nlh->nlmsg_type) { 3704 case ISCSI_UEVENT_START_CONN: 3705 conn = iscsi_conn_lookup(ev->u.start_conn.sid, 3706 ev->u.start_conn.cid); 3707 break; 3708 case ISCSI_UEVENT_BIND_CONN: 3709 conn = iscsi_conn_lookup(ev->u.b_conn.sid, ev->u.b_conn.cid); 3710 break; 3711 case ISCSI_UEVENT_SEND_PDU: 3712 conn = iscsi_conn_lookup(ev->u.send_pdu.sid, ev->u.send_pdu.cid); 3713 break; 3714 } 3715 3716 if (!conn) 3717 return -EINVAL; 3718 3719 mutex_lock(&conn->ep_mutex); 3720 if (test_bit(ISCSI_CLS_CONN_BIT_CLEANUP, &conn->flags)) { 3721 mutex_unlock(&conn->ep_mutex); 3722 ev->r.retcode = -ENOTCONN; 3723 return 0; 3724 } 3725 3726 switch (nlh->nlmsg_type) { 3727 case ISCSI_UEVENT_BIND_CONN: 3728 if (conn->ep) { 3729 /* 3730 * For offload boot support where iscsid is restarted 3731 * during the pivot root stage, the ep will be intact 3732 * here when the new iscsid instance starts up and 3733 * reconnects. 3734 */ 3735 iscsi_ep_disconnect(conn, true); 3736 } 3737 3738 session = iscsi_session_lookup(ev->u.b_conn.sid); 3739 if (!session) { 3740 err = -EINVAL; 3741 break; 3742 } 3743 3744 ev->r.retcode = transport->bind_conn(session, conn, 3745 ev->u.b_conn.transport_eph, 3746 ev->u.b_conn.is_leading); 3747 if (!ev->r.retcode) 3748 conn->state = ISCSI_CONN_BOUND; 3749 3750 if (ev->r.retcode || !transport->ep_connect) 3751 break; 3752 3753 ep = iscsi_lookup_endpoint(ev->u.b_conn.transport_eph); 3754 if (ep) { 3755 ep->conn = conn; 3756 conn->ep = ep; 3757 iscsi_put_endpoint(ep); 3758 } else { 3759 err = -ENOTCONN; 3760 iscsi_cls_conn_printk(KERN_ERR, conn, 3761 "Could not set ep conn binding\n"); 3762 } 3763 break; 3764 case ISCSI_UEVENT_START_CONN: 3765 ev->r.retcode = transport->start_conn(conn); 3766 if (!ev->r.retcode) 3767 conn->state = ISCSI_CONN_UP; 3768 break; 3769 case ISCSI_UEVENT_SEND_PDU: 3770 pdu_len = nlh->nlmsg_len - sizeof(*nlh) - sizeof(*ev); 3771 3772 if ((ev->u.send_pdu.hdr_size > pdu_len) || 3773 (ev->u.send_pdu.data_size > (pdu_len - ev->u.send_pdu.hdr_size))) { 3774 err = -EINVAL; 3775 break; 3776 } 3777 3778 ev->r.retcode = transport->send_pdu(conn, 3779 (struct iscsi_hdr *)((char *)ev + sizeof(*ev)), 3780 (char *)ev + sizeof(*ev) + ev->u.send_pdu.hdr_size, 3781 ev->u.send_pdu.data_size); 3782 break; 3783 default: 3784 err = -ENOSYS; 3785 } 3786 3787 mutex_unlock(&conn->ep_mutex); 3788 return err; 3789 } 3790 3791 static int 3792 iscsi_if_recv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, uint32_t *group) 3793 { 3794 int err = 0; 3795 u32 portid; 3796 struct iscsi_uevent *ev = nlmsg_data(nlh); 3797 struct iscsi_transport *transport = NULL; 3798 struct iscsi_internal *priv; 3799 struct iscsi_cls_session *session; 3800 struct iscsi_endpoint *ep = NULL; 3801 3802 if (!netlink_capable(skb, CAP_SYS_ADMIN)) 3803 return -EPERM; 3804 3805 if (nlh->nlmsg_type == ISCSI_UEVENT_PATH_UPDATE) 3806 *group = ISCSI_NL_GRP_UIP; 3807 else 3808 *group = ISCSI_NL_GRP_ISCSID; 3809 3810 priv = iscsi_if_transport_lookup(iscsi_ptr(ev->transport_handle)); 3811 if (!priv) 3812 return -EINVAL; 3813 transport = priv->iscsi_transport; 3814 3815 if (!try_module_get(transport->owner)) 3816 return -EINVAL; 3817 3818 portid = NETLINK_CB(skb).portid; 3819 3820 switch (nlh->nlmsg_type) { 3821 case ISCSI_UEVENT_CREATE_SESSION: 3822 err = iscsi_if_create_session(priv, ep, ev, 3823 portid, 3824 ev->u.c_session.initial_cmdsn, 3825 ev->u.c_session.cmds_max, 3826 ev->u.c_session.queue_depth); 3827 break; 3828 case ISCSI_UEVENT_CREATE_BOUND_SESSION: 3829 ep = iscsi_lookup_endpoint(ev->u.c_bound_session.ep_handle); 3830 if (!ep) { 3831 err = -EINVAL; 3832 break; 3833 } 3834 3835 err = iscsi_if_create_session(priv, ep, ev, 3836 portid, 3837 ev->u.c_bound_session.initial_cmdsn, 3838 ev->u.c_bound_session.cmds_max, 3839 ev->u.c_bound_session.queue_depth); 3840 iscsi_put_endpoint(ep); 3841 break; 3842 case ISCSI_UEVENT_DESTROY_SESSION: 3843 session = iscsi_session_lookup(ev->u.d_session.sid); 3844 if (!session) 3845 err = -EINVAL; 3846 else if (iscsi_session_has_conns(ev->u.d_session.sid)) 3847 err = -EBUSY; 3848 else 3849 transport->destroy_session(session); 3850 break; 3851 case ISCSI_UEVENT_DESTROY_SESSION_ASYNC: 3852 session = iscsi_session_lookup(ev->u.d_session.sid); 3853 if (!session) 3854 err = -EINVAL; 3855 else if (iscsi_session_has_conns(ev->u.d_session.sid)) 3856 err = -EBUSY; 3857 else { 3858 unsigned long flags; 3859 3860 /* Prevent this session from being found again */ 3861 spin_lock_irqsave(&sesslock, flags); 3862 list_del_init(&session->sess_list); 3863 spin_unlock_irqrestore(&sesslock, flags); 3864 3865 queue_work(system_unbound_wq, &session->destroy_work); 3866 } 3867 break; 3868 case ISCSI_UEVENT_UNBIND_SESSION: 3869 session = iscsi_session_lookup(ev->u.d_session.sid); 3870 if (session) 3871 scsi_queue_work(iscsi_session_to_shost(session), 3872 &session->unbind_work); 3873 else 3874 err = -EINVAL; 3875 break; 3876 case ISCSI_UEVENT_SET_PARAM: 3877 err = iscsi_set_param(transport, ev); 3878 break; 3879 case ISCSI_UEVENT_CREATE_CONN: 3880 case ISCSI_UEVENT_DESTROY_CONN: 3881 case ISCSI_UEVENT_STOP_CONN: 3882 case ISCSI_UEVENT_START_CONN: 3883 case ISCSI_UEVENT_BIND_CONN: 3884 case ISCSI_UEVENT_SEND_PDU: 3885 err = iscsi_if_transport_conn(transport, nlh); 3886 break; 3887 case ISCSI_UEVENT_GET_STATS: 3888 err = iscsi_if_get_stats(transport, nlh); 3889 break; 3890 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT: 3891 case ISCSI_UEVENT_TRANSPORT_EP_POLL: 3892 case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT: 3893 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST: 3894 err = iscsi_if_transport_ep(transport, ev, nlh->nlmsg_type); 3895 break; 3896 case ISCSI_UEVENT_TGT_DSCVR: 3897 err = iscsi_tgt_dscvr(transport, ev); 3898 break; 3899 case ISCSI_UEVENT_SET_HOST_PARAM: 3900 err = iscsi_set_host_param(transport, ev); 3901 break; 3902 case ISCSI_UEVENT_PATH_UPDATE: 3903 err = iscsi_set_path(transport, ev); 3904 break; 3905 case ISCSI_UEVENT_SET_IFACE_PARAMS: 3906 err = iscsi_set_iface_params(transport, ev, 3907 nlmsg_attrlen(nlh, sizeof(*ev))); 3908 break; 3909 case ISCSI_UEVENT_PING: 3910 err = iscsi_send_ping(transport, ev); 3911 break; 3912 case ISCSI_UEVENT_GET_CHAP: 3913 err = iscsi_get_chap(transport, nlh); 3914 break; 3915 case ISCSI_UEVENT_DELETE_CHAP: 3916 err = iscsi_delete_chap(transport, ev); 3917 break; 3918 case ISCSI_UEVENT_SET_FLASHNODE_PARAMS: 3919 err = iscsi_set_flashnode_param(transport, ev, 3920 nlmsg_attrlen(nlh, 3921 sizeof(*ev))); 3922 break; 3923 case ISCSI_UEVENT_NEW_FLASHNODE: 3924 err = iscsi_new_flashnode(transport, ev, 3925 nlmsg_attrlen(nlh, sizeof(*ev))); 3926 break; 3927 case ISCSI_UEVENT_DEL_FLASHNODE: 3928 err = iscsi_del_flashnode(transport, ev); 3929 break; 3930 case ISCSI_UEVENT_LOGIN_FLASHNODE: 3931 err = iscsi_login_flashnode(transport, ev); 3932 break; 3933 case ISCSI_UEVENT_LOGOUT_FLASHNODE: 3934 err = iscsi_logout_flashnode(transport, ev); 3935 break; 3936 case ISCSI_UEVENT_LOGOUT_FLASHNODE_SID: 3937 err = iscsi_logout_flashnode_sid(transport, ev); 3938 break; 3939 case ISCSI_UEVENT_SET_CHAP: 3940 err = iscsi_set_chap(transport, ev, 3941 nlmsg_attrlen(nlh, sizeof(*ev))); 3942 break; 3943 case ISCSI_UEVENT_GET_HOST_STATS: 3944 err = iscsi_get_host_stats(transport, nlh); 3945 break; 3946 default: 3947 err = -ENOSYS; 3948 break; 3949 } 3950 3951 module_put(transport->owner); 3952 return err; 3953 } 3954 3955 /* 3956 * Get message from skb. Each message is processed by iscsi_if_recv_msg. 3957 * Malformed skbs with wrong lengths or invalid creds are not processed. 3958 */ 3959 static void 3960 iscsi_if_rx(struct sk_buff *skb) 3961 { 3962 u32 portid = NETLINK_CB(skb).portid; 3963 3964 mutex_lock(&rx_queue_mutex); 3965 while (skb->len >= NLMSG_HDRLEN) { 3966 int err; 3967 uint32_t rlen; 3968 struct nlmsghdr *nlh; 3969 struct iscsi_uevent *ev; 3970 uint32_t group; 3971 int retries = ISCSI_SEND_MAX_ALLOWED; 3972 3973 nlh = nlmsg_hdr(skb); 3974 if (nlh->nlmsg_len < sizeof(*nlh) + sizeof(*ev) || 3975 skb->len < nlh->nlmsg_len) { 3976 break; 3977 } 3978 3979 ev = nlmsg_data(nlh); 3980 rlen = NLMSG_ALIGN(nlh->nlmsg_len); 3981 if (rlen > skb->len) 3982 rlen = skb->len; 3983 3984 err = iscsi_if_recv_msg(skb, nlh, &group); 3985 if (err) { 3986 ev->type = ISCSI_KEVENT_IF_ERROR; 3987 ev->iferror = err; 3988 } 3989 do { 3990 /* 3991 * special case for GET_STATS: 3992 * on success - sending reply and stats from 3993 * inside of if_recv_msg(), 3994 * on error - fall through. 3995 */ 3996 if (ev->type == ISCSI_UEVENT_GET_STATS && !err) 3997 break; 3998 if (ev->type == ISCSI_UEVENT_GET_CHAP && !err) 3999 break; 4000 err = iscsi_if_send_reply(portid, nlh->nlmsg_type, 4001 ev, sizeof(*ev)); 4002 if (err == -EAGAIN && --retries < 0) { 4003 printk(KERN_WARNING "Send reply failed, error %d\n", err); 4004 break; 4005 } 4006 } while (err < 0 && err != -ECONNREFUSED && err != -ESRCH); 4007 skb_pull(skb, rlen); 4008 } 4009 mutex_unlock(&rx_queue_mutex); 4010 } 4011 4012 #define ISCSI_CLASS_ATTR(_prefix,_name,_mode,_show,_store) \ 4013 struct device_attribute dev_attr_##_prefix##_##_name = \ 4014 __ATTR(_name,_mode,_show,_store) 4015 4016 /* 4017 * iSCSI connection attrs 4018 */ 4019 #define iscsi_conn_attr_show(param) \ 4020 static ssize_t \ 4021 show_conn_param_##param(struct device *dev, \ 4022 struct device_attribute *attr, char *buf) \ 4023 { \ 4024 struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent); \ 4025 struct iscsi_transport *t = conn->transport; \ 4026 return t->get_conn_param(conn, param, buf); \ 4027 } 4028 4029 #define iscsi_conn_attr(field, param) \ 4030 iscsi_conn_attr_show(param) \ 4031 static ISCSI_CLASS_ATTR(conn, field, S_IRUGO, show_conn_param_##param, \ 4032 NULL); 4033 4034 iscsi_conn_attr(max_recv_dlength, ISCSI_PARAM_MAX_RECV_DLENGTH); 4035 iscsi_conn_attr(max_xmit_dlength, ISCSI_PARAM_MAX_XMIT_DLENGTH); 4036 iscsi_conn_attr(header_digest, ISCSI_PARAM_HDRDGST_EN); 4037 iscsi_conn_attr(data_digest, ISCSI_PARAM_DATADGST_EN); 4038 iscsi_conn_attr(ifmarker, ISCSI_PARAM_IFMARKER_EN); 4039 iscsi_conn_attr(ofmarker, ISCSI_PARAM_OFMARKER_EN); 4040 iscsi_conn_attr(persistent_port, ISCSI_PARAM_PERSISTENT_PORT); 4041 iscsi_conn_attr(exp_statsn, ISCSI_PARAM_EXP_STATSN); 4042 iscsi_conn_attr(persistent_address, ISCSI_PARAM_PERSISTENT_ADDRESS); 4043 iscsi_conn_attr(ping_tmo, ISCSI_PARAM_PING_TMO); 4044 iscsi_conn_attr(recv_tmo, ISCSI_PARAM_RECV_TMO); 4045 iscsi_conn_attr(local_port, ISCSI_PARAM_LOCAL_PORT); 4046 iscsi_conn_attr(statsn, ISCSI_PARAM_STATSN); 4047 iscsi_conn_attr(keepalive_tmo, ISCSI_PARAM_KEEPALIVE_TMO); 4048 iscsi_conn_attr(max_segment_size, ISCSI_PARAM_MAX_SEGMENT_SIZE); 4049 iscsi_conn_attr(tcp_timestamp_stat, ISCSI_PARAM_TCP_TIMESTAMP_STAT); 4050 iscsi_conn_attr(tcp_wsf_disable, ISCSI_PARAM_TCP_WSF_DISABLE); 4051 iscsi_conn_attr(tcp_nagle_disable, ISCSI_PARAM_TCP_NAGLE_DISABLE); 4052 iscsi_conn_attr(tcp_timer_scale, ISCSI_PARAM_TCP_TIMER_SCALE); 4053 iscsi_conn_attr(tcp_timestamp_enable, ISCSI_PARAM_TCP_TIMESTAMP_EN); 4054 iscsi_conn_attr(fragment_disable, ISCSI_PARAM_IP_FRAGMENT_DISABLE); 4055 iscsi_conn_attr(ipv4_tos, ISCSI_PARAM_IPV4_TOS); 4056 iscsi_conn_attr(ipv6_traffic_class, ISCSI_PARAM_IPV6_TC); 4057 iscsi_conn_attr(ipv6_flow_label, ISCSI_PARAM_IPV6_FLOW_LABEL); 4058 iscsi_conn_attr(is_fw_assigned_ipv6, ISCSI_PARAM_IS_FW_ASSIGNED_IPV6); 4059 iscsi_conn_attr(tcp_xmit_wsf, ISCSI_PARAM_TCP_XMIT_WSF); 4060 iscsi_conn_attr(tcp_recv_wsf, ISCSI_PARAM_TCP_RECV_WSF); 4061 iscsi_conn_attr(local_ipaddr, ISCSI_PARAM_LOCAL_IPADDR); 4062 4063 static const char *const connection_state_names[] = { 4064 [ISCSI_CONN_UP] = "up", 4065 [ISCSI_CONN_DOWN] = "down", 4066 [ISCSI_CONN_FAILED] = "failed", 4067 [ISCSI_CONN_BOUND] = "bound" 4068 }; 4069 4070 static ssize_t show_conn_state(struct device *dev, 4071 struct device_attribute *attr, char *buf) 4072 { 4073 struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent); 4074 const char *state = "unknown"; 4075 4076 if (conn->state >= 0 && 4077 conn->state < ARRAY_SIZE(connection_state_names)) 4078 state = connection_state_names[conn->state]; 4079 4080 return sysfs_emit(buf, "%s\n", state); 4081 } 4082 static ISCSI_CLASS_ATTR(conn, state, S_IRUGO, show_conn_state, 4083 NULL); 4084 4085 #define iscsi_conn_ep_attr_show(param) \ 4086 static ssize_t show_conn_ep_param_##param(struct device *dev, \ 4087 struct device_attribute *attr,\ 4088 char *buf) \ 4089 { \ 4090 struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent); \ 4091 struct iscsi_transport *t = conn->transport; \ 4092 struct iscsi_endpoint *ep; \ 4093 ssize_t rc; \ 4094 \ 4095 /* \ 4096 * Need to make sure ep_disconnect does not free the LLD's \ 4097 * interconnect resources while we are trying to read them. \ 4098 */ \ 4099 mutex_lock(&conn->ep_mutex); \ 4100 ep = conn->ep; \ 4101 if (!ep && t->ep_connect) { \ 4102 mutex_unlock(&conn->ep_mutex); \ 4103 return -ENOTCONN; \ 4104 } \ 4105 \ 4106 if (ep) \ 4107 rc = t->get_ep_param(ep, param, buf); \ 4108 else \ 4109 rc = t->get_conn_param(conn, param, buf); \ 4110 mutex_unlock(&conn->ep_mutex); \ 4111 return rc; \ 4112 } 4113 4114 #define iscsi_conn_ep_attr(field, param) \ 4115 iscsi_conn_ep_attr_show(param) \ 4116 static ISCSI_CLASS_ATTR(conn, field, S_IRUGO, \ 4117 show_conn_ep_param_##param, NULL); 4118 4119 iscsi_conn_ep_attr(address, ISCSI_PARAM_CONN_ADDRESS); 4120 iscsi_conn_ep_attr(port, ISCSI_PARAM_CONN_PORT); 4121 4122 static struct attribute *iscsi_conn_attrs[] = { 4123 &dev_attr_conn_max_recv_dlength.attr, 4124 &dev_attr_conn_max_xmit_dlength.attr, 4125 &dev_attr_conn_header_digest.attr, 4126 &dev_attr_conn_data_digest.attr, 4127 &dev_attr_conn_ifmarker.attr, 4128 &dev_attr_conn_ofmarker.attr, 4129 &dev_attr_conn_address.attr, 4130 &dev_attr_conn_port.attr, 4131 &dev_attr_conn_exp_statsn.attr, 4132 &dev_attr_conn_persistent_address.attr, 4133 &dev_attr_conn_persistent_port.attr, 4134 &dev_attr_conn_ping_tmo.attr, 4135 &dev_attr_conn_recv_tmo.attr, 4136 &dev_attr_conn_local_port.attr, 4137 &dev_attr_conn_statsn.attr, 4138 &dev_attr_conn_keepalive_tmo.attr, 4139 &dev_attr_conn_max_segment_size.attr, 4140 &dev_attr_conn_tcp_timestamp_stat.attr, 4141 &dev_attr_conn_tcp_wsf_disable.attr, 4142 &dev_attr_conn_tcp_nagle_disable.attr, 4143 &dev_attr_conn_tcp_timer_scale.attr, 4144 &dev_attr_conn_tcp_timestamp_enable.attr, 4145 &dev_attr_conn_fragment_disable.attr, 4146 &dev_attr_conn_ipv4_tos.attr, 4147 &dev_attr_conn_ipv6_traffic_class.attr, 4148 &dev_attr_conn_ipv6_flow_label.attr, 4149 &dev_attr_conn_is_fw_assigned_ipv6.attr, 4150 &dev_attr_conn_tcp_xmit_wsf.attr, 4151 &dev_attr_conn_tcp_recv_wsf.attr, 4152 &dev_attr_conn_local_ipaddr.attr, 4153 &dev_attr_conn_state.attr, 4154 NULL, 4155 }; 4156 4157 static umode_t iscsi_conn_attr_is_visible(struct kobject *kobj, 4158 struct attribute *attr, int i) 4159 { 4160 struct device *cdev = container_of(kobj, struct device, kobj); 4161 struct iscsi_cls_conn *conn = transport_class_to_conn(cdev); 4162 struct iscsi_transport *t = conn->transport; 4163 int param; 4164 4165 if (attr == &dev_attr_conn_max_recv_dlength.attr) 4166 param = ISCSI_PARAM_MAX_RECV_DLENGTH; 4167 else if (attr == &dev_attr_conn_max_xmit_dlength.attr) 4168 param = ISCSI_PARAM_MAX_XMIT_DLENGTH; 4169 else if (attr == &dev_attr_conn_header_digest.attr) 4170 param = ISCSI_PARAM_HDRDGST_EN; 4171 else if (attr == &dev_attr_conn_data_digest.attr) 4172 param = ISCSI_PARAM_DATADGST_EN; 4173 else if (attr == &dev_attr_conn_ifmarker.attr) 4174 param = ISCSI_PARAM_IFMARKER_EN; 4175 else if (attr == &dev_attr_conn_ofmarker.attr) 4176 param = ISCSI_PARAM_OFMARKER_EN; 4177 else if (attr == &dev_attr_conn_address.attr) 4178 param = ISCSI_PARAM_CONN_ADDRESS; 4179 else if (attr == &dev_attr_conn_port.attr) 4180 param = ISCSI_PARAM_CONN_PORT; 4181 else if (attr == &dev_attr_conn_exp_statsn.attr) 4182 param = ISCSI_PARAM_EXP_STATSN; 4183 else if (attr == &dev_attr_conn_persistent_address.attr) 4184 param = ISCSI_PARAM_PERSISTENT_ADDRESS; 4185 else if (attr == &dev_attr_conn_persistent_port.attr) 4186 param = ISCSI_PARAM_PERSISTENT_PORT; 4187 else if (attr == &dev_attr_conn_ping_tmo.attr) 4188 param = ISCSI_PARAM_PING_TMO; 4189 else if (attr == &dev_attr_conn_recv_tmo.attr) 4190 param = ISCSI_PARAM_RECV_TMO; 4191 else if (attr == &dev_attr_conn_local_port.attr) 4192 param = ISCSI_PARAM_LOCAL_PORT; 4193 else if (attr == &dev_attr_conn_statsn.attr) 4194 param = ISCSI_PARAM_STATSN; 4195 else if (attr == &dev_attr_conn_keepalive_tmo.attr) 4196 param = ISCSI_PARAM_KEEPALIVE_TMO; 4197 else if (attr == &dev_attr_conn_max_segment_size.attr) 4198 param = ISCSI_PARAM_MAX_SEGMENT_SIZE; 4199 else if (attr == &dev_attr_conn_tcp_timestamp_stat.attr) 4200 param = ISCSI_PARAM_TCP_TIMESTAMP_STAT; 4201 else if (attr == &dev_attr_conn_tcp_wsf_disable.attr) 4202 param = ISCSI_PARAM_TCP_WSF_DISABLE; 4203 else if (attr == &dev_attr_conn_tcp_nagle_disable.attr) 4204 param = ISCSI_PARAM_TCP_NAGLE_DISABLE; 4205 else if (attr == &dev_attr_conn_tcp_timer_scale.attr) 4206 param = ISCSI_PARAM_TCP_TIMER_SCALE; 4207 else if (attr == &dev_attr_conn_tcp_timestamp_enable.attr) 4208 param = ISCSI_PARAM_TCP_TIMESTAMP_EN; 4209 else if (attr == &dev_attr_conn_fragment_disable.attr) 4210 param = ISCSI_PARAM_IP_FRAGMENT_DISABLE; 4211 else if (attr == &dev_attr_conn_ipv4_tos.attr) 4212 param = ISCSI_PARAM_IPV4_TOS; 4213 else if (attr == &dev_attr_conn_ipv6_traffic_class.attr) 4214 param = ISCSI_PARAM_IPV6_TC; 4215 else if (attr == &dev_attr_conn_ipv6_flow_label.attr) 4216 param = ISCSI_PARAM_IPV6_FLOW_LABEL; 4217 else if (attr == &dev_attr_conn_is_fw_assigned_ipv6.attr) 4218 param = ISCSI_PARAM_IS_FW_ASSIGNED_IPV6; 4219 else if (attr == &dev_attr_conn_tcp_xmit_wsf.attr) 4220 param = ISCSI_PARAM_TCP_XMIT_WSF; 4221 else if (attr == &dev_attr_conn_tcp_recv_wsf.attr) 4222 param = ISCSI_PARAM_TCP_RECV_WSF; 4223 else if (attr == &dev_attr_conn_local_ipaddr.attr) 4224 param = ISCSI_PARAM_LOCAL_IPADDR; 4225 else if (attr == &dev_attr_conn_state.attr) 4226 return S_IRUGO; 4227 else { 4228 WARN_ONCE(1, "Invalid conn attr"); 4229 return 0; 4230 } 4231 4232 return t->attr_is_visible(ISCSI_PARAM, param); 4233 } 4234 4235 static struct attribute_group iscsi_conn_group = { 4236 .attrs = iscsi_conn_attrs, 4237 .is_visible = iscsi_conn_attr_is_visible, 4238 }; 4239 4240 /* 4241 * iSCSI session attrs 4242 */ 4243 #define iscsi_session_attr_show(param, perm) \ 4244 static ssize_t \ 4245 show_session_param_##param(struct device *dev, \ 4246 struct device_attribute *attr, char *buf) \ 4247 { \ 4248 struct iscsi_cls_session *session = \ 4249 iscsi_dev_to_session(dev->parent); \ 4250 struct iscsi_transport *t = session->transport; \ 4251 \ 4252 if (perm && !capable(CAP_SYS_ADMIN)) \ 4253 return -EACCES; \ 4254 return t->get_session_param(session, param, buf); \ 4255 } 4256 4257 #define iscsi_session_attr(field, param, perm) \ 4258 iscsi_session_attr_show(param, perm) \ 4259 static ISCSI_CLASS_ATTR(sess, field, S_IRUGO, show_session_param_##param, \ 4260 NULL); 4261 iscsi_session_attr(targetname, ISCSI_PARAM_TARGET_NAME, 0); 4262 iscsi_session_attr(initial_r2t, ISCSI_PARAM_INITIAL_R2T_EN, 0); 4263 iscsi_session_attr(max_outstanding_r2t, ISCSI_PARAM_MAX_R2T, 0); 4264 iscsi_session_attr(immediate_data, ISCSI_PARAM_IMM_DATA_EN, 0); 4265 iscsi_session_attr(first_burst_len, ISCSI_PARAM_FIRST_BURST, 0); 4266 iscsi_session_attr(max_burst_len, ISCSI_PARAM_MAX_BURST, 0); 4267 iscsi_session_attr(data_pdu_in_order, ISCSI_PARAM_PDU_INORDER_EN, 0); 4268 iscsi_session_attr(data_seq_in_order, ISCSI_PARAM_DATASEQ_INORDER_EN, 0); 4269 iscsi_session_attr(erl, ISCSI_PARAM_ERL, 0); 4270 iscsi_session_attr(tpgt, ISCSI_PARAM_TPGT, 0); 4271 iscsi_session_attr(username, ISCSI_PARAM_USERNAME, 1); 4272 iscsi_session_attr(username_in, ISCSI_PARAM_USERNAME_IN, 1); 4273 iscsi_session_attr(password, ISCSI_PARAM_PASSWORD, 1); 4274 iscsi_session_attr(password_in, ISCSI_PARAM_PASSWORD_IN, 1); 4275 iscsi_session_attr(chap_out_idx, ISCSI_PARAM_CHAP_OUT_IDX, 1); 4276 iscsi_session_attr(chap_in_idx, ISCSI_PARAM_CHAP_IN_IDX, 1); 4277 iscsi_session_attr(fast_abort, ISCSI_PARAM_FAST_ABORT, 0); 4278 iscsi_session_attr(abort_tmo, ISCSI_PARAM_ABORT_TMO, 0); 4279 iscsi_session_attr(lu_reset_tmo, ISCSI_PARAM_LU_RESET_TMO, 0); 4280 iscsi_session_attr(tgt_reset_tmo, ISCSI_PARAM_TGT_RESET_TMO, 0); 4281 iscsi_session_attr(ifacename, ISCSI_PARAM_IFACE_NAME, 0); 4282 iscsi_session_attr(initiatorname, ISCSI_PARAM_INITIATOR_NAME, 0); 4283 iscsi_session_attr(targetalias, ISCSI_PARAM_TARGET_ALIAS, 0); 4284 iscsi_session_attr(boot_root, ISCSI_PARAM_BOOT_ROOT, 0); 4285 iscsi_session_attr(boot_nic, ISCSI_PARAM_BOOT_NIC, 0); 4286 iscsi_session_attr(boot_target, ISCSI_PARAM_BOOT_TARGET, 0); 4287 iscsi_session_attr(auto_snd_tgt_disable, ISCSI_PARAM_AUTO_SND_TGT_DISABLE, 0); 4288 iscsi_session_attr(discovery_session, ISCSI_PARAM_DISCOVERY_SESS, 0); 4289 iscsi_session_attr(portal_type, ISCSI_PARAM_PORTAL_TYPE, 0); 4290 iscsi_session_attr(chap_auth, ISCSI_PARAM_CHAP_AUTH_EN, 0); 4291 iscsi_session_attr(discovery_logout, ISCSI_PARAM_DISCOVERY_LOGOUT_EN, 0); 4292 iscsi_session_attr(bidi_chap, ISCSI_PARAM_BIDI_CHAP_EN, 0); 4293 iscsi_session_attr(discovery_auth_optional, 4294 ISCSI_PARAM_DISCOVERY_AUTH_OPTIONAL, 0); 4295 iscsi_session_attr(def_time2wait, ISCSI_PARAM_DEF_TIME2WAIT, 0); 4296 iscsi_session_attr(def_time2retain, ISCSI_PARAM_DEF_TIME2RETAIN, 0); 4297 iscsi_session_attr(isid, ISCSI_PARAM_ISID, 0); 4298 iscsi_session_attr(tsid, ISCSI_PARAM_TSID, 0); 4299 iscsi_session_attr(def_taskmgmt_tmo, ISCSI_PARAM_DEF_TASKMGMT_TMO, 0); 4300 iscsi_session_attr(discovery_parent_idx, ISCSI_PARAM_DISCOVERY_PARENT_IDX, 0); 4301 iscsi_session_attr(discovery_parent_type, ISCSI_PARAM_DISCOVERY_PARENT_TYPE, 0); 4302 4303 static ssize_t 4304 show_priv_session_state(struct device *dev, struct device_attribute *attr, 4305 char *buf) 4306 { 4307 struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent); 4308 return sysfs_emit(buf, "%s\n", iscsi_session_state_name(session->state)); 4309 } 4310 static ISCSI_CLASS_ATTR(priv_sess, state, S_IRUGO, show_priv_session_state, 4311 NULL); 4312 static ssize_t 4313 show_priv_session_creator(struct device *dev, struct device_attribute *attr, 4314 char *buf) 4315 { 4316 struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent); 4317 return sysfs_emit(buf, "%d\n", session->creator); 4318 } 4319 static ISCSI_CLASS_ATTR(priv_sess, creator, S_IRUGO, show_priv_session_creator, 4320 NULL); 4321 static ssize_t 4322 show_priv_session_target_id(struct device *dev, struct device_attribute *attr, 4323 char *buf) 4324 { 4325 struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent); 4326 return sysfs_emit(buf, "%d\n", session->target_id); 4327 } 4328 static ISCSI_CLASS_ATTR(priv_sess, target_id, S_IRUGO, 4329 show_priv_session_target_id, NULL); 4330 4331 #define iscsi_priv_session_attr_show(field, format) \ 4332 static ssize_t \ 4333 show_priv_session_##field(struct device *dev, \ 4334 struct device_attribute *attr, char *buf) \ 4335 { \ 4336 struct iscsi_cls_session *session = \ 4337 iscsi_dev_to_session(dev->parent); \ 4338 if (session->field == -1) \ 4339 return sysfs_emit(buf, "off\n"); \ 4340 return sysfs_emit(buf, format"\n", session->field); \ 4341 } 4342 4343 #define iscsi_priv_session_attr_store(field) \ 4344 static ssize_t \ 4345 store_priv_session_##field(struct device *dev, \ 4346 struct device_attribute *attr, \ 4347 const char *buf, size_t count) \ 4348 { \ 4349 int val; \ 4350 char *cp; \ 4351 struct iscsi_cls_session *session = \ 4352 iscsi_dev_to_session(dev->parent); \ 4353 if ((session->state == ISCSI_SESSION_FREE) || \ 4354 (session->state == ISCSI_SESSION_FAILED)) \ 4355 return -EBUSY; \ 4356 if (strncmp(buf, "off", 3) == 0) { \ 4357 session->field = -1; \ 4358 session->field##_sysfs_override = true; \ 4359 } else { \ 4360 val = simple_strtoul(buf, &cp, 0); \ 4361 if (*cp != '\0' && *cp != '\n') \ 4362 return -EINVAL; \ 4363 session->field = val; \ 4364 session->field##_sysfs_override = true; \ 4365 } \ 4366 return count; \ 4367 } 4368 4369 #define iscsi_priv_session_rw_attr(field, format) \ 4370 iscsi_priv_session_attr_show(field, format) \ 4371 iscsi_priv_session_attr_store(field) \ 4372 static ISCSI_CLASS_ATTR(priv_sess, field, S_IRUGO | S_IWUSR, \ 4373 show_priv_session_##field, \ 4374 store_priv_session_##field) 4375 4376 iscsi_priv_session_rw_attr(recovery_tmo, "%d"); 4377 4378 static struct attribute *iscsi_session_attrs[] = { 4379 &dev_attr_sess_initial_r2t.attr, 4380 &dev_attr_sess_max_outstanding_r2t.attr, 4381 &dev_attr_sess_immediate_data.attr, 4382 &dev_attr_sess_first_burst_len.attr, 4383 &dev_attr_sess_max_burst_len.attr, 4384 &dev_attr_sess_data_pdu_in_order.attr, 4385 &dev_attr_sess_data_seq_in_order.attr, 4386 &dev_attr_sess_erl.attr, 4387 &dev_attr_sess_targetname.attr, 4388 &dev_attr_sess_tpgt.attr, 4389 &dev_attr_sess_password.attr, 4390 &dev_attr_sess_password_in.attr, 4391 &dev_attr_sess_username.attr, 4392 &dev_attr_sess_username_in.attr, 4393 &dev_attr_sess_fast_abort.attr, 4394 &dev_attr_sess_abort_tmo.attr, 4395 &dev_attr_sess_lu_reset_tmo.attr, 4396 &dev_attr_sess_tgt_reset_tmo.attr, 4397 &dev_attr_sess_ifacename.attr, 4398 &dev_attr_sess_initiatorname.attr, 4399 &dev_attr_sess_targetalias.attr, 4400 &dev_attr_sess_boot_root.attr, 4401 &dev_attr_sess_boot_nic.attr, 4402 &dev_attr_sess_boot_target.attr, 4403 &dev_attr_priv_sess_recovery_tmo.attr, 4404 &dev_attr_priv_sess_state.attr, 4405 &dev_attr_priv_sess_creator.attr, 4406 &dev_attr_sess_chap_out_idx.attr, 4407 &dev_attr_sess_chap_in_idx.attr, 4408 &dev_attr_priv_sess_target_id.attr, 4409 &dev_attr_sess_auto_snd_tgt_disable.attr, 4410 &dev_attr_sess_discovery_session.attr, 4411 &dev_attr_sess_portal_type.attr, 4412 &dev_attr_sess_chap_auth.attr, 4413 &dev_attr_sess_discovery_logout.attr, 4414 &dev_attr_sess_bidi_chap.attr, 4415 &dev_attr_sess_discovery_auth_optional.attr, 4416 &dev_attr_sess_def_time2wait.attr, 4417 &dev_attr_sess_def_time2retain.attr, 4418 &dev_attr_sess_isid.attr, 4419 &dev_attr_sess_tsid.attr, 4420 &dev_attr_sess_def_taskmgmt_tmo.attr, 4421 &dev_attr_sess_discovery_parent_idx.attr, 4422 &dev_attr_sess_discovery_parent_type.attr, 4423 NULL, 4424 }; 4425 4426 static umode_t iscsi_session_attr_is_visible(struct kobject *kobj, 4427 struct attribute *attr, int i) 4428 { 4429 struct device *cdev = container_of(kobj, struct device, kobj); 4430 struct iscsi_cls_session *session = transport_class_to_session(cdev); 4431 struct iscsi_transport *t = session->transport; 4432 int param; 4433 4434 if (attr == &dev_attr_sess_initial_r2t.attr) 4435 param = ISCSI_PARAM_INITIAL_R2T_EN; 4436 else if (attr == &dev_attr_sess_max_outstanding_r2t.attr) 4437 param = ISCSI_PARAM_MAX_R2T; 4438 else if (attr == &dev_attr_sess_immediate_data.attr) 4439 param = ISCSI_PARAM_IMM_DATA_EN; 4440 else if (attr == &dev_attr_sess_first_burst_len.attr) 4441 param = ISCSI_PARAM_FIRST_BURST; 4442 else if (attr == &dev_attr_sess_max_burst_len.attr) 4443 param = ISCSI_PARAM_MAX_BURST; 4444 else if (attr == &dev_attr_sess_data_pdu_in_order.attr) 4445 param = ISCSI_PARAM_PDU_INORDER_EN; 4446 else if (attr == &dev_attr_sess_data_seq_in_order.attr) 4447 param = ISCSI_PARAM_DATASEQ_INORDER_EN; 4448 else if (attr == &dev_attr_sess_erl.attr) 4449 param = ISCSI_PARAM_ERL; 4450 else if (attr == &dev_attr_sess_targetname.attr) 4451 param = ISCSI_PARAM_TARGET_NAME; 4452 else if (attr == &dev_attr_sess_tpgt.attr) 4453 param = ISCSI_PARAM_TPGT; 4454 else if (attr == &dev_attr_sess_chap_in_idx.attr) 4455 param = ISCSI_PARAM_CHAP_IN_IDX; 4456 else if (attr == &dev_attr_sess_chap_out_idx.attr) 4457 param = ISCSI_PARAM_CHAP_OUT_IDX; 4458 else if (attr == &dev_attr_sess_password.attr) 4459 param = ISCSI_PARAM_USERNAME; 4460 else if (attr == &dev_attr_sess_password_in.attr) 4461 param = ISCSI_PARAM_USERNAME_IN; 4462 else if (attr == &dev_attr_sess_username.attr) 4463 param = ISCSI_PARAM_PASSWORD; 4464 else if (attr == &dev_attr_sess_username_in.attr) 4465 param = ISCSI_PARAM_PASSWORD_IN; 4466 else if (attr == &dev_attr_sess_fast_abort.attr) 4467 param = ISCSI_PARAM_FAST_ABORT; 4468 else if (attr == &dev_attr_sess_abort_tmo.attr) 4469 param = ISCSI_PARAM_ABORT_TMO; 4470 else if (attr == &dev_attr_sess_lu_reset_tmo.attr) 4471 param = ISCSI_PARAM_LU_RESET_TMO; 4472 else if (attr == &dev_attr_sess_tgt_reset_tmo.attr) 4473 param = ISCSI_PARAM_TGT_RESET_TMO; 4474 else if (attr == &dev_attr_sess_ifacename.attr) 4475 param = ISCSI_PARAM_IFACE_NAME; 4476 else if (attr == &dev_attr_sess_initiatorname.attr) 4477 param = ISCSI_PARAM_INITIATOR_NAME; 4478 else if (attr == &dev_attr_sess_targetalias.attr) 4479 param = ISCSI_PARAM_TARGET_ALIAS; 4480 else if (attr == &dev_attr_sess_boot_root.attr) 4481 param = ISCSI_PARAM_BOOT_ROOT; 4482 else if (attr == &dev_attr_sess_boot_nic.attr) 4483 param = ISCSI_PARAM_BOOT_NIC; 4484 else if (attr == &dev_attr_sess_boot_target.attr) 4485 param = ISCSI_PARAM_BOOT_TARGET; 4486 else if (attr == &dev_attr_sess_auto_snd_tgt_disable.attr) 4487 param = ISCSI_PARAM_AUTO_SND_TGT_DISABLE; 4488 else if (attr == &dev_attr_sess_discovery_session.attr) 4489 param = ISCSI_PARAM_DISCOVERY_SESS; 4490 else if (attr == &dev_attr_sess_portal_type.attr) 4491 param = ISCSI_PARAM_PORTAL_TYPE; 4492 else if (attr == &dev_attr_sess_chap_auth.attr) 4493 param = ISCSI_PARAM_CHAP_AUTH_EN; 4494 else if (attr == &dev_attr_sess_discovery_logout.attr) 4495 param = ISCSI_PARAM_DISCOVERY_LOGOUT_EN; 4496 else if (attr == &dev_attr_sess_bidi_chap.attr) 4497 param = ISCSI_PARAM_BIDI_CHAP_EN; 4498 else if (attr == &dev_attr_sess_discovery_auth_optional.attr) 4499 param = ISCSI_PARAM_DISCOVERY_AUTH_OPTIONAL; 4500 else if (attr == &dev_attr_sess_def_time2wait.attr) 4501 param = ISCSI_PARAM_DEF_TIME2WAIT; 4502 else if (attr == &dev_attr_sess_def_time2retain.attr) 4503 param = ISCSI_PARAM_DEF_TIME2RETAIN; 4504 else if (attr == &dev_attr_sess_isid.attr) 4505 param = ISCSI_PARAM_ISID; 4506 else if (attr == &dev_attr_sess_tsid.attr) 4507 param = ISCSI_PARAM_TSID; 4508 else if (attr == &dev_attr_sess_def_taskmgmt_tmo.attr) 4509 param = ISCSI_PARAM_DEF_TASKMGMT_TMO; 4510 else if (attr == &dev_attr_sess_discovery_parent_idx.attr) 4511 param = ISCSI_PARAM_DISCOVERY_PARENT_IDX; 4512 else if (attr == &dev_attr_sess_discovery_parent_type.attr) 4513 param = ISCSI_PARAM_DISCOVERY_PARENT_TYPE; 4514 else if (attr == &dev_attr_priv_sess_recovery_tmo.attr) 4515 return S_IRUGO | S_IWUSR; 4516 else if (attr == &dev_attr_priv_sess_state.attr) 4517 return S_IRUGO; 4518 else if (attr == &dev_attr_priv_sess_creator.attr) 4519 return S_IRUGO; 4520 else if (attr == &dev_attr_priv_sess_target_id.attr) 4521 return S_IRUGO; 4522 else { 4523 WARN_ONCE(1, "Invalid session attr"); 4524 return 0; 4525 } 4526 4527 return t->attr_is_visible(ISCSI_PARAM, param); 4528 } 4529 4530 static struct attribute_group iscsi_session_group = { 4531 .attrs = iscsi_session_attrs, 4532 .is_visible = iscsi_session_attr_is_visible, 4533 }; 4534 4535 /* 4536 * iSCSI host attrs 4537 */ 4538 #define iscsi_host_attr_show(param) \ 4539 static ssize_t \ 4540 show_host_param_##param(struct device *dev, \ 4541 struct device_attribute *attr, char *buf) \ 4542 { \ 4543 struct Scsi_Host *shost = transport_class_to_shost(dev); \ 4544 struct iscsi_internal *priv = to_iscsi_internal(shost->transportt); \ 4545 return priv->iscsi_transport->get_host_param(shost, param, buf); \ 4546 } 4547 4548 #define iscsi_host_attr(field, param) \ 4549 iscsi_host_attr_show(param) \ 4550 static ISCSI_CLASS_ATTR(host, field, S_IRUGO, show_host_param_##param, \ 4551 NULL); 4552 4553 iscsi_host_attr(netdev, ISCSI_HOST_PARAM_NETDEV_NAME); 4554 iscsi_host_attr(hwaddress, ISCSI_HOST_PARAM_HWADDRESS); 4555 iscsi_host_attr(ipaddress, ISCSI_HOST_PARAM_IPADDRESS); 4556 iscsi_host_attr(initiatorname, ISCSI_HOST_PARAM_INITIATOR_NAME); 4557 iscsi_host_attr(port_state, ISCSI_HOST_PARAM_PORT_STATE); 4558 iscsi_host_attr(port_speed, ISCSI_HOST_PARAM_PORT_SPEED); 4559 4560 static struct attribute *iscsi_host_attrs[] = { 4561 &dev_attr_host_netdev.attr, 4562 &dev_attr_host_hwaddress.attr, 4563 &dev_attr_host_ipaddress.attr, 4564 &dev_attr_host_initiatorname.attr, 4565 &dev_attr_host_port_state.attr, 4566 &dev_attr_host_port_speed.attr, 4567 NULL, 4568 }; 4569 4570 static umode_t iscsi_host_attr_is_visible(struct kobject *kobj, 4571 struct attribute *attr, int i) 4572 { 4573 struct device *cdev = container_of(kobj, struct device, kobj); 4574 struct Scsi_Host *shost = transport_class_to_shost(cdev); 4575 struct iscsi_internal *priv = to_iscsi_internal(shost->transportt); 4576 int param; 4577 4578 if (attr == &dev_attr_host_netdev.attr) 4579 param = ISCSI_HOST_PARAM_NETDEV_NAME; 4580 else if (attr == &dev_attr_host_hwaddress.attr) 4581 param = ISCSI_HOST_PARAM_HWADDRESS; 4582 else if (attr == &dev_attr_host_ipaddress.attr) 4583 param = ISCSI_HOST_PARAM_IPADDRESS; 4584 else if (attr == &dev_attr_host_initiatorname.attr) 4585 param = ISCSI_HOST_PARAM_INITIATOR_NAME; 4586 else if (attr == &dev_attr_host_port_state.attr) 4587 param = ISCSI_HOST_PARAM_PORT_STATE; 4588 else if (attr == &dev_attr_host_port_speed.attr) 4589 param = ISCSI_HOST_PARAM_PORT_SPEED; 4590 else { 4591 WARN_ONCE(1, "Invalid host attr"); 4592 return 0; 4593 } 4594 4595 return priv->iscsi_transport->attr_is_visible(ISCSI_HOST_PARAM, param); 4596 } 4597 4598 static struct attribute_group iscsi_host_group = { 4599 .attrs = iscsi_host_attrs, 4600 .is_visible = iscsi_host_attr_is_visible, 4601 }; 4602 4603 /* convert iscsi_port_speed values to ascii string name */ 4604 static const struct { 4605 enum iscsi_port_speed value; 4606 char *name; 4607 } iscsi_port_speed_names[] = { 4608 {ISCSI_PORT_SPEED_UNKNOWN, "Unknown" }, 4609 {ISCSI_PORT_SPEED_10MBPS, "10 Mbps" }, 4610 {ISCSI_PORT_SPEED_100MBPS, "100 Mbps" }, 4611 {ISCSI_PORT_SPEED_1GBPS, "1 Gbps" }, 4612 {ISCSI_PORT_SPEED_10GBPS, "10 Gbps" }, 4613 {ISCSI_PORT_SPEED_25GBPS, "25 Gbps" }, 4614 {ISCSI_PORT_SPEED_40GBPS, "40 Gbps" }, 4615 }; 4616 4617 char *iscsi_get_port_speed_name(struct Scsi_Host *shost) 4618 { 4619 int i; 4620 char *speed = "Unknown!"; 4621 struct iscsi_cls_host *ihost = shost->shost_data; 4622 uint32_t port_speed = ihost->port_speed; 4623 4624 for (i = 0; i < ARRAY_SIZE(iscsi_port_speed_names); i++) { 4625 if (iscsi_port_speed_names[i].value & port_speed) { 4626 speed = iscsi_port_speed_names[i].name; 4627 break; 4628 } 4629 } 4630 return speed; 4631 } 4632 EXPORT_SYMBOL_GPL(iscsi_get_port_speed_name); 4633 4634 /* convert iscsi_port_state values to ascii string name */ 4635 static const struct { 4636 enum iscsi_port_state value; 4637 char *name; 4638 } iscsi_port_state_names[] = { 4639 {ISCSI_PORT_STATE_DOWN, "LINK DOWN" }, 4640 {ISCSI_PORT_STATE_UP, "LINK UP" }, 4641 }; 4642 4643 char *iscsi_get_port_state_name(struct Scsi_Host *shost) 4644 { 4645 int i; 4646 char *state = "Unknown!"; 4647 struct iscsi_cls_host *ihost = shost->shost_data; 4648 uint32_t port_state = ihost->port_state; 4649 4650 for (i = 0; i < ARRAY_SIZE(iscsi_port_state_names); i++) { 4651 if (iscsi_port_state_names[i].value & port_state) { 4652 state = iscsi_port_state_names[i].name; 4653 break; 4654 } 4655 } 4656 return state; 4657 } 4658 EXPORT_SYMBOL_GPL(iscsi_get_port_state_name); 4659 4660 static int iscsi_session_match(struct attribute_container *cont, 4661 struct device *dev) 4662 { 4663 struct iscsi_cls_session *session; 4664 struct Scsi_Host *shost; 4665 struct iscsi_internal *priv; 4666 4667 if (!iscsi_is_session_dev(dev)) 4668 return 0; 4669 4670 session = iscsi_dev_to_session(dev); 4671 shost = iscsi_session_to_shost(session); 4672 if (!shost->transportt) 4673 return 0; 4674 4675 priv = to_iscsi_internal(shost->transportt); 4676 if (priv->session_cont.ac.class != &iscsi_session_class.class) 4677 return 0; 4678 4679 return &priv->session_cont.ac == cont; 4680 } 4681 4682 static int iscsi_conn_match(struct attribute_container *cont, 4683 struct device *dev) 4684 { 4685 struct iscsi_cls_session *session; 4686 struct iscsi_cls_conn *conn; 4687 struct Scsi_Host *shost; 4688 struct iscsi_internal *priv; 4689 4690 if (!iscsi_is_conn_dev(dev)) 4691 return 0; 4692 4693 conn = iscsi_dev_to_conn(dev); 4694 session = iscsi_dev_to_session(conn->dev.parent); 4695 shost = iscsi_session_to_shost(session); 4696 4697 if (!shost->transportt) 4698 return 0; 4699 4700 priv = to_iscsi_internal(shost->transportt); 4701 if (priv->conn_cont.ac.class != &iscsi_connection_class.class) 4702 return 0; 4703 4704 return &priv->conn_cont.ac == cont; 4705 } 4706 4707 static int iscsi_host_match(struct attribute_container *cont, 4708 struct device *dev) 4709 { 4710 struct Scsi_Host *shost; 4711 struct iscsi_internal *priv; 4712 4713 if (!scsi_is_host_device(dev)) 4714 return 0; 4715 4716 shost = dev_to_shost(dev); 4717 if (!shost->transportt || 4718 shost->transportt->host_attrs.ac.class != &iscsi_host_class.class) 4719 return 0; 4720 4721 priv = to_iscsi_internal(shost->transportt); 4722 return &priv->t.host_attrs.ac == cont; 4723 } 4724 4725 struct scsi_transport_template * 4726 iscsi_register_transport(struct iscsi_transport *tt) 4727 { 4728 struct iscsi_internal *priv; 4729 unsigned long flags; 4730 int err; 4731 4732 BUG_ON(!tt); 4733 WARN_ON(tt->ep_disconnect && !tt->unbind_conn); 4734 4735 priv = iscsi_if_transport_lookup(tt); 4736 if (priv) 4737 return NULL; 4738 4739 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 4740 if (!priv) 4741 return NULL; 4742 INIT_LIST_HEAD(&priv->list); 4743 priv->iscsi_transport = tt; 4744 priv->t.user_scan = iscsi_user_scan; 4745 priv->t.create_work_queue = 1; 4746 4747 priv->dev.class = &iscsi_transport_class; 4748 dev_set_name(&priv->dev, "%s", tt->name); 4749 err = device_register(&priv->dev); 4750 if (err) 4751 goto free_priv; 4752 4753 err = sysfs_create_group(&priv->dev.kobj, &iscsi_transport_group); 4754 if (err) 4755 goto unregister_dev; 4756 4757 /* host parameters */ 4758 priv->t.host_attrs.ac.class = &iscsi_host_class.class; 4759 priv->t.host_attrs.ac.match = iscsi_host_match; 4760 priv->t.host_attrs.ac.grp = &iscsi_host_group; 4761 priv->t.host_size = sizeof(struct iscsi_cls_host); 4762 transport_container_register(&priv->t.host_attrs); 4763 4764 /* connection parameters */ 4765 priv->conn_cont.ac.class = &iscsi_connection_class.class; 4766 priv->conn_cont.ac.match = iscsi_conn_match; 4767 priv->conn_cont.ac.grp = &iscsi_conn_group; 4768 transport_container_register(&priv->conn_cont); 4769 4770 /* session parameters */ 4771 priv->session_cont.ac.class = &iscsi_session_class.class; 4772 priv->session_cont.ac.match = iscsi_session_match; 4773 priv->session_cont.ac.grp = &iscsi_session_group; 4774 transport_container_register(&priv->session_cont); 4775 4776 spin_lock_irqsave(&iscsi_transport_lock, flags); 4777 list_add(&priv->list, &iscsi_transports); 4778 spin_unlock_irqrestore(&iscsi_transport_lock, flags); 4779 4780 printk(KERN_NOTICE "iscsi: registered transport (%s)\n", tt->name); 4781 return &priv->t; 4782 4783 unregister_dev: 4784 device_unregister(&priv->dev); 4785 return NULL; 4786 free_priv: 4787 kfree(priv); 4788 return NULL; 4789 } 4790 EXPORT_SYMBOL_GPL(iscsi_register_transport); 4791 4792 int iscsi_unregister_transport(struct iscsi_transport *tt) 4793 { 4794 struct iscsi_internal *priv; 4795 unsigned long flags; 4796 4797 BUG_ON(!tt); 4798 4799 mutex_lock(&rx_queue_mutex); 4800 4801 priv = iscsi_if_transport_lookup(tt); 4802 BUG_ON (!priv); 4803 4804 spin_lock_irqsave(&iscsi_transport_lock, flags); 4805 list_del(&priv->list); 4806 spin_unlock_irqrestore(&iscsi_transport_lock, flags); 4807 4808 transport_container_unregister(&priv->conn_cont); 4809 transport_container_unregister(&priv->session_cont); 4810 transport_container_unregister(&priv->t.host_attrs); 4811 4812 sysfs_remove_group(&priv->dev.kobj, &iscsi_transport_group); 4813 device_unregister(&priv->dev); 4814 mutex_unlock(&rx_queue_mutex); 4815 4816 return 0; 4817 } 4818 EXPORT_SYMBOL_GPL(iscsi_unregister_transport); 4819 4820 void iscsi_dbg_trace(void (*trace)(struct device *dev, struct va_format *), 4821 struct device *dev, const char *fmt, ...) 4822 { 4823 struct va_format vaf; 4824 va_list args; 4825 4826 va_start(args, fmt); 4827 vaf.fmt = fmt; 4828 vaf.va = &args; 4829 trace(dev, &vaf); 4830 va_end(args); 4831 } 4832 EXPORT_SYMBOL_GPL(iscsi_dbg_trace); 4833 4834 static __init int iscsi_transport_init(void) 4835 { 4836 int err; 4837 struct netlink_kernel_cfg cfg = { 4838 .groups = 1, 4839 .input = iscsi_if_rx, 4840 }; 4841 printk(KERN_INFO "Loading iSCSI transport class v%s.\n", 4842 ISCSI_TRANSPORT_VERSION); 4843 4844 atomic_set(&iscsi_session_nr, 0); 4845 4846 err = class_register(&iscsi_transport_class); 4847 if (err) 4848 return err; 4849 4850 err = class_register(&iscsi_endpoint_class); 4851 if (err) 4852 goto unregister_transport_class; 4853 4854 err = class_register(&iscsi_iface_class); 4855 if (err) 4856 goto unregister_endpoint_class; 4857 4858 err = transport_class_register(&iscsi_host_class); 4859 if (err) 4860 goto unregister_iface_class; 4861 4862 err = transport_class_register(&iscsi_connection_class); 4863 if (err) 4864 goto unregister_host_class; 4865 4866 err = transport_class_register(&iscsi_session_class); 4867 if (err) 4868 goto unregister_conn_class; 4869 4870 err = bus_register(&iscsi_flashnode_bus); 4871 if (err) 4872 goto unregister_session_class; 4873 4874 nls = netlink_kernel_create(&init_net, NETLINK_ISCSI, &cfg); 4875 if (!nls) { 4876 err = -ENOBUFS; 4877 goto unregister_flashnode_bus; 4878 } 4879 4880 iscsi_eh_timer_workq = alloc_workqueue("%s", 4881 WQ_SYSFS | __WQ_LEGACY | WQ_MEM_RECLAIM | WQ_UNBOUND, 4882 1, "iscsi_eh"); 4883 if (!iscsi_eh_timer_workq) { 4884 err = -ENOMEM; 4885 goto release_nls; 4886 } 4887 4888 iscsi_conn_cleanup_workq = alloc_workqueue("%s", 4889 WQ_SYSFS | WQ_MEM_RECLAIM | WQ_UNBOUND, 0, 4890 "iscsi_conn_cleanup"); 4891 if (!iscsi_conn_cleanup_workq) { 4892 err = -ENOMEM; 4893 goto destroy_wq; 4894 } 4895 4896 return 0; 4897 4898 destroy_wq: 4899 destroy_workqueue(iscsi_eh_timer_workq); 4900 release_nls: 4901 netlink_kernel_release(nls); 4902 unregister_flashnode_bus: 4903 bus_unregister(&iscsi_flashnode_bus); 4904 unregister_session_class: 4905 transport_class_unregister(&iscsi_session_class); 4906 unregister_conn_class: 4907 transport_class_unregister(&iscsi_connection_class); 4908 unregister_host_class: 4909 transport_class_unregister(&iscsi_host_class); 4910 unregister_iface_class: 4911 class_unregister(&iscsi_iface_class); 4912 unregister_endpoint_class: 4913 class_unregister(&iscsi_endpoint_class); 4914 unregister_transport_class: 4915 class_unregister(&iscsi_transport_class); 4916 return err; 4917 } 4918 4919 static void __exit iscsi_transport_exit(void) 4920 { 4921 destroy_workqueue(iscsi_conn_cleanup_workq); 4922 destroy_workqueue(iscsi_eh_timer_workq); 4923 netlink_kernel_release(nls); 4924 bus_unregister(&iscsi_flashnode_bus); 4925 transport_class_unregister(&iscsi_connection_class); 4926 transport_class_unregister(&iscsi_session_class); 4927 transport_class_unregister(&iscsi_host_class); 4928 class_unregister(&iscsi_endpoint_class); 4929 class_unregister(&iscsi_iface_class); 4930 class_unregister(&iscsi_transport_class); 4931 } 4932 4933 module_init(iscsi_transport_init); 4934 module_exit(iscsi_transport_exit); 4935 4936 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu>, " 4937 "Dmitry Yusupov <dmitry_yus@yahoo.com>, " 4938 "Alex Aizman <itn780@yahoo.com>"); 4939 MODULE_DESCRIPTION("iSCSI Transport Interface"); 4940 MODULE_LICENSE("GPL"); 4941 MODULE_VERSION(ISCSI_TRANSPORT_VERSION); 4942 MODULE_ALIAS_NET_PF_PROTO(PF_NETLINK, NETLINK_ISCSI); 4943