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