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