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