xref: /openbmc/linux/drivers/s390/scsi/zfcp_fc.c (revision 612a462a)
1 /*
2  * zfcp device driver
3  *
4  * Fibre Channel related functions for the zfcp device driver.
5  *
6  * Copyright IBM Corp. 2008, 2017
7  */
8 
9 #define KMSG_COMPONENT "zfcp"
10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
11 
12 #include <linux/types.h>
13 #include <linux/slab.h>
14 #include <linux/utsname.h>
15 #include <linux/random.h>
16 #include <linux/bsg-lib.h>
17 #include <scsi/fc/fc_els.h>
18 #include <scsi/libfc.h>
19 #include "zfcp_ext.h"
20 #include "zfcp_fc.h"
21 
22 struct kmem_cache *zfcp_fc_req_cache;
23 
24 static u32 zfcp_fc_rscn_range_mask[] = {
25 	[ELS_ADDR_FMT_PORT]		= 0xFFFFFF,
26 	[ELS_ADDR_FMT_AREA]		= 0xFFFF00,
27 	[ELS_ADDR_FMT_DOM]		= 0xFF0000,
28 	[ELS_ADDR_FMT_FAB]		= 0x000000,
29 };
30 
31 static bool no_auto_port_rescan;
32 module_param(no_auto_port_rescan, bool, 0600);
33 MODULE_PARM_DESC(no_auto_port_rescan,
34 		 "no automatic port_rescan (default off)");
35 
36 static unsigned int port_scan_backoff = 500;
37 module_param(port_scan_backoff, uint, 0600);
38 MODULE_PARM_DESC(port_scan_backoff,
39 	"upper limit of port scan random backoff in msecs (default 500)");
40 
41 static unsigned int port_scan_ratelimit = 60000;
42 module_param(port_scan_ratelimit, uint, 0600);
43 MODULE_PARM_DESC(port_scan_ratelimit,
44 	"minimum interval between port scans in msecs (default 60000)");
45 
46 unsigned int zfcp_fc_port_scan_backoff(void)
47 {
48 	if (!port_scan_backoff)
49 		return 0;
50 	return get_random_int() % port_scan_backoff;
51 }
52 
53 static void zfcp_fc_port_scan_time(struct zfcp_adapter *adapter)
54 {
55 	unsigned long interval = msecs_to_jiffies(port_scan_ratelimit);
56 	unsigned long backoff = msecs_to_jiffies(zfcp_fc_port_scan_backoff());
57 
58 	adapter->next_port_scan = jiffies + interval + backoff;
59 }
60 
61 static void zfcp_fc_port_scan(struct zfcp_adapter *adapter)
62 {
63 	unsigned long now = jiffies;
64 	unsigned long next = adapter->next_port_scan;
65 	unsigned long delay = 0, max;
66 
67 	/* delay only needed within waiting period */
68 	if (time_before(now, next)) {
69 		delay = next - now;
70 		/* paranoia: never ever delay scans longer than specified */
71 		max = msecs_to_jiffies(port_scan_ratelimit + port_scan_backoff);
72 		delay = min(delay, max);
73 	}
74 
75 	queue_delayed_work(adapter->work_queue, &adapter->scan_work, delay);
76 }
77 
78 void zfcp_fc_conditional_port_scan(struct zfcp_adapter *adapter)
79 {
80 	if (no_auto_port_rescan)
81 		return;
82 
83 	zfcp_fc_port_scan(adapter);
84 }
85 
86 void zfcp_fc_inverse_conditional_port_scan(struct zfcp_adapter *adapter)
87 {
88 	if (!no_auto_port_rescan)
89 		return;
90 
91 	zfcp_fc_port_scan(adapter);
92 }
93 
94 /**
95  * zfcp_fc_post_event - post event to userspace via fc_transport
96  * @work: work struct with enqueued events
97  */
98 void zfcp_fc_post_event(struct work_struct *work)
99 {
100 	struct zfcp_fc_event *event = NULL, *tmp = NULL;
101 	LIST_HEAD(tmp_lh);
102 	struct zfcp_fc_events *events = container_of(work,
103 					struct zfcp_fc_events, work);
104 	struct zfcp_adapter *adapter = container_of(events, struct zfcp_adapter,
105 						events);
106 
107 	spin_lock_bh(&events->list_lock);
108 	list_splice_init(&events->list, &tmp_lh);
109 	spin_unlock_bh(&events->list_lock);
110 
111 	list_for_each_entry_safe(event, tmp, &tmp_lh, list) {
112 		fc_host_post_event(adapter->scsi_host, fc_get_event_number(),
113 				event->code, event->data);
114 		list_del(&event->list);
115 		kfree(event);
116 	}
117 
118 }
119 
120 /**
121  * zfcp_fc_enqueue_event - safely enqueue FC HBA API event from irq context
122  * @adapter: The adapter where to enqueue the event
123  * @event_code: The event code (as defined in fc_host_event_code in
124  *		scsi_transport_fc.h)
125  * @event_data: The event data (e.g. n_port page in case of els)
126  */
127 void zfcp_fc_enqueue_event(struct zfcp_adapter *adapter,
128 			enum fc_host_event_code event_code, u32 event_data)
129 {
130 	struct zfcp_fc_event *event;
131 
132 	event = kmalloc(sizeof(struct zfcp_fc_event), GFP_ATOMIC);
133 	if (!event)
134 		return;
135 
136 	event->code = event_code;
137 	event->data = event_data;
138 
139 	spin_lock(&adapter->events.list_lock);
140 	list_add_tail(&event->list, &adapter->events.list);
141 	spin_unlock(&adapter->events.list_lock);
142 
143 	queue_work(adapter->work_queue, &adapter->events.work);
144 }
145 
146 static int zfcp_fc_wka_port_get(struct zfcp_fc_wka_port *wka_port)
147 {
148 	if (mutex_lock_interruptible(&wka_port->mutex))
149 		return -ERESTARTSYS;
150 
151 	if (wka_port->status == ZFCP_FC_WKA_PORT_OFFLINE ||
152 	    wka_port->status == ZFCP_FC_WKA_PORT_CLOSING) {
153 		wka_port->status = ZFCP_FC_WKA_PORT_OPENING;
154 		if (zfcp_fsf_open_wka_port(wka_port))
155 			wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
156 	}
157 
158 	mutex_unlock(&wka_port->mutex);
159 
160 	wait_event(wka_port->completion_wq,
161 		   wka_port->status == ZFCP_FC_WKA_PORT_ONLINE ||
162 		   wka_port->status == ZFCP_FC_WKA_PORT_OFFLINE);
163 
164 	if (wka_port->status == ZFCP_FC_WKA_PORT_ONLINE) {
165 		atomic_inc(&wka_port->refcount);
166 		return 0;
167 	}
168 	return -EIO;
169 }
170 
171 static void zfcp_fc_wka_port_offline(struct work_struct *work)
172 {
173 	struct delayed_work *dw = to_delayed_work(work);
174 	struct zfcp_fc_wka_port *wka_port =
175 			container_of(dw, struct zfcp_fc_wka_port, work);
176 
177 	mutex_lock(&wka_port->mutex);
178 	if ((atomic_read(&wka_port->refcount) != 0) ||
179 	    (wka_port->status != ZFCP_FC_WKA_PORT_ONLINE))
180 		goto out;
181 
182 	wka_port->status = ZFCP_FC_WKA_PORT_CLOSING;
183 	if (zfcp_fsf_close_wka_port(wka_port)) {
184 		wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
185 		wake_up(&wka_port->completion_wq);
186 	}
187 out:
188 	mutex_unlock(&wka_port->mutex);
189 }
190 
191 static void zfcp_fc_wka_port_put(struct zfcp_fc_wka_port *wka_port)
192 {
193 	if (atomic_dec_return(&wka_port->refcount) != 0)
194 		return;
195 	/* wait 10 milliseconds, other reqs might pop in */
196 	schedule_delayed_work(&wka_port->work, HZ / 100);
197 }
198 
199 static void zfcp_fc_wka_port_init(struct zfcp_fc_wka_port *wka_port, u32 d_id,
200 				  struct zfcp_adapter *adapter)
201 {
202 	init_waitqueue_head(&wka_port->completion_wq);
203 
204 	wka_port->adapter = adapter;
205 	wka_port->d_id = d_id;
206 
207 	wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
208 	atomic_set(&wka_port->refcount, 0);
209 	mutex_init(&wka_port->mutex);
210 	INIT_DELAYED_WORK(&wka_port->work, zfcp_fc_wka_port_offline);
211 }
212 
213 static void zfcp_fc_wka_port_force_offline(struct zfcp_fc_wka_port *wka)
214 {
215 	cancel_delayed_work_sync(&wka->work);
216 	mutex_lock(&wka->mutex);
217 	wka->status = ZFCP_FC_WKA_PORT_OFFLINE;
218 	mutex_unlock(&wka->mutex);
219 }
220 
221 void zfcp_fc_wka_ports_force_offline(struct zfcp_fc_wka_ports *gs)
222 {
223 	if (!gs)
224 		return;
225 	zfcp_fc_wka_port_force_offline(&gs->ms);
226 	zfcp_fc_wka_port_force_offline(&gs->ts);
227 	zfcp_fc_wka_port_force_offline(&gs->ds);
228 	zfcp_fc_wka_port_force_offline(&gs->as);
229 }
230 
231 static void _zfcp_fc_incoming_rscn(struct zfcp_fsf_req *fsf_req, u32 range,
232 				   struct fc_els_rscn_page *page)
233 {
234 	unsigned long flags;
235 	struct zfcp_adapter *adapter = fsf_req->adapter;
236 	struct zfcp_port *port;
237 
238 	read_lock_irqsave(&adapter->port_list_lock, flags);
239 	list_for_each_entry(port, &adapter->port_list, list) {
240 		if ((port->d_id & range) == (ntoh24(page->rscn_fid) & range))
241 			zfcp_fc_test_link(port);
242 		if (!port->d_id)
243 			zfcp_erp_port_reopen(port,
244 					     ZFCP_STATUS_COMMON_ERP_FAILED,
245 					     "fcrscn1");
246 	}
247 	read_unlock_irqrestore(&adapter->port_list_lock, flags);
248 }
249 
250 static void zfcp_fc_incoming_rscn(struct zfcp_fsf_req *fsf_req)
251 {
252 	struct fsf_status_read_buffer *status_buffer = (void *)fsf_req->data;
253 	struct fc_els_rscn *head;
254 	struct fc_els_rscn_page *page;
255 	u16 i;
256 	u16 no_entries;
257 	unsigned int afmt;
258 
259 	head = (struct fc_els_rscn *) status_buffer->payload.data;
260 	page = (struct fc_els_rscn_page *) head;
261 
262 	/* see FC-FS */
263 	no_entries = be16_to_cpu(head->rscn_plen) /
264 		sizeof(struct fc_els_rscn_page);
265 
266 	for (i = 1; i < no_entries; i++) {
267 		/* skip head and start with 1st element */
268 		page++;
269 		afmt = page->rscn_page_flags & ELS_RSCN_ADDR_FMT_MASK;
270 		_zfcp_fc_incoming_rscn(fsf_req, zfcp_fc_rscn_range_mask[afmt],
271 				       page);
272 		zfcp_fc_enqueue_event(fsf_req->adapter, FCH_EVT_RSCN,
273 				      *(u32 *)page);
274 	}
275 	zfcp_fc_conditional_port_scan(fsf_req->adapter);
276 }
277 
278 static void zfcp_fc_incoming_wwpn(struct zfcp_fsf_req *req, u64 wwpn)
279 {
280 	unsigned long flags;
281 	struct zfcp_adapter *adapter = req->adapter;
282 	struct zfcp_port *port;
283 
284 	read_lock_irqsave(&adapter->port_list_lock, flags);
285 	list_for_each_entry(port, &adapter->port_list, list)
286 		if (port->wwpn == wwpn) {
287 			zfcp_erp_port_forced_reopen(port, 0, "fciwwp1");
288 			break;
289 		}
290 	read_unlock_irqrestore(&adapter->port_list_lock, flags);
291 }
292 
293 static void zfcp_fc_incoming_plogi(struct zfcp_fsf_req *req)
294 {
295 	struct fsf_status_read_buffer *status_buffer;
296 	struct fc_els_flogi *plogi;
297 
298 	status_buffer = (struct fsf_status_read_buffer *) req->data;
299 	plogi = (struct fc_els_flogi *) status_buffer->payload.data;
300 	zfcp_fc_incoming_wwpn(req, be64_to_cpu(plogi->fl_wwpn));
301 }
302 
303 static void zfcp_fc_incoming_logo(struct zfcp_fsf_req *req)
304 {
305 	struct fsf_status_read_buffer *status_buffer =
306 		(struct fsf_status_read_buffer *)req->data;
307 	struct fc_els_logo *logo =
308 		(struct fc_els_logo *) status_buffer->payload.data;
309 
310 	zfcp_fc_incoming_wwpn(req, be64_to_cpu(logo->fl_n_port_wwn));
311 }
312 
313 /**
314  * zfcp_fc_incoming_els - handle incoming ELS
315  * @fsf_req - request which contains incoming ELS
316  */
317 void zfcp_fc_incoming_els(struct zfcp_fsf_req *fsf_req)
318 {
319 	struct fsf_status_read_buffer *status_buffer =
320 		(struct fsf_status_read_buffer *) fsf_req->data;
321 	unsigned int els_type = status_buffer->payload.data[0];
322 
323 	zfcp_dbf_san_in_els("fciels1", fsf_req);
324 	if (els_type == ELS_PLOGI)
325 		zfcp_fc_incoming_plogi(fsf_req);
326 	else if (els_type == ELS_LOGO)
327 		zfcp_fc_incoming_logo(fsf_req);
328 	else if (els_type == ELS_RSCN)
329 		zfcp_fc_incoming_rscn(fsf_req);
330 }
331 
332 static void zfcp_fc_ns_gid_pn_eval(struct zfcp_fc_req *fc_req)
333 {
334 	struct zfcp_fsf_ct_els *ct_els = &fc_req->ct_els;
335 	struct zfcp_fc_gid_pn_rsp *gid_pn_rsp = &fc_req->u.gid_pn.rsp;
336 
337 	if (ct_els->status)
338 		return;
339 	if (gid_pn_rsp->ct_hdr.ct_cmd != cpu_to_be16(FC_FS_ACC))
340 		return;
341 
342 	/* looks like a valid d_id */
343 	ct_els->port->d_id = ntoh24(gid_pn_rsp->gid_pn.fp_fid);
344 }
345 
346 static void zfcp_fc_complete(void *data)
347 {
348 	complete(data);
349 }
350 
351 static void zfcp_fc_ct_ns_init(struct fc_ct_hdr *ct_hdr, u16 cmd, u16 mr_size)
352 {
353 	ct_hdr->ct_rev = FC_CT_REV;
354 	ct_hdr->ct_fs_type = FC_FST_DIR;
355 	ct_hdr->ct_fs_subtype = FC_NS_SUBTYPE;
356 	ct_hdr->ct_cmd = cpu_to_be16(cmd);
357 	ct_hdr->ct_mr_size = cpu_to_be16(mr_size / 4);
358 }
359 
360 static int zfcp_fc_ns_gid_pn_request(struct zfcp_port *port,
361 				     struct zfcp_fc_req *fc_req)
362 {
363 	struct zfcp_adapter *adapter = port->adapter;
364 	DECLARE_COMPLETION_ONSTACK(completion);
365 	struct zfcp_fc_gid_pn_req *gid_pn_req = &fc_req->u.gid_pn.req;
366 	struct zfcp_fc_gid_pn_rsp *gid_pn_rsp = &fc_req->u.gid_pn.rsp;
367 	int ret;
368 
369 	/* setup parameters for send generic command */
370 	fc_req->ct_els.port = port;
371 	fc_req->ct_els.handler = zfcp_fc_complete;
372 	fc_req->ct_els.handler_data = &completion;
373 	fc_req->ct_els.req = &fc_req->sg_req;
374 	fc_req->ct_els.resp = &fc_req->sg_rsp;
375 	sg_init_one(&fc_req->sg_req, gid_pn_req, sizeof(*gid_pn_req));
376 	sg_init_one(&fc_req->sg_rsp, gid_pn_rsp, sizeof(*gid_pn_rsp));
377 
378 	zfcp_fc_ct_ns_init(&gid_pn_req->ct_hdr,
379 			   FC_NS_GID_PN, ZFCP_FC_CT_SIZE_PAGE);
380 	gid_pn_req->gid_pn.fn_wwpn = cpu_to_be64(port->wwpn);
381 
382 	ret = zfcp_fsf_send_ct(&adapter->gs->ds, &fc_req->ct_els,
383 			       adapter->pool.gid_pn_req,
384 			       ZFCP_FC_CTELS_TMO);
385 	if (!ret) {
386 		wait_for_completion(&completion);
387 		zfcp_fc_ns_gid_pn_eval(fc_req);
388 	}
389 	return ret;
390 }
391 
392 /**
393  * zfcp_fc_ns_gid_pn - initiate GID_PN nameserver request
394  * @port: port where GID_PN request is needed
395  * return: -ENOMEM on error, 0 otherwise
396  */
397 static int zfcp_fc_ns_gid_pn(struct zfcp_port *port)
398 {
399 	int ret;
400 	struct zfcp_fc_req *fc_req;
401 	struct zfcp_adapter *adapter = port->adapter;
402 
403 	fc_req = mempool_alloc(adapter->pool.gid_pn, GFP_ATOMIC);
404 	if (!fc_req)
405 		return -ENOMEM;
406 
407 	memset(fc_req, 0, sizeof(*fc_req));
408 
409 	ret = zfcp_fc_wka_port_get(&adapter->gs->ds);
410 	if (ret)
411 		goto out;
412 
413 	ret = zfcp_fc_ns_gid_pn_request(port, fc_req);
414 
415 	zfcp_fc_wka_port_put(&adapter->gs->ds);
416 out:
417 	mempool_free(fc_req, adapter->pool.gid_pn);
418 	return ret;
419 }
420 
421 void zfcp_fc_port_did_lookup(struct work_struct *work)
422 {
423 	int ret;
424 	struct zfcp_port *port = container_of(work, struct zfcp_port,
425 					      gid_pn_work);
426 
427 	ret = zfcp_fc_ns_gid_pn(port);
428 	if (ret) {
429 		/* could not issue gid_pn for some reason */
430 		zfcp_erp_adapter_reopen(port->adapter, 0, "fcgpn_1");
431 		goto out;
432 	}
433 
434 	if (!port->d_id) {
435 		zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ERP_FAILED);
436 		goto out;
437 	}
438 
439 	zfcp_erp_port_reopen(port, 0, "fcgpn_3");
440 out:
441 	put_device(&port->dev);
442 }
443 
444 /**
445  * zfcp_fc_trigger_did_lookup - trigger the d_id lookup using a GID_PN request
446  * @port: The zfcp_port to lookup the d_id for.
447  */
448 void zfcp_fc_trigger_did_lookup(struct zfcp_port *port)
449 {
450 	get_device(&port->dev);
451 	if (!queue_work(port->adapter->work_queue, &port->gid_pn_work))
452 		put_device(&port->dev);
453 }
454 
455 /**
456  * zfcp_fc_plogi_evaluate - evaluate PLOGI playload
457  * @port: zfcp_port structure
458  * @plogi: plogi payload
459  *
460  * Evaluate PLOGI playload and copy important fields into zfcp_port structure
461  */
462 void zfcp_fc_plogi_evaluate(struct zfcp_port *port, struct fc_els_flogi *plogi)
463 {
464 	if (be64_to_cpu(plogi->fl_wwpn) != port->wwpn) {
465 		port->d_id = 0;
466 		dev_warn(&port->adapter->ccw_device->dev,
467 			 "A port opened with WWPN 0x%016Lx returned data that "
468 			 "identifies it as WWPN 0x%016Lx\n",
469 			 (unsigned long long) port->wwpn,
470 			 (unsigned long long) be64_to_cpu(plogi->fl_wwpn));
471 		return;
472 	}
473 
474 	port->wwnn = be64_to_cpu(plogi->fl_wwnn);
475 	port->maxframe_size = be16_to_cpu(plogi->fl_csp.sp_bb_data);
476 
477 	if (plogi->fl_cssp[0].cp_class & cpu_to_be16(FC_CPC_VALID))
478 		port->supported_classes |= FC_COS_CLASS1;
479 	if (plogi->fl_cssp[1].cp_class & cpu_to_be16(FC_CPC_VALID))
480 		port->supported_classes |= FC_COS_CLASS2;
481 	if (plogi->fl_cssp[2].cp_class & cpu_to_be16(FC_CPC_VALID))
482 		port->supported_classes |= FC_COS_CLASS3;
483 	if (plogi->fl_cssp[3].cp_class & cpu_to_be16(FC_CPC_VALID))
484 		port->supported_classes |= FC_COS_CLASS4;
485 }
486 
487 static void zfcp_fc_adisc_handler(void *data)
488 {
489 	struct zfcp_fc_req *fc_req = data;
490 	struct zfcp_port *port = fc_req->ct_els.port;
491 	struct fc_els_adisc *adisc_resp = &fc_req->u.adisc.rsp;
492 
493 	if (fc_req->ct_els.status) {
494 		/* request rejected or timed out */
495 		zfcp_erp_port_forced_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED,
496 					    "fcadh_1");
497 		goto out;
498 	}
499 
500 	if (!port->wwnn)
501 		port->wwnn = be64_to_cpu(adisc_resp->adisc_wwnn);
502 
503 	if ((port->wwpn != be64_to_cpu(adisc_resp->adisc_wwpn)) ||
504 	    !(atomic_read(&port->status) & ZFCP_STATUS_COMMON_OPEN)) {
505 		zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED,
506 				     "fcadh_2");
507 		goto out;
508 	}
509 
510 	/* port is good, unblock rport without going through erp */
511 	zfcp_scsi_schedule_rport_register(port);
512  out:
513 	atomic_andnot(ZFCP_STATUS_PORT_LINK_TEST, &port->status);
514 	put_device(&port->dev);
515 	kmem_cache_free(zfcp_fc_req_cache, fc_req);
516 }
517 
518 static int zfcp_fc_adisc(struct zfcp_port *port)
519 {
520 	struct zfcp_fc_req *fc_req;
521 	struct zfcp_adapter *adapter = port->adapter;
522 	struct Scsi_Host *shost = adapter->scsi_host;
523 	int ret;
524 
525 	fc_req = kmem_cache_zalloc(zfcp_fc_req_cache, GFP_ATOMIC);
526 	if (!fc_req)
527 		return -ENOMEM;
528 
529 	fc_req->ct_els.port = port;
530 	fc_req->ct_els.req = &fc_req->sg_req;
531 	fc_req->ct_els.resp = &fc_req->sg_rsp;
532 	sg_init_one(&fc_req->sg_req, &fc_req->u.adisc.req,
533 		    sizeof(struct fc_els_adisc));
534 	sg_init_one(&fc_req->sg_rsp, &fc_req->u.adisc.rsp,
535 		    sizeof(struct fc_els_adisc));
536 
537 	fc_req->ct_els.handler = zfcp_fc_adisc_handler;
538 	fc_req->ct_els.handler_data = fc_req;
539 
540 	/* acc. to FC-FS, hard_nport_id in ADISC should not be set for ports
541 	   without FC-AL-2 capability, so we don't set it */
542 	fc_req->u.adisc.req.adisc_wwpn = cpu_to_be64(fc_host_port_name(shost));
543 	fc_req->u.adisc.req.adisc_wwnn = cpu_to_be64(fc_host_node_name(shost));
544 	fc_req->u.adisc.req.adisc_cmd = ELS_ADISC;
545 	hton24(fc_req->u.adisc.req.adisc_port_id, fc_host_port_id(shost));
546 
547 	ret = zfcp_fsf_send_els(adapter, port->d_id, &fc_req->ct_els,
548 				ZFCP_FC_CTELS_TMO);
549 	if (ret)
550 		kmem_cache_free(zfcp_fc_req_cache, fc_req);
551 
552 	return ret;
553 }
554 
555 void zfcp_fc_link_test_work(struct work_struct *work)
556 {
557 	struct zfcp_port *port =
558 		container_of(work, struct zfcp_port, test_link_work);
559 	int retval;
560 
561 	get_device(&port->dev);
562 	port->rport_task = RPORT_DEL;
563 	zfcp_scsi_rport_work(&port->rport_work);
564 
565 	/* only issue one test command at one time per port */
566 	if (atomic_read(&port->status) & ZFCP_STATUS_PORT_LINK_TEST)
567 		goto out;
568 
569 	atomic_or(ZFCP_STATUS_PORT_LINK_TEST, &port->status);
570 
571 	retval = zfcp_fc_adisc(port);
572 	if (retval == 0)
573 		return;
574 
575 	/* send of ADISC was not possible */
576 	atomic_andnot(ZFCP_STATUS_PORT_LINK_TEST, &port->status);
577 	zfcp_erp_port_forced_reopen(port, 0, "fcltwk1");
578 
579 out:
580 	put_device(&port->dev);
581 }
582 
583 /**
584  * zfcp_fc_test_link - lightweight link test procedure
585  * @port: port to be tested
586  *
587  * Test status of a link to a remote port using the ELS command ADISC.
588  * If there is a problem with the remote port, error recovery steps
589  * will be triggered.
590  */
591 void zfcp_fc_test_link(struct zfcp_port *port)
592 {
593 	get_device(&port->dev);
594 	if (!queue_work(port->adapter->work_queue, &port->test_link_work))
595 		put_device(&port->dev);
596 }
597 
598 static struct zfcp_fc_req *zfcp_alloc_sg_env(int buf_num)
599 {
600 	struct zfcp_fc_req *fc_req;
601 
602 	fc_req = kmem_cache_zalloc(zfcp_fc_req_cache, GFP_KERNEL);
603 	if (!fc_req)
604 		return NULL;
605 
606 	if (zfcp_sg_setup_table(&fc_req->sg_rsp, buf_num)) {
607 		kmem_cache_free(zfcp_fc_req_cache, fc_req);
608 		return NULL;
609 	}
610 
611 	sg_init_one(&fc_req->sg_req, &fc_req->u.gpn_ft.req,
612 		    sizeof(struct zfcp_fc_gpn_ft_req));
613 
614 	return fc_req;
615 }
616 
617 static int zfcp_fc_send_gpn_ft(struct zfcp_fc_req *fc_req,
618 			       struct zfcp_adapter *adapter, int max_bytes)
619 {
620 	struct zfcp_fsf_ct_els *ct_els = &fc_req->ct_els;
621 	struct zfcp_fc_gpn_ft_req *req = &fc_req->u.gpn_ft.req;
622 	DECLARE_COMPLETION_ONSTACK(completion);
623 	int ret;
624 
625 	zfcp_fc_ct_ns_init(&req->ct_hdr, FC_NS_GPN_FT, max_bytes);
626 	req->gpn_ft.fn_fc4_type = FC_TYPE_FCP;
627 
628 	ct_els->handler = zfcp_fc_complete;
629 	ct_els->handler_data = &completion;
630 	ct_els->req = &fc_req->sg_req;
631 	ct_els->resp = &fc_req->sg_rsp;
632 
633 	ret = zfcp_fsf_send_ct(&adapter->gs->ds, ct_els, NULL,
634 			       ZFCP_FC_CTELS_TMO);
635 	if (!ret)
636 		wait_for_completion(&completion);
637 	return ret;
638 }
639 
640 static void zfcp_fc_validate_port(struct zfcp_port *port, struct list_head *lh)
641 {
642 	if (!(atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC))
643 		return;
644 
645 	atomic_andnot(ZFCP_STATUS_COMMON_NOESC, &port->status);
646 
647 	if ((port->supported_classes != 0) ||
648 	    !list_empty(&port->unit_list))
649 		return;
650 
651 	list_move_tail(&port->list, lh);
652 }
653 
654 static int zfcp_fc_eval_gpn_ft(struct zfcp_fc_req *fc_req,
655 			       struct zfcp_adapter *adapter, int max_entries)
656 {
657 	struct zfcp_fsf_ct_els *ct_els = &fc_req->ct_els;
658 	struct scatterlist *sg = &fc_req->sg_rsp;
659 	struct fc_ct_hdr *hdr = sg_virt(sg);
660 	struct fc_gpn_ft_resp *acc = sg_virt(sg);
661 	struct zfcp_port *port, *tmp;
662 	unsigned long flags;
663 	LIST_HEAD(remove_lh);
664 	u32 d_id;
665 	int ret = 0, x, last = 0;
666 
667 	if (ct_els->status)
668 		return -EIO;
669 
670 	if (hdr->ct_cmd != cpu_to_be16(FC_FS_ACC)) {
671 		if (hdr->ct_reason == FC_FS_RJT_UNABL)
672 			return -EAGAIN; /* might be a temporary condition */
673 		return -EIO;
674 	}
675 
676 	if (hdr->ct_mr_size) {
677 		dev_warn(&adapter->ccw_device->dev,
678 			 "The name server reported %d words residual data\n",
679 			 hdr->ct_mr_size);
680 		return -E2BIG;
681 	}
682 
683 	/* first entry is the header */
684 	for (x = 1; x < max_entries && !last; x++) {
685 		if (x % (ZFCP_FC_GPN_FT_ENT_PAGE + 1))
686 			acc++;
687 		else
688 			acc = sg_virt(++sg);
689 
690 		last = acc->fp_flags & FC_NS_FID_LAST;
691 		d_id = ntoh24(acc->fp_fid);
692 
693 		/* don't attach ports with a well known address */
694 		if (d_id >= FC_FID_WELL_KNOWN_BASE)
695 			continue;
696 		/* skip the adapter's port and known remote ports */
697 		if (be64_to_cpu(acc->fp_wwpn) ==
698 		    fc_host_port_name(adapter->scsi_host))
699 			continue;
700 
701 		port = zfcp_port_enqueue(adapter, be64_to_cpu(acc->fp_wwpn),
702 					 ZFCP_STATUS_COMMON_NOESC, d_id);
703 		if (!IS_ERR(port))
704 			zfcp_erp_port_reopen(port, 0, "fcegpf1");
705 		else if (PTR_ERR(port) != -EEXIST)
706 			ret = PTR_ERR(port);
707 	}
708 
709 	zfcp_erp_wait(adapter);
710 	write_lock_irqsave(&adapter->port_list_lock, flags);
711 	list_for_each_entry_safe(port, tmp, &adapter->port_list, list)
712 		zfcp_fc_validate_port(port, &remove_lh);
713 	write_unlock_irqrestore(&adapter->port_list_lock, flags);
714 
715 	list_for_each_entry_safe(port, tmp, &remove_lh, list) {
716 		zfcp_erp_port_shutdown(port, 0, "fcegpf2");
717 		device_unregister(&port->dev);
718 	}
719 
720 	return ret;
721 }
722 
723 /**
724  * zfcp_fc_scan_ports - scan remote ports and attach new ports
725  * @work: reference to scheduled work
726  */
727 void zfcp_fc_scan_ports(struct work_struct *work)
728 {
729 	struct delayed_work *dw = to_delayed_work(work);
730 	struct zfcp_adapter *adapter = container_of(dw, struct zfcp_adapter,
731 						    scan_work);
732 	int ret, i;
733 	struct zfcp_fc_req *fc_req;
734 	int chain, max_entries, buf_num, max_bytes;
735 
736 	zfcp_fc_port_scan_time(adapter);
737 
738 	chain = adapter->adapter_features & FSF_FEATURE_ELS_CT_CHAINED_SBALS;
739 	buf_num = chain ? ZFCP_FC_GPN_FT_NUM_BUFS : 1;
740 	max_entries = chain ? ZFCP_FC_GPN_FT_MAX_ENT : ZFCP_FC_GPN_FT_ENT_PAGE;
741 	max_bytes = chain ? ZFCP_FC_GPN_FT_MAX_SIZE : ZFCP_FC_CT_SIZE_PAGE;
742 
743 	if (fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPORT &&
744 	    fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPIV)
745 		return;
746 
747 	if (zfcp_fc_wka_port_get(&adapter->gs->ds))
748 		return;
749 
750 	fc_req = zfcp_alloc_sg_env(buf_num);
751 	if (!fc_req)
752 		goto out;
753 
754 	for (i = 0; i < 3; i++) {
755 		ret = zfcp_fc_send_gpn_ft(fc_req, adapter, max_bytes);
756 		if (!ret) {
757 			ret = zfcp_fc_eval_gpn_ft(fc_req, adapter, max_entries);
758 			if (ret == -EAGAIN)
759 				ssleep(1);
760 			else
761 				break;
762 		}
763 	}
764 	zfcp_sg_free_table(&fc_req->sg_rsp, buf_num);
765 	kmem_cache_free(zfcp_fc_req_cache, fc_req);
766 out:
767 	zfcp_fc_wka_port_put(&adapter->gs->ds);
768 }
769 
770 static int zfcp_fc_gspn(struct zfcp_adapter *adapter,
771 			struct zfcp_fc_req *fc_req)
772 {
773 	DECLARE_COMPLETION_ONSTACK(completion);
774 	char devno[] = "DEVNO:";
775 	struct zfcp_fsf_ct_els *ct_els = &fc_req->ct_els;
776 	struct zfcp_fc_gspn_req *gspn_req = &fc_req->u.gspn.req;
777 	struct zfcp_fc_gspn_rsp *gspn_rsp = &fc_req->u.gspn.rsp;
778 	int ret;
779 
780 	zfcp_fc_ct_ns_init(&gspn_req->ct_hdr, FC_NS_GSPN_ID,
781 			   FC_SYMBOLIC_NAME_SIZE);
782 	hton24(gspn_req->gspn.fp_fid, fc_host_port_id(adapter->scsi_host));
783 
784 	sg_init_one(&fc_req->sg_req, gspn_req, sizeof(*gspn_req));
785 	sg_init_one(&fc_req->sg_rsp, gspn_rsp, sizeof(*gspn_rsp));
786 
787 	ct_els->handler = zfcp_fc_complete;
788 	ct_els->handler_data = &completion;
789 	ct_els->req = &fc_req->sg_req;
790 	ct_els->resp = &fc_req->sg_rsp;
791 
792 	ret = zfcp_fsf_send_ct(&adapter->gs->ds, ct_els, NULL,
793 			       ZFCP_FC_CTELS_TMO);
794 	if (ret)
795 		return ret;
796 
797 	wait_for_completion(&completion);
798 	if (ct_els->status)
799 		return ct_els->status;
800 
801 	if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_NPIV &&
802 	    !(strstr(gspn_rsp->gspn.fp_name, devno)))
803 		snprintf(fc_host_symbolic_name(adapter->scsi_host),
804 			 FC_SYMBOLIC_NAME_SIZE, "%s%s %s NAME: %s",
805 			 gspn_rsp->gspn.fp_name, devno,
806 			 dev_name(&adapter->ccw_device->dev),
807 			 init_utsname()->nodename);
808 	else
809 		strlcpy(fc_host_symbolic_name(adapter->scsi_host),
810 			gspn_rsp->gspn.fp_name, FC_SYMBOLIC_NAME_SIZE);
811 
812 	return 0;
813 }
814 
815 static void zfcp_fc_rspn(struct zfcp_adapter *adapter,
816 			 struct zfcp_fc_req *fc_req)
817 {
818 	DECLARE_COMPLETION_ONSTACK(completion);
819 	struct Scsi_Host *shost = adapter->scsi_host;
820 	struct zfcp_fsf_ct_els *ct_els = &fc_req->ct_els;
821 	struct zfcp_fc_rspn_req *rspn_req = &fc_req->u.rspn.req;
822 	struct fc_ct_hdr *rspn_rsp = &fc_req->u.rspn.rsp;
823 	int ret, len;
824 
825 	zfcp_fc_ct_ns_init(&rspn_req->ct_hdr, FC_NS_RSPN_ID,
826 			   FC_SYMBOLIC_NAME_SIZE);
827 	hton24(rspn_req->rspn.fr_fid.fp_fid, fc_host_port_id(shost));
828 	len = strlcpy(rspn_req->rspn.fr_name, fc_host_symbolic_name(shost),
829 		      FC_SYMBOLIC_NAME_SIZE);
830 	rspn_req->rspn.fr_name_len = len;
831 
832 	sg_init_one(&fc_req->sg_req, rspn_req, sizeof(*rspn_req));
833 	sg_init_one(&fc_req->sg_rsp, rspn_rsp, sizeof(*rspn_rsp));
834 
835 	ct_els->handler = zfcp_fc_complete;
836 	ct_els->handler_data = &completion;
837 	ct_els->req = &fc_req->sg_req;
838 	ct_els->resp = &fc_req->sg_rsp;
839 
840 	ret = zfcp_fsf_send_ct(&adapter->gs->ds, ct_els, NULL,
841 			       ZFCP_FC_CTELS_TMO);
842 	if (!ret)
843 		wait_for_completion(&completion);
844 }
845 
846 /**
847  * zfcp_fc_sym_name_update - Retrieve and update the symbolic port name
848  * @work: ns_up_work of the adapter where to update the symbolic port name
849  *
850  * Retrieve the current symbolic port name that may have been set by
851  * the hardware using the GSPN request and update the fc_host
852  * symbolic_name sysfs attribute. When running in NPIV mode (and hence
853  * the port name is unique for this system), update the symbolic port
854  * name to add Linux specific information and update the FC nameserver
855  * using the RSPN request.
856  */
857 void zfcp_fc_sym_name_update(struct work_struct *work)
858 {
859 	struct zfcp_adapter *adapter = container_of(work, struct zfcp_adapter,
860 						    ns_up_work);
861 	int ret;
862 	struct zfcp_fc_req *fc_req;
863 
864 	if (fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPORT &&
865 	    fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPIV)
866 		return;
867 
868 	fc_req = kmem_cache_zalloc(zfcp_fc_req_cache, GFP_KERNEL);
869 	if (!fc_req)
870 		return;
871 
872 	ret = zfcp_fc_wka_port_get(&adapter->gs->ds);
873 	if (ret)
874 		goto out_free;
875 
876 	ret = zfcp_fc_gspn(adapter, fc_req);
877 	if (ret || fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPIV)
878 		goto out_ds_put;
879 
880 	memset(fc_req, 0, sizeof(*fc_req));
881 	zfcp_fc_rspn(adapter, fc_req);
882 
883 out_ds_put:
884 	zfcp_fc_wka_port_put(&adapter->gs->ds);
885 out_free:
886 	kmem_cache_free(zfcp_fc_req_cache, fc_req);
887 }
888 
889 static void zfcp_fc_ct_els_job_handler(void *data)
890 {
891 	struct bsg_job *job = data;
892 	struct zfcp_fsf_ct_els *zfcp_ct_els = job->dd_data;
893 	struct fc_bsg_reply *jr = job->reply;
894 
895 	jr->reply_payload_rcv_len = job->reply_payload.payload_len;
896 	jr->reply_data.ctels_reply.status = FC_CTELS_STATUS_OK;
897 	jr->result = zfcp_ct_els->status ? -EIO : 0;
898 	bsg_job_done(job, jr->result, jr->reply_payload_rcv_len);
899 }
900 
901 static struct zfcp_fc_wka_port *zfcp_fc_job_wka_port(struct bsg_job *job)
902 {
903 	u32 preamble_word1;
904 	u8 gs_type;
905 	struct zfcp_adapter *adapter;
906 	struct fc_bsg_request *bsg_request = job->request;
907 	struct fc_rport *rport = fc_bsg_to_rport(job);
908 	struct Scsi_Host *shost;
909 
910 	preamble_word1 = bsg_request->rqst_data.r_ct.preamble_word1;
911 	gs_type = (preamble_word1 & 0xff000000) >> 24;
912 
913 	shost = rport ? rport_to_shost(rport) : fc_bsg_to_shost(job);
914 	adapter = (struct zfcp_adapter *) shost->hostdata[0];
915 
916 	switch (gs_type) {
917 	case FC_FST_ALIAS:
918 		return &adapter->gs->as;
919 	case FC_FST_MGMT:
920 		return &adapter->gs->ms;
921 	case FC_FST_TIME:
922 		return &adapter->gs->ts;
923 		break;
924 	case FC_FST_DIR:
925 		return &adapter->gs->ds;
926 		break;
927 	default:
928 		return NULL;
929 	}
930 }
931 
932 static void zfcp_fc_ct_job_handler(void *data)
933 {
934 	struct bsg_job *job = data;
935 	struct zfcp_fc_wka_port *wka_port;
936 
937 	wka_port = zfcp_fc_job_wka_port(job);
938 	zfcp_fc_wka_port_put(wka_port);
939 
940 	zfcp_fc_ct_els_job_handler(data);
941 }
942 
943 static int zfcp_fc_exec_els_job(struct bsg_job *job,
944 				struct zfcp_adapter *adapter)
945 {
946 	struct zfcp_fsf_ct_els *els = job->dd_data;
947 	struct fc_rport *rport = fc_bsg_to_rport(job);
948 	struct fc_bsg_request *bsg_request = job->request;
949 	struct zfcp_port *port;
950 	u32 d_id;
951 
952 	if (rport) {
953 		port = zfcp_get_port_by_wwpn(adapter, rport->port_name);
954 		if (!port)
955 			return -EINVAL;
956 
957 		d_id = port->d_id;
958 		put_device(&port->dev);
959 	} else
960 		d_id = ntoh24(bsg_request->rqst_data.h_els.port_id);
961 
962 	els->handler = zfcp_fc_ct_els_job_handler;
963 	return zfcp_fsf_send_els(adapter, d_id, els, job->req->timeout / HZ);
964 }
965 
966 static int zfcp_fc_exec_ct_job(struct bsg_job *job,
967 			       struct zfcp_adapter *adapter)
968 {
969 	int ret;
970 	struct zfcp_fsf_ct_els *ct = job->dd_data;
971 	struct zfcp_fc_wka_port *wka_port;
972 
973 	wka_port = zfcp_fc_job_wka_port(job);
974 	if (!wka_port)
975 		return -EINVAL;
976 
977 	ret = zfcp_fc_wka_port_get(wka_port);
978 	if (ret)
979 		return ret;
980 
981 	ct->handler = zfcp_fc_ct_job_handler;
982 	ret = zfcp_fsf_send_ct(wka_port, ct, NULL, job->req->timeout / HZ);
983 	if (ret)
984 		zfcp_fc_wka_port_put(wka_port);
985 
986 	return ret;
987 }
988 
989 int zfcp_fc_exec_bsg_job(struct bsg_job *job)
990 {
991 	struct Scsi_Host *shost;
992 	struct zfcp_adapter *adapter;
993 	struct zfcp_fsf_ct_els *ct_els = job->dd_data;
994 	struct fc_bsg_request *bsg_request = job->request;
995 	struct fc_rport *rport = fc_bsg_to_rport(job);
996 
997 	shost = rport ? rport_to_shost(rport) : fc_bsg_to_shost(job);
998 	adapter = (struct zfcp_adapter *)shost->hostdata[0];
999 
1000 	if (!(atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_OPEN))
1001 		return -EINVAL;
1002 
1003 	ct_els->req = job->request_payload.sg_list;
1004 	ct_els->resp = job->reply_payload.sg_list;
1005 	ct_els->handler_data = job;
1006 
1007 	switch (bsg_request->msgcode) {
1008 	case FC_BSG_RPT_ELS:
1009 	case FC_BSG_HST_ELS_NOLOGIN:
1010 		return zfcp_fc_exec_els_job(job, adapter);
1011 	case FC_BSG_RPT_CT:
1012 	case FC_BSG_HST_CT:
1013 		return zfcp_fc_exec_ct_job(job, adapter);
1014 	default:
1015 		return -EINVAL;
1016 	}
1017 }
1018 
1019 int zfcp_fc_timeout_bsg_job(struct bsg_job *job)
1020 {
1021 	/* hardware tracks timeout, reset bsg timeout to not interfere */
1022 	return -EAGAIN;
1023 }
1024 
1025 int zfcp_fc_gs_setup(struct zfcp_adapter *adapter)
1026 {
1027 	struct zfcp_fc_wka_ports *wka_ports;
1028 
1029 	wka_ports = kzalloc(sizeof(struct zfcp_fc_wka_ports), GFP_KERNEL);
1030 	if (!wka_ports)
1031 		return -ENOMEM;
1032 
1033 	adapter->gs = wka_ports;
1034 	zfcp_fc_wka_port_init(&wka_ports->ms, FC_FID_MGMT_SERV, adapter);
1035 	zfcp_fc_wka_port_init(&wka_ports->ts, FC_FID_TIME_SERV, adapter);
1036 	zfcp_fc_wka_port_init(&wka_ports->ds, FC_FID_DIR_SERV, adapter);
1037 	zfcp_fc_wka_port_init(&wka_ports->as, FC_FID_ALIASES, adapter);
1038 
1039 	return 0;
1040 }
1041 
1042 void zfcp_fc_gs_destroy(struct zfcp_adapter *adapter)
1043 {
1044 	kfree(adapter->gs);
1045 	adapter->gs = NULL;
1046 }
1047 
1048