zfcp_scsi.c 18.3 KB
Newer Older
S
Swen Schillig 已提交
1
/*
C
Christof Schmitt 已提交
2
 * zfcp device driver
L
Linus Torvalds 已提交
3
 *
C
Christof Schmitt 已提交
4
 * Interface to Linux SCSI midlayer.
S
Swen Schillig 已提交
5
 *
6
 * Copyright IBM Corporation 2002, 2009
L
Linus Torvalds 已提交
7 8
 */

9 10 11
#define KMSG_COMPONENT "zfcp"
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt

L
Linus Torvalds 已提交
12
#include "zfcp_ext.h"
13
#include <asm/atomic.h>
L
Linus Torvalds 已提交
14 15

/* Find start of Sense Information in FCP response unit*/
16
char *zfcp_get_fcp_sns_info_ptr(struct fcp_rsp_iu *fcp_rsp_iu)
L
Linus Torvalds 已提交
17 18 19
{
	char *fcp_sns_info_ptr;

20
	fcp_sns_info_ptr = (unsigned char *) &fcp_rsp_iu[1];
L
Linus Torvalds 已提交
21
	if (fcp_rsp_iu->validity.bits.fcp_rsp_len_valid)
22
		fcp_sns_info_ptr += fcp_rsp_iu->fcp_rsp_len;
L
Linus Torvalds 已提交
23 24 25 26

	return fcp_sns_info_ptr;
}

27
static void zfcp_scsi_slave_destroy(struct scsi_device *sdpnt)
L
Linus Torvalds 已提交
28 29
{
	struct zfcp_unit *unit = (struct zfcp_unit *) sdpnt->hostdata;
30 31
	unit->device = NULL;
	zfcp_unit_put(unit);
L
Linus Torvalds 已提交
32 33
}

34
static int zfcp_scsi_slave_configure(struct scsi_device *sdp)
L
Linus Torvalds 已提交
35 36
{
	if (sdp->tagged_supported)
37
		scsi_adjust_queue_depth(sdp, MSG_SIMPLE_TAG, 32);
L
Linus Torvalds 已提交
38 39 40 41 42
	else
		scsi_adjust_queue_depth(sdp, 0, 1);
	return 0;
}

43
static void zfcp_scsi_command_fail(struct scsi_cmnd *scpnt, int result)
L
Linus Torvalds 已提交
44
{
45
	set_host_byte(scpnt, result);
46 47 48
	if ((scpnt->device != NULL) && (scpnt->device->host != NULL))
		zfcp_scsi_dbf_event_result("fail", 4,
			(struct zfcp_adapter*) scpnt->device->host->hostdata[0],
49
			scpnt, NULL);
L
Linus Torvalds 已提交
50 51 52 53
	/* return directly */
	scpnt->scsi_done(scpnt);
}

54 55
static int zfcp_scsi_queuecommand(struct scsi_cmnd *scpnt,
				  void (*done) (struct scsi_cmnd *))
L
Linus Torvalds 已提交
56 57 58
{
	struct zfcp_unit *unit;
	struct zfcp_adapter *adapter;
59 60
	int    status, scsi_result, ret;
	struct fc_rport *rport = starget_to_rport(scsi_target(scpnt->device));
L
Linus Torvalds 已提交
61 62 63 64 65 66 67 68 69 70 71

	/* reset the status for this request */
	scpnt->result = 0;
	scpnt->host_scribble = NULL;
	scpnt->scsi_done = done;

	/*
	 * figure out adapter and target device
	 * (stored there by zfcp_scsi_slave_alloc)
	 */
	adapter = (struct zfcp_adapter *) scpnt->device->host->hostdata[0];
72 73 74 75 76 77 78 79 80 81
	unit = scpnt->device->hostdata;

	BUG_ON(!adapter || (adapter != unit->port->adapter));
	BUG_ON(!scpnt->scsi_done);

	if (unlikely(!unit)) {
		zfcp_scsi_command_fail(scpnt, DID_NO_CONNECT);
		return 0;
	}

82 83 84 85 86 87 88 89
	scsi_result = fc_remote_port_chkready(rport);
	if (unlikely(scsi_result)) {
		scpnt->result = scsi_result;
		zfcp_scsi_dbf_event_result("fail", 4, adapter, scpnt, NULL);
		scpnt->scsi_done(scpnt);
		return 0;
	}

90 91 92 93 94 95 96
	status = atomic_read(&unit->status);
	if (unlikely((status & ZFCP_STATUS_COMMON_ERP_FAILED) ||
		     !(status & ZFCP_STATUS_COMMON_RUNNING))) {
		zfcp_scsi_command_fail(scpnt, DID_ERROR);
		return 0;;
	}

97
	ret = zfcp_fsf_send_fcp_command_task(unit, scpnt);
98
	if (unlikely(ret == -EBUSY))
99
		return SCSI_MLQUEUE_DEVICE_BUSY;
100 101
	else if (unlikely(ret < 0))
		return SCSI_MLQUEUE_HOST_BUSY;
L
Linus Torvalds 已提交
102

103
	return ret;
L
Linus Torvalds 已提交
104 105
}

106 107 108
static struct zfcp_unit *zfcp_unit_lookup(struct zfcp_adapter *adapter,
					  int channel, unsigned int id,
					  unsigned int lun)
L
Linus Torvalds 已提交
109 110
{
	struct zfcp_port *port;
111
	struct zfcp_unit *unit;
112
	int scsi_lun;
L
Linus Torvalds 已提交
113 114

	list_for_each_entry(port, &adapter->port_list_head, list) {
115
		if (!port->rport || (id != port->rport->scsi_target_id))
L
Linus Torvalds 已提交
116
			continue;
117 118 119 120
		list_for_each_entry(unit, &port->unit_list_head, list) {
			scsi_lun = scsilun_to_int(
				(struct scsi_lun *)&unit->fcp_lun);
			if (lun == scsi_lun)
121
				return unit;
122
		}
L
Linus Torvalds 已提交
123
	}
124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140

	return NULL;
}

static int zfcp_scsi_slave_alloc(struct scsi_device *sdp)
{
	struct zfcp_adapter *adapter;
	struct zfcp_unit *unit;
	unsigned long flags;
	int retval = -ENXIO;

	adapter = (struct zfcp_adapter *) sdp->host->hostdata[0];
	if (!adapter)
		goto out;

	read_lock_irqsave(&zfcp_data.config_lock, flags);
	unit = zfcp_unit_lookup(adapter, sdp->channel, sdp->id, sdp->lun);
141
	if (unit) {
142 143 144 145 146 147 148
		sdp->hostdata = unit;
		unit->device = sdp;
		zfcp_unit_get(unit);
		retval = 0;
	}
	read_unlock_irqrestore(&zfcp_data.config_lock, flags);
out:
L
Linus Torvalds 已提交
149 150 151
	return retval;
}

152
static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
L
Linus Torvalds 已提交
153
{
154 155 156 157 158
	struct Scsi_Host *scsi_host = scpnt->device->host;
	struct zfcp_adapter *adapter =
		(struct zfcp_adapter *) scsi_host->hostdata[0];
	struct zfcp_unit *unit = scpnt->device->hostdata;
	struct zfcp_fsf_req *old_req, *abrt_req;
L
Linus Torvalds 已提交
159
	unsigned long flags;
160
	unsigned long old_req_id = (unsigned long) scpnt->host_scribble;
161
	int retval = SUCCESS;
162
	int retry = 3;
L
Linus Torvalds 已提交
163

164
	/* avoid race condition between late normal completion and abort */
L
Linus Torvalds 已提交
165 166
	write_lock_irqsave(&adapter->abort_lock, flags);

167
	spin_lock(&adapter->req_list_lock);
168
	old_req = zfcp_reqlist_find(adapter, old_req_id);
169
	spin_unlock(&adapter->req_list_lock);
170
	if (!old_req) {
L
Linus Torvalds 已提交
171
		write_unlock_irqrestore(&adapter->abort_lock, flags);
172 173
		zfcp_scsi_dbf_event_abort("lte1", adapter, scpnt, NULL,
					  old_req_id);
174
		return FAILED; /* completion could be in progress */
L
Linus Torvalds 已提交
175
	}
176
	old_req->data = NULL;
L
Linus Torvalds 已提交
177

178
	/* don't access old fsf_req after releasing the abort_lock */
L
Linus Torvalds 已提交
179
	write_unlock_irqrestore(&adapter->abort_lock, flags);
180

181 182 183 184 185 186 187 188 189 190 191 192
	while (retry--) {
		abrt_req = zfcp_fsf_abort_fcp_command(old_req_id, unit);
		if (abrt_req)
			break;

		zfcp_erp_wait(adapter);
		if (!(atomic_read(&adapter->status) &
		      ZFCP_STATUS_COMMON_RUNNING)) {
			zfcp_scsi_dbf_event_abort("nres", adapter, scpnt, NULL,
						  old_req_id);
			return SUCCESS;
		}
L
Linus Torvalds 已提交
193
	}
194 195
	if (!abrt_req)
		return FAILED;
L
Linus Torvalds 已提交
196

197 198
	wait_event(abrt_req->completion_wq,
		   abrt_req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
199

200 201 202 203 204 205
	if (abrt_req->status & ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED)
		zfcp_scsi_dbf_event_abort("okay", adapter, scpnt, abrt_req, 0);
	else if (abrt_req->status & ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED)
		zfcp_scsi_dbf_event_abort("lte2", adapter, scpnt, abrt_req, 0);
	else {
		zfcp_scsi_dbf_event_abort("fail", adapter, scpnt, abrt_req, 0);
L
Linus Torvalds 已提交
206 207
		retval = FAILED;
	}
208
	zfcp_fsf_req_free(abrt_req);
209
	return retval;
L
Linus Torvalds 已提交
210 211
}

212
static int zfcp_task_mgmt_function(struct scsi_cmnd *scpnt, u8 tm_flags)
L
Linus Torvalds 已提交
213
{
214
	struct zfcp_unit *unit = scpnt->device->hostdata;
L
Linus Torvalds 已提交
215 216
	struct zfcp_adapter *adapter = unit->port->adapter;
	struct zfcp_fsf_req *fsf_req;
217
	int retval = SUCCESS;
218 219 220 221 222 223 224 225 226 227 228 229 230 231
	int retry = 3;

	while (retry--) {
		fsf_req = zfcp_fsf_send_fcp_ctm(unit, tm_flags);
		if (fsf_req)
			break;

		zfcp_erp_wait(adapter);
		if (!(atomic_read(&adapter->status) &
		      ZFCP_STATUS_COMMON_RUNNING)) {
			zfcp_scsi_dbf_event_devreset("nres", tm_flags, unit,
						     scpnt);
			return SUCCESS;
		}
L
Linus Torvalds 已提交
232
	}
233 234
	if (!fsf_req)
		return FAILED;
L
Linus Torvalds 已提交
235

236 237
	wait_event(fsf_req->completion_wq,
		   fsf_req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
238

239 240
	if (fsf_req->status & ZFCP_STATUS_FSFREQ_TMFUNCFAILED) {
		zfcp_scsi_dbf_event_devreset("fail", tm_flags, unit, scpnt);
241
		retval = FAILED;
242 243
	} else if (fsf_req->status & ZFCP_STATUS_FSFREQ_TMFUNCNOTSUPP) {
		zfcp_scsi_dbf_event_devreset("nsup", tm_flags, unit, scpnt);
244
		retval = FAILED;
245 246
	} else
		zfcp_scsi_dbf_event_devreset("okay", tm_flags, unit, scpnt);
247 248

	zfcp_fsf_req_free(fsf_req);
L
Linus Torvalds 已提交
249 250 251
	return retval;
}

252 253
static int zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd *scpnt)
{
254
	return zfcp_task_mgmt_function(scpnt, FCP_LOGICAL_UNIT_RESET);
255 256 257 258
}

static int zfcp_scsi_eh_target_reset_handler(struct scsi_cmnd *scpnt)
{
259
	return zfcp_task_mgmt_function(scpnt, FCP_TARGET_RESET);
260 261
}

262
static int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *scpnt)
L
Linus Torvalds 已提交
263
{
264 265
	struct zfcp_unit *unit = scpnt->device->hostdata;
	struct zfcp_adapter *adapter = unit->port->adapter;
L
Linus Torvalds 已提交
266

267
	zfcp_erp_adapter_reopen(adapter, 0, "schrh_1", scpnt);
268
	zfcp_erp_wait(adapter);
L
Linus Torvalds 已提交
269

270
	return SUCCESS;
L
Linus Torvalds 已提交
271 272
}

273
int zfcp_adapter_scsi_register(struct zfcp_adapter *adapter)
L
Linus Torvalds 已提交
274
{
275
	struct ccw_dev_id dev_id;
L
Linus Torvalds 已提交
276

277
	if (adapter->scsi_host)
278
		return 0;
279

280
	ccw_device_get_id(adapter->ccw_device, &dev_id);
L
Linus Torvalds 已提交
281 282 283 284
	/* register adapter as SCSI host with mid layer of SCSI stack */
	adapter->scsi_host = scsi_host_alloc(&zfcp_data.scsi_host_template,
					     sizeof (struct zfcp_adapter *));
	if (!adapter->scsi_host) {
C
Christof Schmitt 已提交
285
		dev_err(&adapter->ccw_device->dev,
286 287
			"Registering the FCP device with the "
			"SCSI stack failed\n");
288
		return -EIO;
L
Linus Torvalds 已提交
289 290 291 292 293 294
	}

	/* tell the SCSI stack some characteristics of this adapter */
	adapter->scsi_host->max_id = 1;
	adapter->scsi_host->max_lun = 1;
	adapter->scsi_host->max_channel = 0;
295 296
	adapter->scsi_host->unique_id = dev_id.devno;
	adapter->scsi_host->max_cmd_len = 255;
297
	adapter->scsi_host->transportt = zfcp_data.scsi_transport_template;
L
Linus Torvalds 已提交
298 299 300 301 302

	adapter->scsi_host->hostdata[0] = (unsigned long) adapter;

	if (scsi_add_host(adapter->scsi_host, &adapter->ccw_device->dev)) {
		scsi_host_put(adapter->scsi_host);
303
		return -EIO;
L
Linus Torvalds 已提交
304
	}
305 306

	return 0;
L
Linus Torvalds 已提交
307 308
}

309
void zfcp_adapter_scsi_unregister(struct zfcp_adapter *adapter)
L
Linus Torvalds 已提交
310 311
{
	struct Scsi_Host *shost;
312
	struct zfcp_port *port;
L
Linus Torvalds 已提交
313 314 315 316

	shost = adapter->scsi_host;
	if (!shost)
		return;
317

318 319 320 321
	read_lock_irq(&zfcp_data.config_lock);
	list_for_each_entry(port, &adapter->port_list_head, list)
		if (port->rport)
			port->rport = NULL;
322

323
	read_unlock_irq(&zfcp_data.config_lock);
324
	fc_remove_host(shost);
L
Linus Torvalds 已提交
325 326 327 328 329 330 331
	scsi_remove_host(shost);
	scsi_host_put(shost);
	adapter->scsi_host = NULL;

	return;
}

332 333
static struct fc_host_statistics*
zfcp_init_fc_host_stats(struct zfcp_adapter *adapter)
L
Linus Torvalds 已提交
334
{
335
	struct fc_host_statistics *fc_stats;
L
Linus Torvalds 已提交
336

337 338 339 340 341 342 343 344
	if (!adapter->fc_stats) {
		fc_stats = kmalloc(sizeof(*fc_stats), GFP_KERNEL);
		if (!fc_stats)
			return NULL;
		adapter->fc_stats = fc_stats; /* freed in adater_dequeue */
	}
	memset(adapter->fc_stats, 0, sizeof(*adapter->fc_stats));
	return adapter->fc_stats;
L
Linus Torvalds 已提交
345 346
}

347 348 349
static void zfcp_adjust_fc_host_stats(struct fc_host_statistics *fc_stats,
				      struct fsf_qtcb_bottom_port *data,
				      struct fsf_qtcb_bottom_port *old)
L
Linus Torvalds 已提交
350
{
351 352
	fc_stats->seconds_since_last_reset =
		data->seconds_since_last_reset - old->seconds_since_last_reset;
353 354 355 356 357 358 359 360 361 362
	fc_stats->tx_frames = data->tx_frames - old->tx_frames;
	fc_stats->tx_words = data->tx_words - old->tx_words;
	fc_stats->rx_frames = data->rx_frames - old->rx_frames;
	fc_stats->rx_words = data->rx_words - old->rx_words;
	fc_stats->lip_count = data->lip - old->lip;
	fc_stats->nos_count = data->nos - old->nos;
	fc_stats->error_frames = data->error_frames - old->error_frames;
	fc_stats->dumped_frames = data->dumped_frames - old->dumped_frames;
	fc_stats->link_failure_count = data->link_failure - old->link_failure;
	fc_stats->loss_of_sync_count = data->loss_of_sync - old->loss_of_sync;
363 364 365 366 367 368
	fc_stats->loss_of_signal_count =
		data->loss_of_signal - old->loss_of_signal;
	fc_stats->prim_seq_protocol_err_count =
		data->psp_error_counts - old->psp_error_counts;
	fc_stats->invalid_tx_word_count =
		data->invalid_tx_words - old->invalid_tx_words;
369
	fc_stats->invalid_crc_count = data->invalid_crcs - old->invalid_crcs;
370 371 372 373 374 375
	fc_stats->fcp_input_requests =
		data->input_requests - old->input_requests;
	fc_stats->fcp_output_requests =
		data->output_requests - old->output_requests;
	fc_stats->fcp_control_requests =
		data->control_requests - old->control_requests;
376 377 378
	fc_stats->fcp_input_megabytes = data->input_mb - old->input_mb;
	fc_stats->fcp_output_megabytes = data->output_mb - old->output_mb;
}
L
Linus Torvalds 已提交
379

380 381
static void zfcp_set_fc_host_stats(struct fc_host_statistics *fc_stats,
				   struct fsf_qtcb_bottom_port *data)
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404
{
	fc_stats->seconds_since_last_reset = data->seconds_since_last_reset;
	fc_stats->tx_frames = data->tx_frames;
	fc_stats->tx_words = data->tx_words;
	fc_stats->rx_frames = data->rx_frames;
	fc_stats->rx_words = data->rx_words;
	fc_stats->lip_count = data->lip;
	fc_stats->nos_count = data->nos;
	fc_stats->error_frames = data->error_frames;
	fc_stats->dumped_frames = data->dumped_frames;
	fc_stats->link_failure_count = data->link_failure;
	fc_stats->loss_of_sync_count = data->loss_of_sync;
	fc_stats->loss_of_signal_count = data->loss_of_signal;
	fc_stats->prim_seq_protocol_err_count = data->psp_error_counts;
	fc_stats->invalid_tx_word_count = data->invalid_tx_words;
	fc_stats->invalid_crc_count = data->invalid_crcs;
	fc_stats->fcp_input_requests = data->input_requests;
	fc_stats->fcp_output_requests = data->output_requests;
	fc_stats->fcp_control_requests = data->control_requests;
	fc_stats->fcp_input_megabytes = data->input_mb;
	fc_stats->fcp_output_megabytes = data->output_mb;
}

405
static struct fc_host_statistics *zfcp_get_fc_host_stats(struct Scsi_Host *host)
406 407 408 409 410 411
{
	struct zfcp_adapter *adapter;
	struct fc_host_statistics *fc_stats;
	struct fsf_qtcb_bottom_port *data;
	int ret;

412
	adapter = (struct zfcp_adapter *)host->hostdata[0];
413 414 415 416
	fc_stats = zfcp_init_fc_host_stats(adapter);
	if (!fc_stats)
		return NULL;

417
	data = kzalloc(sizeof(*data), GFP_KERNEL);
418 419 420
	if (!data)
		return NULL;

421
	ret = zfcp_fsf_exchange_port_data_sync(adapter, data);
422 423
	if (ret) {
		kfree(data);
424
		return NULL;
425 426 427 428
	}

	if (adapter->stats_reset &&
	    ((jiffies/HZ - adapter->stats_reset) <
429
	     data->seconds_since_last_reset))
430 431
		zfcp_adjust_fc_host_stats(fc_stats, data,
					  adapter->stats_reset_data);
432
	else
433 434 435 436
		zfcp_set_fc_host_stats(fc_stats, data);

	kfree(data);
	return fc_stats;
L
Linus Torvalds 已提交
437 438
}

439
static void zfcp_reset_fc_host_stats(struct Scsi_Host *shost)
L
Linus Torvalds 已提交
440
{
441
	struct zfcp_adapter *adapter;
442
	struct fsf_qtcb_bottom_port *data;
443
	int ret;
L
Linus Torvalds 已提交
444

445
	adapter = (struct zfcp_adapter *)shost->hostdata[0];
446
	data = kzalloc(sizeof(*data), GFP_KERNEL);
447 448 449
	if (!data)
		return;

450
	ret = zfcp_fsf_exchange_port_data_sync(adapter, data);
451
	if (ret)
H
Heiko Carstens 已提交
452
		kfree(data);
453
	else {
454
		adapter->stats_reset = jiffies/HZ;
455
		kfree(adapter->stats_reset_data);
456
		adapter->stats_reset_data = data; /* finally freed in
457
						     adapter_dequeue */
458
	}
L
Linus Torvalds 已提交
459 460
}

461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477
static void zfcp_get_host_port_state(struct Scsi_Host *shost)
{
	struct zfcp_adapter *adapter =
		(struct zfcp_adapter *)shost->hostdata[0];
	int status = atomic_read(&adapter->status);

	if ((status & ZFCP_STATUS_COMMON_RUNNING) &&
	    !(status & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED))
		fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
	else if (status & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED)
		fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
	else if (status & ZFCP_STATUS_COMMON_ERP_FAILED)
		fc_host_port_state(shost) = FC_PORTSTATE_ERROR;
	else
		fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
}

478 479 480 481 482
static void zfcp_set_rport_dev_loss_tmo(struct fc_rport *rport, u32 timeout)
{
	rport->dev_loss_tmo = timeout;
}

483 484 485 486 487 488
/**
 * zfcp_scsi_dev_loss_tmo_callbk - Free any reference to rport
 * @rport: The rport that is about to be deleted.
 */
static void zfcp_scsi_dev_loss_tmo_callbk(struct fc_rport *rport)
{
489
	struct zfcp_port *port;
490 491

	write_lock_irq(&zfcp_data.config_lock);
492 493 494
	port = rport->dd_data;
	if (port)
		port->rport = NULL;
495 496 497 498 499 500 501 502 503 504 505 506 507
	write_unlock_irq(&zfcp_data.config_lock);
}

/**
 * zfcp_scsi_terminate_rport_io - Terminate all I/O on a rport
 * @rport: The FC rport where to teminate I/O
 *
 * Abort all pending SCSI commands for a port by closing the
 * port. Using a reopen for avoids a conflict with a shutdown
 * overwriting a reopen.
 */
static void zfcp_scsi_terminate_rport_io(struct fc_rport *rport)
{
508 509 510 511 512 513 514
	struct zfcp_port *port;

	write_lock_irq(&zfcp_data.config_lock);
	port = rport->dd_data;
	if (port)
		zfcp_port_get(port);
	write_unlock_irq(&zfcp_data.config_lock);
515

516 517 518 519
	if (port) {
		zfcp_erp_port_reopen(port, 0, "sctrpi1", NULL);
		zfcp_port_put(port);
	}
520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547
}

static void zfcp_scsi_rport_register(struct zfcp_port *port)
{
	struct fc_rport_identifiers ids;
	struct fc_rport *rport;

	ids.node_name = port->wwnn;
	ids.port_name = port->wwpn;
	ids.port_id = port->d_id;
	ids.roles = FC_RPORT_ROLE_FCP_TARGET;

	rport = fc_remote_port_add(port->adapter->scsi_host, 0, &ids);
	if (!rport) {
		dev_err(&port->adapter->ccw_device->dev,
			"Registering port 0x%016Lx failed\n",
			(unsigned long long)port->wwpn);
		return;
	}

	rport->dd_data = port;
	rport->maxframe_size = port->maxframe_size;
	rport->supported_classes = port->supported_classes;
	port->rport = rport;
}

static void zfcp_scsi_rport_block(struct zfcp_port *port)
{
548 549 550 551
	struct fc_rport *rport = port->rport;

	if (rport)
		fc_remote_port_delete(rport);
552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598
}

void zfcp_scsi_schedule_rport_register(struct zfcp_port *port)
{
	zfcp_port_get(port);
	port->rport_task = RPORT_ADD;

	if (!queue_work(zfcp_data.work_queue, &port->rport_work))
		zfcp_port_put(port);
}

void zfcp_scsi_schedule_rport_block(struct zfcp_port *port)
{
	zfcp_port_get(port);
	port->rport_task = RPORT_DEL;

	if (!queue_work(zfcp_data.work_queue, &port->rport_work))
		zfcp_port_put(port);
}

void zfcp_scsi_schedule_rports_block(struct zfcp_adapter *adapter)
{
	struct zfcp_port *port;

	list_for_each_entry(port, &adapter->port_list_head, list)
		zfcp_scsi_schedule_rport_block(port);
}

void zfcp_scsi_rport_work(struct work_struct *work)
{
	struct zfcp_port *port = container_of(work, struct zfcp_port,
					      rport_work);

	while (port->rport_task) {
		if (port->rport_task == RPORT_ADD) {
			port->rport_task = RPORT_NONE;
			zfcp_scsi_rport_register(port);
		} else {
			port->rport_task = RPORT_NONE;
			zfcp_scsi_rport_block(port);
		}
	}

	zfcp_port_put(port);
}


599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615
void zfcp_scsi_scan(struct work_struct *work)
{
	struct zfcp_unit *unit = container_of(work, struct zfcp_unit,
					      scsi_work);
	struct fc_rport *rport;

	flush_work(&unit->port->rport_work);
	rport = unit->port->rport;

	if (rport && rport->port_state == FC_PORTSTATE_ONLINE)
		scsi_scan_target(&rport->dev, 0, rport->scsi_target_id,
				 scsilun_to_int((struct scsi_lun *)
						&unit->fcp_lun), 0);

	zfcp_unit_put(unit);
}

L
Linus Torvalds 已提交
616 617 618 619
struct fc_function_template zfcp_transport_functions = {
	.show_starget_port_id = 1,
	.show_starget_port_name = 1,
	.show_starget_node_name = 1,
620
	.show_rport_supported_classes = 1,
621
	.show_rport_maxframe_size = 1,
622
	.show_rport_dev_loss_tmo = 1,
623 624
	.show_host_node_name = 1,
	.show_host_port_name = 1,
625
	.show_host_permanent_port_name = 1,
626
	.show_host_supported_classes = 1,
627
	.show_host_supported_speeds = 1,
628
	.show_host_maxframe_size = 1,
629
	.show_host_serial_number = 1,
630 631
	.get_fc_host_stats = zfcp_get_fc_host_stats,
	.reset_fc_host_stats = zfcp_reset_fc_host_stats,
632
	.set_rport_dev_loss_tmo = zfcp_set_rport_dev_loss_tmo,
633
	.get_host_port_state = zfcp_get_host_port_state,
634 635
	.dev_loss_tmo_callbk = zfcp_scsi_dev_loss_tmo_callbk,
	.terminate_rport_io = zfcp_scsi_terminate_rport_io,
636
	.show_host_port_state = 1,
637 638
	/* no functions registered for following dynamic attributes but
	   directly set by LLDD */
639
	.show_host_port_type = 1,
640 641
	.show_host_speed = 1,
	.show_host_port_id = 1,
642
	.disable_target_scan = 1,
L
Linus Torvalds 已提交
643 644
};

645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664
struct zfcp_data zfcp_data = {
	.scsi_host_template = {
		.name			 = "zfcp",
		.module			 = THIS_MODULE,
		.proc_name		 = "zfcp",
		.slave_alloc		 = zfcp_scsi_slave_alloc,
		.slave_configure	 = zfcp_scsi_slave_configure,
		.slave_destroy		 = zfcp_scsi_slave_destroy,
		.queuecommand		 = zfcp_scsi_queuecommand,
		.eh_abort_handler	 = zfcp_scsi_eh_abort_handler,
		.eh_device_reset_handler = zfcp_scsi_eh_device_reset_handler,
		.eh_target_reset_handler = zfcp_scsi_eh_target_reset_handler,
		.eh_host_reset_handler	 = zfcp_scsi_eh_host_reset_handler,
		.can_queue		 = 4096,
		.this_id		 = -1,
		.sg_tablesize		 = ZFCP_MAX_SBALES_PER_REQ,
		.cmd_per_lun		 = 1,
		.use_clustering		 = 1,
		.sdev_attrs		 = zfcp_sysfs_sdev_attrs,
		.max_sectors		 = (ZFCP_MAX_SBALES_PER_REQ * 8),
665
		.shost_attrs		 = zfcp_sysfs_shost_attrs,
666 667
	},
};