1 /* 2 * This file is part of the zfcp device driver for 3 * FCP adapters for IBM System z9 and zSeries. 4 * 5 * (C) Copyright IBM Corp. 2002, 2006 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2, or (at your option) 10 * any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 */ 21 22 /* 23 * Driver authors: 24 * Martin Peschke (originator of the driver) 25 * Raimund Schroeder 26 * Aron Zeh 27 * Wolfgang Taphorn 28 * Stefan Bader 29 * Heiko Carstens (kernel 2.6 port of the driver) 30 * Andreas Herrmann 31 * Maxim Shchetynin 32 * Volker Sameske 33 * Ralph Wuerthner 34 */ 35 36 #include "zfcp_ext.h" 37 38 /* accumulated log level (module parameter) */ 39 static u32 loglevel = ZFCP_LOG_LEVEL_DEFAULTS; 40 static char *device; 41 /*********************** FUNCTION PROTOTYPES *********************************/ 42 43 /* written against the module interface */ 44 static int __init zfcp_module_init(void); 45 46 /* FCP related */ 47 static void zfcp_ns_gid_pn_handler(unsigned long); 48 49 /* miscellaneous */ 50 static int zfcp_sg_list_alloc(struct zfcp_sg_list *, size_t); 51 static void zfcp_sg_list_free(struct zfcp_sg_list *); 52 static int zfcp_sg_list_copy_from_user(struct zfcp_sg_list *, 53 void __user *, size_t); 54 static int zfcp_sg_list_copy_to_user(void __user *, 55 struct zfcp_sg_list *, size_t); 56 static long zfcp_cfdc_dev_ioctl(struct file *, unsigned int, unsigned long); 57 58 #define ZFCP_CFDC_IOC_MAGIC 0xDD 59 #define ZFCP_CFDC_IOC \ 60 _IOWR(ZFCP_CFDC_IOC_MAGIC, 0, struct zfcp_cfdc_sense_data) 61 62 63 static const struct file_operations zfcp_cfdc_fops = { 64 .unlocked_ioctl = zfcp_cfdc_dev_ioctl, 65 #ifdef CONFIG_COMPAT 66 .compat_ioctl = zfcp_cfdc_dev_ioctl 67 #endif 68 }; 69 70 static struct miscdevice zfcp_cfdc_misc = { 71 .minor = ZFCP_CFDC_DEV_MINOR, 72 .name = ZFCP_CFDC_DEV_NAME, 73 .fops = &zfcp_cfdc_fops 74 }; 75 76 /*********************** KERNEL/MODULE PARAMETERS ***************************/ 77 78 /* declare driver module init/cleanup functions */ 79 module_init(zfcp_module_init); 80 81 MODULE_AUTHOR("IBM Deutschland Entwicklung GmbH - linux390@de.ibm.com"); 82 MODULE_DESCRIPTION 83 ("FCP (SCSI over Fibre Channel) HBA driver for IBM System z9 and zSeries"); 84 MODULE_LICENSE("GPL"); 85 86 module_param(device, charp, 0400); 87 MODULE_PARM_DESC(device, "specify initial device"); 88 89 module_param(loglevel, uint, 0400); 90 MODULE_PARM_DESC(loglevel, 91 "log levels, 8 nibbles: " 92 "FC ERP QDIO CIO Config FSF SCSI Other, " 93 "levels: 0=none 1=normal 2=devel 3=trace"); 94 95 /****************************************************************/ 96 /************** Functions without logging ***********************/ 97 /****************************************************************/ 98 99 void 100 _zfcp_hex_dump(char *addr, int count) 101 { 102 int i; 103 for (i = 0; i < count; i++) { 104 printk("%02x", addr[i]); 105 if ((i % 4) == 3) 106 printk(" "); 107 if ((i % 32) == 31) 108 printk("\n"); 109 } 110 if (((i-1) % 32) != 31) 111 printk("\n"); 112 } 113 114 115 /****************************************************************/ 116 /****** Functions to handle the request ID hash table ********/ 117 /****************************************************************/ 118 119 #define ZFCP_LOG_AREA ZFCP_LOG_AREA_FSF 120 121 static int zfcp_reqlist_alloc(struct zfcp_adapter *adapter) 122 { 123 int idx; 124 125 adapter->req_list = kcalloc(REQUEST_LIST_SIZE, sizeof(struct list_head), 126 GFP_KERNEL); 127 if (!adapter->req_list) 128 return -ENOMEM; 129 130 for (idx = 0; idx < REQUEST_LIST_SIZE; idx++) 131 INIT_LIST_HEAD(&adapter->req_list[idx]); 132 return 0; 133 } 134 135 static void zfcp_reqlist_free(struct zfcp_adapter *adapter) 136 { 137 kfree(adapter->req_list); 138 } 139 140 int zfcp_reqlist_isempty(struct zfcp_adapter *adapter) 141 { 142 unsigned int idx; 143 144 for (idx = 0; idx < REQUEST_LIST_SIZE; idx++) 145 if (!list_empty(&adapter->req_list[idx])) 146 return 0; 147 return 1; 148 } 149 150 #undef ZFCP_LOG_AREA 151 152 /****************************************************************/ 153 /************** Uncategorised Functions *************************/ 154 /****************************************************************/ 155 156 #define ZFCP_LOG_AREA ZFCP_LOG_AREA_OTHER 157 158 /** 159 * zfcp_device_setup - setup function 160 * @str: pointer to parameter string 161 * 162 * Parse "device=..." parameter string. 163 */ 164 static int __init 165 zfcp_device_setup(char *devstr) 166 { 167 char *tmp, *str; 168 size_t len; 169 170 if (!devstr) 171 return 0; 172 173 len = strlen(devstr) + 1; 174 str = kmalloc(len, GFP_KERNEL); 175 if (!str) 176 goto err_out; 177 memcpy(str, devstr, len); 178 179 tmp = strchr(str, ','); 180 if (!tmp) 181 goto err_out; 182 *tmp++ = '\0'; 183 strncpy(zfcp_data.init_busid, str, BUS_ID_SIZE); 184 zfcp_data.init_busid[BUS_ID_SIZE-1] = '\0'; 185 186 zfcp_data.init_wwpn = simple_strtoull(tmp, &tmp, 0); 187 if (*tmp++ != ',') 188 goto err_out; 189 if (*tmp == '\0') 190 goto err_out; 191 192 zfcp_data.init_fcp_lun = simple_strtoull(tmp, &tmp, 0); 193 if (*tmp != '\0') 194 goto err_out; 195 kfree(str); 196 return 1; 197 198 err_out: 199 ZFCP_LOG_NORMAL("Parse error for device parameter string %s\n", str); 200 kfree(str); 201 return 0; 202 } 203 204 static void __init 205 zfcp_init_device_configure(void) 206 { 207 struct zfcp_adapter *adapter; 208 struct zfcp_port *port; 209 struct zfcp_unit *unit; 210 211 down(&zfcp_data.config_sema); 212 read_lock_irq(&zfcp_data.config_lock); 213 adapter = zfcp_get_adapter_by_busid(zfcp_data.init_busid); 214 if (adapter) 215 zfcp_adapter_get(adapter); 216 read_unlock_irq(&zfcp_data.config_lock); 217 218 if (adapter == NULL) 219 goto out_adapter; 220 port = zfcp_port_enqueue(adapter, zfcp_data.init_wwpn, 0, 0); 221 if (!port) 222 goto out_port; 223 unit = zfcp_unit_enqueue(port, zfcp_data.init_fcp_lun); 224 if (!unit) 225 goto out_unit; 226 up(&zfcp_data.config_sema); 227 ccw_device_set_online(adapter->ccw_device); 228 zfcp_erp_wait(adapter); 229 down(&zfcp_data.config_sema); 230 zfcp_unit_put(unit); 231 out_unit: 232 zfcp_port_put(port); 233 out_port: 234 zfcp_adapter_put(adapter); 235 out_adapter: 236 up(&zfcp_data.config_sema); 237 return; 238 } 239 240 static int calc_alignment(int size) 241 { 242 int align = 1; 243 244 if (!size) 245 return 0; 246 247 while ((size - align) > 0) 248 align <<= 1; 249 250 return align; 251 } 252 253 static int __init 254 zfcp_module_init(void) 255 { 256 int retval = -ENOMEM; 257 int size, align; 258 259 size = sizeof(struct zfcp_fsf_req_qtcb); 260 align = calc_alignment(size); 261 zfcp_data.fsf_req_qtcb_cache = 262 kmem_cache_create("zfcp_fsf", size, align, 0, NULL); 263 if (!zfcp_data.fsf_req_qtcb_cache) 264 goto out; 265 266 size = sizeof(struct fsf_status_read_buffer); 267 align = calc_alignment(size); 268 zfcp_data.sr_buffer_cache = 269 kmem_cache_create("zfcp_sr", size, align, 0, NULL); 270 if (!zfcp_data.sr_buffer_cache) 271 goto out_sr_cache; 272 273 size = sizeof(struct zfcp_gid_pn_data); 274 align = calc_alignment(size); 275 zfcp_data.gid_pn_cache = 276 kmem_cache_create("zfcp_gid", size, align, 0, NULL); 277 if (!zfcp_data.gid_pn_cache) 278 goto out_gid_cache; 279 280 atomic_set(&zfcp_data.loglevel, loglevel); 281 282 /* initialize adapter list */ 283 INIT_LIST_HEAD(&zfcp_data.adapter_list_head); 284 285 /* initialize adapters to be removed list head */ 286 INIT_LIST_HEAD(&zfcp_data.adapter_remove_lh); 287 288 zfcp_data.scsi_transport_template = 289 fc_attach_transport(&zfcp_transport_functions); 290 if (!zfcp_data.scsi_transport_template) 291 goto out_transport; 292 293 retval = misc_register(&zfcp_cfdc_misc); 294 if (retval != 0) { 295 ZFCP_LOG_INFO("registration of misc device " 296 "zfcp_cfdc failed\n"); 297 goto out_misc; 298 } 299 300 ZFCP_LOG_TRACE("major/minor for zfcp_cfdc: %d/%d\n", 301 ZFCP_CFDC_DEV_MAJOR, zfcp_cfdc_misc.minor); 302 303 /* Initialise proc semaphores */ 304 sema_init(&zfcp_data.config_sema, 1); 305 306 /* initialise configuration rw lock */ 307 rwlock_init(&zfcp_data.config_lock); 308 309 /* setup dynamic I/O */ 310 retval = zfcp_ccw_register(); 311 if (retval) { 312 ZFCP_LOG_NORMAL("registration with common I/O layer failed\n"); 313 goto out_ccw_register; 314 } 315 316 if (zfcp_device_setup(device)) 317 zfcp_init_device_configure(); 318 319 goto out; 320 321 out_ccw_register: 322 misc_deregister(&zfcp_cfdc_misc); 323 out_misc: 324 fc_release_transport(zfcp_data.scsi_transport_template); 325 out_transport: 326 kmem_cache_destroy(zfcp_data.gid_pn_cache); 327 out_gid_cache: 328 kmem_cache_destroy(zfcp_data.sr_buffer_cache); 329 out_sr_cache: 330 kmem_cache_destroy(zfcp_data.fsf_req_qtcb_cache); 331 out: 332 return retval; 333 } 334 335 /* 336 * function: zfcp_cfdc_dev_ioctl 337 * 338 * purpose: Handle control file upload/download transaction via IOCTL 339 * interface 340 * 341 * returns: 0 - Operation completed successfuly 342 * -ENOTTY - Unknown IOCTL command 343 * -EINVAL - Invalid sense data record 344 * -ENXIO - The FCP adapter is not available 345 * -EOPNOTSUPP - The FCP adapter does not have CFDC support 346 * -ENOMEM - Insufficient memory 347 * -EFAULT - User space memory I/O operation fault 348 * -EPERM - Cannot create or queue FSF request or create SBALs 349 * -ERESTARTSYS- Received signal (is mapped to EAGAIN by VFS) 350 */ 351 static long 352 zfcp_cfdc_dev_ioctl(struct file *file, unsigned int command, 353 unsigned long buffer) 354 { 355 struct zfcp_cfdc_sense_data *sense_data, __user *sense_data_user; 356 struct zfcp_adapter *adapter = NULL; 357 struct zfcp_fsf_req *fsf_req = NULL; 358 struct zfcp_sg_list *sg_list = NULL; 359 u32 fsf_command, option; 360 char *bus_id = NULL; 361 int retval = 0; 362 363 sense_data = kmalloc(sizeof(struct zfcp_cfdc_sense_data), GFP_KERNEL); 364 if (sense_data == NULL) { 365 retval = -ENOMEM; 366 goto out; 367 } 368 369 sg_list = kzalloc(sizeof(struct zfcp_sg_list), GFP_KERNEL); 370 if (sg_list == NULL) { 371 retval = -ENOMEM; 372 goto out; 373 } 374 375 if (command != ZFCP_CFDC_IOC) { 376 ZFCP_LOG_INFO("IOC request code 0x%x invalid\n", command); 377 retval = -ENOTTY; 378 goto out; 379 } 380 381 if ((sense_data_user = (void __user *) buffer) == NULL) { 382 ZFCP_LOG_INFO("sense data record is required\n"); 383 retval = -EINVAL; 384 goto out; 385 } 386 387 retval = copy_from_user(sense_data, sense_data_user, 388 sizeof(struct zfcp_cfdc_sense_data)); 389 if (retval) { 390 retval = -EFAULT; 391 goto out; 392 } 393 394 if (sense_data->signature != ZFCP_CFDC_SIGNATURE) { 395 ZFCP_LOG_INFO("invalid sense data request signature 0x%08x\n", 396 ZFCP_CFDC_SIGNATURE); 397 retval = -EINVAL; 398 goto out; 399 } 400 401 switch (sense_data->command) { 402 403 case ZFCP_CFDC_CMND_DOWNLOAD_NORMAL: 404 fsf_command = FSF_QTCB_DOWNLOAD_CONTROL_FILE; 405 option = FSF_CFDC_OPTION_NORMAL_MODE; 406 break; 407 408 case ZFCP_CFDC_CMND_DOWNLOAD_FORCE: 409 fsf_command = FSF_QTCB_DOWNLOAD_CONTROL_FILE; 410 option = FSF_CFDC_OPTION_FORCE; 411 break; 412 413 case ZFCP_CFDC_CMND_FULL_ACCESS: 414 fsf_command = FSF_QTCB_DOWNLOAD_CONTROL_FILE; 415 option = FSF_CFDC_OPTION_FULL_ACCESS; 416 break; 417 418 case ZFCP_CFDC_CMND_RESTRICTED_ACCESS: 419 fsf_command = FSF_QTCB_DOWNLOAD_CONTROL_FILE; 420 option = FSF_CFDC_OPTION_RESTRICTED_ACCESS; 421 break; 422 423 case ZFCP_CFDC_CMND_UPLOAD: 424 fsf_command = FSF_QTCB_UPLOAD_CONTROL_FILE; 425 option = 0; 426 break; 427 428 default: 429 ZFCP_LOG_INFO("invalid command code 0x%08x\n", 430 sense_data->command); 431 retval = -EINVAL; 432 goto out; 433 } 434 435 bus_id = kmalloc(BUS_ID_SIZE, GFP_KERNEL); 436 if (bus_id == NULL) { 437 retval = -ENOMEM; 438 goto out; 439 } 440 snprintf(bus_id, BUS_ID_SIZE, "%d.%d.%04x", 441 (sense_data->devno >> 24), 442 (sense_data->devno >> 16) & 0xFF, 443 (sense_data->devno & 0xFFFF)); 444 445 read_lock_irq(&zfcp_data.config_lock); 446 adapter = zfcp_get_adapter_by_busid(bus_id); 447 if (adapter) 448 zfcp_adapter_get(adapter); 449 read_unlock_irq(&zfcp_data.config_lock); 450 451 kfree(bus_id); 452 453 if (adapter == NULL) { 454 ZFCP_LOG_INFO("invalid adapter\n"); 455 retval = -ENXIO; 456 goto out; 457 } 458 459 if (sense_data->command & ZFCP_CFDC_WITH_CONTROL_FILE) { 460 retval = zfcp_sg_list_alloc(sg_list, 461 ZFCP_CFDC_MAX_CONTROL_FILE_SIZE); 462 if (retval) { 463 retval = -ENOMEM; 464 goto out; 465 } 466 } 467 468 if ((sense_data->command & ZFCP_CFDC_DOWNLOAD) && 469 (sense_data->command & ZFCP_CFDC_WITH_CONTROL_FILE)) { 470 retval = zfcp_sg_list_copy_from_user( 471 sg_list, &sense_data_user->control_file, 472 ZFCP_CFDC_MAX_CONTROL_FILE_SIZE); 473 if (retval) { 474 retval = -EFAULT; 475 goto out; 476 } 477 } 478 479 retval = zfcp_fsf_control_file(adapter, &fsf_req, fsf_command, 480 option, sg_list); 481 if (retval) 482 goto out; 483 484 if ((fsf_req->qtcb->prefix.prot_status != FSF_PROT_GOOD) && 485 (fsf_req->qtcb->prefix.prot_status != FSF_PROT_FSF_STATUS_PRESENTED)) { 486 retval = -ENXIO; 487 goto out; 488 } 489 490 sense_data->fsf_status = fsf_req->qtcb->header.fsf_status; 491 memcpy(&sense_data->fsf_status_qual, 492 &fsf_req->qtcb->header.fsf_status_qual, 493 sizeof(union fsf_status_qual)); 494 memcpy(&sense_data->payloads, &fsf_req->qtcb->bottom.support.els, 256); 495 496 retval = copy_to_user(sense_data_user, sense_data, 497 sizeof(struct zfcp_cfdc_sense_data)); 498 if (retval) { 499 retval = -EFAULT; 500 goto out; 501 } 502 503 if (sense_data->command & ZFCP_CFDC_UPLOAD) { 504 retval = zfcp_sg_list_copy_to_user( 505 &sense_data_user->control_file, sg_list, 506 ZFCP_CFDC_MAX_CONTROL_FILE_SIZE); 507 if (retval) { 508 retval = -EFAULT; 509 goto out; 510 } 511 } 512 513 out: 514 if (fsf_req != NULL) 515 zfcp_fsf_req_free(fsf_req); 516 517 if ((adapter != NULL) && (retval != -ENXIO)) 518 zfcp_adapter_put(adapter); 519 520 if (sg_list != NULL) { 521 zfcp_sg_list_free(sg_list); 522 kfree(sg_list); 523 } 524 525 kfree(sense_data); 526 527 return retval; 528 } 529 530 531 /** 532 * zfcp_sg_list_alloc - create a scatter-gather list of the specified size 533 * @sg_list: structure describing a scatter gather list 534 * @size: size of scatter-gather list 535 * Return: 0 on success, else -ENOMEM 536 * 537 * In sg_list->sg a pointer to the created scatter-gather list is returned, 538 * or NULL if we run out of memory. sg_list->count specifies the number of 539 * elements of the scatter-gather list. The maximum size of a single element 540 * in the scatter-gather list is PAGE_SIZE. 541 */ 542 static int 543 zfcp_sg_list_alloc(struct zfcp_sg_list *sg_list, size_t size) 544 { 545 struct scatterlist *sg; 546 unsigned int i; 547 int retval = 0; 548 void *address; 549 550 BUG_ON(sg_list == NULL); 551 552 sg_list->count = size >> PAGE_SHIFT; 553 if (size & ~PAGE_MASK) 554 sg_list->count++; 555 sg_list->sg = kcalloc(sg_list->count, sizeof(struct scatterlist), 556 GFP_KERNEL); 557 if (sg_list->sg == NULL) { 558 sg_list->count = 0; 559 retval = -ENOMEM; 560 goto out; 561 } 562 563 for (i = 0, sg = sg_list->sg; i < sg_list->count; i++, sg++) { 564 sg->length = min(size, PAGE_SIZE); 565 sg->offset = 0; 566 address = (void *) get_zeroed_page(GFP_KERNEL); 567 if (address == NULL) { 568 sg_list->count = i; 569 zfcp_sg_list_free(sg_list); 570 retval = -ENOMEM; 571 goto out; 572 } 573 zfcp_address_to_sg(address, sg); 574 size -= sg->length; 575 } 576 577 out: 578 return retval; 579 } 580 581 582 /** 583 * zfcp_sg_list_free - free memory of a scatter-gather list 584 * @sg_list: structure describing a scatter-gather list 585 * 586 * Memory for each element in the scatter-gather list is freed. 587 * Finally sg_list->sg is freed itself and sg_list->count is reset. 588 */ 589 static void 590 zfcp_sg_list_free(struct zfcp_sg_list *sg_list) 591 { 592 struct scatterlist *sg; 593 unsigned int i; 594 595 BUG_ON(sg_list == NULL); 596 597 for (i = 0, sg = sg_list->sg; i < sg_list->count; i++, sg++) 598 free_page((unsigned long) zfcp_sg_to_address(sg)); 599 600 sg_list->count = 0; 601 kfree(sg_list->sg); 602 } 603 604 /** 605 * zfcp_sg_size - determine size of a scatter-gather list 606 * @sg: array of (struct scatterlist) 607 * @sg_count: elements in array 608 * Return: size of entire scatter-gather list 609 */ 610 static size_t zfcp_sg_size(struct scatterlist *sg, unsigned int sg_count) 611 { 612 unsigned int i; 613 struct scatterlist *p; 614 size_t size; 615 616 size = 0; 617 for (i = 0, p = sg; i < sg_count; i++, p++) { 618 BUG_ON(p == NULL); 619 size += p->length; 620 } 621 622 return size; 623 } 624 625 626 /** 627 * zfcp_sg_list_copy_from_user -copy data from user space to scatter-gather list 628 * @sg_list: structure describing a scatter-gather list 629 * @user_buffer: pointer to buffer in user space 630 * @size: number of bytes to be copied 631 * Return: 0 on success, -EFAULT if copy_from_user fails. 632 */ 633 static int 634 zfcp_sg_list_copy_from_user(struct zfcp_sg_list *sg_list, 635 void __user *user_buffer, 636 size_t size) 637 { 638 struct scatterlist *sg; 639 unsigned int length; 640 void *zfcp_buffer; 641 int retval = 0; 642 643 BUG_ON(sg_list == NULL); 644 645 if (zfcp_sg_size(sg_list->sg, sg_list->count) < size) 646 return -EFAULT; 647 648 for (sg = sg_list->sg; size > 0; sg++) { 649 length = min((unsigned int)size, sg->length); 650 zfcp_buffer = zfcp_sg_to_address(sg); 651 if (copy_from_user(zfcp_buffer, user_buffer, length)) { 652 retval = -EFAULT; 653 goto out; 654 } 655 user_buffer += length; 656 size -= length; 657 } 658 659 out: 660 return retval; 661 } 662 663 664 /** 665 * zfcp_sg_list_copy_to_user - copy data from scatter-gather list to user space 666 * @user_buffer: pointer to buffer in user space 667 * @sg_list: structure describing a scatter-gather list 668 * @size: number of bytes to be copied 669 * Return: 0 on success, -EFAULT if copy_to_user fails 670 */ 671 static int 672 zfcp_sg_list_copy_to_user(void __user *user_buffer, 673 struct zfcp_sg_list *sg_list, 674 size_t size) 675 { 676 struct scatterlist *sg; 677 unsigned int length; 678 void *zfcp_buffer; 679 int retval = 0; 680 681 BUG_ON(sg_list == NULL); 682 683 if (zfcp_sg_size(sg_list->sg, sg_list->count) < size) 684 return -EFAULT; 685 686 for (sg = sg_list->sg; size > 0; sg++) { 687 length = min((unsigned int) size, sg->length); 688 zfcp_buffer = zfcp_sg_to_address(sg); 689 if (copy_to_user(user_buffer, zfcp_buffer, length)) { 690 retval = -EFAULT; 691 goto out; 692 } 693 user_buffer += length; 694 size -= length; 695 } 696 697 out: 698 return retval; 699 } 700 701 702 #undef ZFCP_LOG_AREA 703 704 /****************************************************************/ 705 /****** Functions for configuration/set-up of structures ********/ 706 /****************************************************************/ 707 708 #define ZFCP_LOG_AREA ZFCP_LOG_AREA_CONFIG 709 710 /** 711 * zfcp_get_unit_by_lun - find unit in unit list of port by FCP LUN 712 * @port: pointer to port to search for unit 713 * @fcp_lun: FCP LUN to search for 714 * Traverse list of all units of a port and return pointer to a unit 715 * with the given FCP LUN. 716 */ 717 struct zfcp_unit * 718 zfcp_get_unit_by_lun(struct zfcp_port *port, fcp_lun_t fcp_lun) 719 { 720 struct zfcp_unit *unit; 721 int found = 0; 722 723 list_for_each_entry(unit, &port->unit_list_head, list) { 724 if ((unit->fcp_lun == fcp_lun) && 725 !atomic_test_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status)) 726 { 727 found = 1; 728 break; 729 } 730 } 731 return found ? unit : NULL; 732 } 733 734 /** 735 * zfcp_get_port_by_wwpn - find port in port list of adapter by wwpn 736 * @adapter: pointer to adapter to search for port 737 * @wwpn: wwpn to search for 738 * Traverse list of all ports of an adapter and return pointer to a port 739 * with the given wwpn. 740 */ 741 struct zfcp_port * 742 zfcp_get_port_by_wwpn(struct zfcp_adapter *adapter, wwn_t wwpn) 743 { 744 struct zfcp_port *port; 745 int found = 0; 746 747 list_for_each_entry(port, &adapter->port_list_head, list) { 748 if ((port->wwpn == wwpn) && 749 !(atomic_read(&port->status) & 750 (ZFCP_STATUS_PORT_NO_WWPN | ZFCP_STATUS_COMMON_REMOVE))) { 751 found = 1; 752 break; 753 } 754 } 755 return found ? port : NULL; 756 } 757 758 /** 759 * zfcp_get_port_by_did - find port in port list of adapter by d_id 760 * @adapter: pointer to adapter to search for port 761 * @d_id: d_id to search for 762 * Traverse list of all ports of an adapter and return pointer to a port 763 * with the given d_id. 764 */ 765 struct zfcp_port * 766 zfcp_get_port_by_did(struct zfcp_adapter *adapter, u32 d_id) 767 { 768 struct zfcp_port *port; 769 int found = 0; 770 771 list_for_each_entry(port, &adapter->port_list_head, list) { 772 if ((port->d_id == d_id) && 773 !atomic_test_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status)) 774 { 775 found = 1; 776 break; 777 } 778 } 779 return found ? port : NULL; 780 } 781 782 /** 783 * zfcp_get_adapter_by_busid - find adpater in adapter list by bus_id 784 * @bus_id: bus_id to search for 785 * Traverse list of all adapters and return pointer to an adapter 786 * with the given bus_id. 787 */ 788 struct zfcp_adapter * 789 zfcp_get_adapter_by_busid(char *bus_id) 790 { 791 struct zfcp_adapter *adapter; 792 int found = 0; 793 794 list_for_each_entry(adapter, &zfcp_data.adapter_list_head, list) { 795 if ((strncmp(bus_id, zfcp_get_busid_by_adapter(adapter), 796 BUS_ID_SIZE) == 0) && 797 !atomic_test_mask(ZFCP_STATUS_COMMON_REMOVE, 798 &adapter->status)){ 799 found = 1; 800 break; 801 } 802 } 803 return found ? adapter : NULL; 804 } 805 806 /** 807 * zfcp_unit_enqueue - enqueue unit to unit list of a port. 808 * @port: pointer to port where unit is added 809 * @fcp_lun: FCP LUN of unit to be enqueued 810 * Return: pointer to enqueued unit on success, NULL on error 811 * Locks: config_sema must be held to serialize changes to the unit list 812 * 813 * Sets up some unit internal structures and creates sysfs entry. 814 */ 815 struct zfcp_unit * 816 zfcp_unit_enqueue(struct zfcp_port *port, fcp_lun_t fcp_lun) 817 { 818 struct zfcp_unit *unit; 819 820 /* 821 * check that there is no unit with this FCP_LUN already in list 822 * and enqueue it. 823 * Note: Unlike for the adapter and the port, this is an error 824 */ 825 read_lock_irq(&zfcp_data.config_lock); 826 unit = zfcp_get_unit_by_lun(port, fcp_lun); 827 read_unlock_irq(&zfcp_data.config_lock); 828 if (unit) 829 return NULL; 830 831 unit = kzalloc(sizeof (struct zfcp_unit), GFP_KERNEL); 832 if (!unit) 833 return NULL; 834 835 /* initialise reference count stuff */ 836 atomic_set(&unit->refcount, 0); 837 init_waitqueue_head(&unit->remove_wq); 838 839 unit->port = port; 840 unit->fcp_lun = fcp_lun; 841 842 /* setup for sysfs registration */ 843 snprintf(unit->sysfs_device.bus_id, BUS_ID_SIZE, "0x%016llx", fcp_lun); 844 unit->sysfs_device.parent = &port->sysfs_device; 845 unit->sysfs_device.release = zfcp_sysfs_unit_release; 846 dev_set_drvdata(&unit->sysfs_device, unit); 847 848 init_waitqueue_head(&unit->scsi_scan_wq); 849 850 /* mark unit unusable as long as sysfs registration is not complete */ 851 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status); 852 853 if (device_register(&unit->sysfs_device)) { 854 kfree(unit); 855 return NULL; 856 } 857 858 if (zfcp_sysfs_unit_create_files(&unit->sysfs_device)) { 859 device_unregister(&unit->sysfs_device); 860 return NULL; 861 } 862 863 zfcp_unit_get(unit); 864 unit->scsi_lun = scsilun_to_int((struct scsi_lun *)&unit->fcp_lun); 865 866 write_lock_irq(&zfcp_data.config_lock); 867 list_add_tail(&unit->list, &port->unit_list_head); 868 atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status); 869 atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &unit->status); 870 write_unlock_irq(&zfcp_data.config_lock); 871 872 port->units++; 873 zfcp_port_get(port); 874 875 return unit; 876 } 877 878 void 879 zfcp_unit_dequeue(struct zfcp_unit *unit) 880 { 881 zfcp_unit_wait(unit); 882 write_lock_irq(&zfcp_data.config_lock); 883 list_del(&unit->list); 884 write_unlock_irq(&zfcp_data.config_lock); 885 unit->port->units--; 886 zfcp_port_put(unit->port); 887 zfcp_sysfs_unit_remove_files(&unit->sysfs_device); 888 device_unregister(&unit->sysfs_device); 889 } 890 891 /* 892 * Allocates a combined QTCB/fsf_req buffer for erp actions and fcp/SCSI 893 * commands. 894 * It also genrates fcp-nameserver request/response buffer and unsolicited 895 * status read fsf_req buffers. 896 * 897 * locks: must only be called with zfcp_data.config_sema taken 898 */ 899 static int 900 zfcp_allocate_low_mem_buffers(struct zfcp_adapter *adapter) 901 { 902 adapter->pool.fsf_req_erp = 903 mempool_create_slab_pool(ZFCP_POOL_FSF_REQ_ERP_NR, 904 zfcp_data.fsf_req_qtcb_cache); 905 if (!adapter->pool.fsf_req_erp) 906 return -ENOMEM; 907 908 adapter->pool.fsf_req_scsi = 909 mempool_create_slab_pool(ZFCP_POOL_FSF_REQ_SCSI_NR, 910 zfcp_data.fsf_req_qtcb_cache); 911 if (!adapter->pool.fsf_req_scsi) 912 return -ENOMEM; 913 914 adapter->pool.fsf_req_abort = 915 mempool_create_slab_pool(ZFCP_POOL_FSF_REQ_ABORT_NR, 916 zfcp_data.fsf_req_qtcb_cache); 917 if (!adapter->pool.fsf_req_abort) 918 return -ENOMEM; 919 920 adapter->pool.fsf_req_status_read = 921 mempool_create_kmalloc_pool(ZFCP_POOL_STATUS_READ_NR, 922 sizeof(struct zfcp_fsf_req)); 923 if (!adapter->pool.fsf_req_status_read) 924 return -ENOMEM; 925 926 adapter->pool.data_status_read = 927 mempool_create_slab_pool(ZFCP_POOL_STATUS_READ_NR, 928 zfcp_data.sr_buffer_cache); 929 if (!adapter->pool.data_status_read) 930 return -ENOMEM; 931 932 adapter->pool.data_gid_pn = 933 mempool_create_slab_pool(ZFCP_POOL_DATA_GID_PN_NR, 934 zfcp_data.gid_pn_cache); 935 if (!adapter->pool.data_gid_pn) 936 return -ENOMEM; 937 938 return 0; 939 } 940 941 /** 942 * zfcp_free_low_mem_buffers - free memory pools of an adapter 943 * @adapter: pointer to zfcp_adapter for which memory pools should be freed 944 * locking: zfcp_data.config_sema must be held 945 */ 946 static void 947 zfcp_free_low_mem_buffers(struct zfcp_adapter *adapter) 948 { 949 if (adapter->pool.fsf_req_erp) 950 mempool_destroy(adapter->pool.fsf_req_erp); 951 if (adapter->pool.fsf_req_scsi) 952 mempool_destroy(adapter->pool.fsf_req_scsi); 953 if (adapter->pool.fsf_req_abort) 954 mempool_destroy(adapter->pool.fsf_req_abort); 955 if (adapter->pool.fsf_req_status_read) 956 mempool_destroy(adapter->pool.fsf_req_status_read); 957 if (adapter->pool.data_status_read) 958 mempool_destroy(adapter->pool.data_status_read); 959 if (adapter->pool.data_gid_pn) 960 mempool_destroy(adapter->pool.data_gid_pn); 961 } 962 963 static void zfcp_dummy_release(struct device *dev) 964 { 965 return; 966 } 967 968 /* 969 * Enqueues an adapter at the end of the adapter list in the driver data. 970 * All adapter internal structures are set up. 971 * Proc-fs entries are also created. 972 * 973 * returns: 0 if a new adapter was successfully enqueued 974 * ZFCP_KNOWN if an adapter with this devno was already present 975 * -ENOMEM if alloc failed 976 * locks: config_sema must be held to serialise changes to the adapter list 977 */ 978 struct zfcp_adapter * 979 zfcp_adapter_enqueue(struct ccw_device *ccw_device) 980 { 981 int retval = 0; 982 struct zfcp_adapter *adapter; 983 984 /* 985 * Note: It is safe to release the list_lock, as any list changes 986 * are protected by the config_sema, which must be held to get here 987 */ 988 989 /* try to allocate new adapter data structure (zeroed) */ 990 adapter = kzalloc(sizeof (struct zfcp_adapter), GFP_KERNEL); 991 if (!adapter) { 992 ZFCP_LOG_INFO("error: allocation of base adapter " 993 "structure failed\n"); 994 goto out; 995 } 996 997 ccw_device->handler = NULL; 998 999 /* save ccw_device pointer */ 1000 adapter->ccw_device = ccw_device; 1001 1002 retval = zfcp_qdio_allocate_queues(adapter); 1003 if (retval) 1004 goto queues_alloc_failed; 1005 1006 retval = zfcp_qdio_allocate(adapter); 1007 if (retval) 1008 goto qdio_allocate_failed; 1009 1010 retval = zfcp_allocate_low_mem_buffers(adapter); 1011 if (retval) { 1012 ZFCP_LOG_INFO("error: pool allocation failed\n"); 1013 goto failed_low_mem_buffers; 1014 } 1015 1016 /* initialise reference count stuff */ 1017 atomic_set(&adapter->refcount, 0); 1018 init_waitqueue_head(&adapter->remove_wq); 1019 1020 /* initialise list of ports */ 1021 INIT_LIST_HEAD(&adapter->port_list_head); 1022 1023 /* initialise list of ports to be removed */ 1024 INIT_LIST_HEAD(&adapter->port_remove_lh); 1025 1026 /* initialize list of fsf requests */ 1027 spin_lock_init(&adapter->req_list_lock); 1028 retval = zfcp_reqlist_alloc(adapter); 1029 if (retval) { 1030 ZFCP_LOG_INFO("request list initialization failed\n"); 1031 goto failed_low_mem_buffers; 1032 } 1033 1034 /* initialize debug locks */ 1035 1036 spin_lock_init(&adapter->erp_dbf_lock); 1037 spin_lock_init(&adapter->hba_dbf_lock); 1038 spin_lock_init(&adapter->san_dbf_lock); 1039 spin_lock_init(&adapter->scsi_dbf_lock); 1040 1041 /* initialize error recovery stuff */ 1042 1043 rwlock_init(&adapter->erp_lock); 1044 sema_init(&adapter->erp_ready_sem, 0); 1045 INIT_LIST_HEAD(&adapter->erp_ready_head); 1046 INIT_LIST_HEAD(&adapter->erp_running_head); 1047 1048 /* initialize abort lock */ 1049 rwlock_init(&adapter->abort_lock); 1050 1051 /* initialise some erp stuff */ 1052 init_waitqueue_head(&adapter->erp_thread_wqh); 1053 init_waitqueue_head(&adapter->erp_done_wqh); 1054 1055 /* initialize lock of associated request queue */ 1056 rwlock_init(&adapter->request_queue.queue_lock); 1057 1058 /* mark adapter unusable as long as sysfs registration is not complete */ 1059 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status); 1060 1061 adapter->ccw_device = ccw_device; 1062 dev_set_drvdata(&ccw_device->dev, adapter); 1063 1064 if (zfcp_sysfs_adapter_create_files(&ccw_device->dev)) 1065 goto sysfs_failed; 1066 1067 adapter->generic_services.parent = &adapter->ccw_device->dev; 1068 adapter->generic_services.release = zfcp_dummy_release; 1069 snprintf(adapter->generic_services.bus_id, BUS_ID_SIZE, 1070 "generic_services"); 1071 1072 if (device_register(&adapter->generic_services)) 1073 goto generic_services_failed; 1074 1075 /* put allocated adapter at list tail */ 1076 write_lock_irq(&zfcp_data.config_lock); 1077 atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status); 1078 list_add_tail(&adapter->list, &zfcp_data.adapter_list_head); 1079 write_unlock_irq(&zfcp_data.config_lock); 1080 1081 zfcp_data.adapters++; 1082 1083 goto out; 1084 1085 generic_services_failed: 1086 zfcp_sysfs_adapter_remove_files(&adapter->ccw_device->dev); 1087 sysfs_failed: 1088 dev_set_drvdata(&ccw_device->dev, NULL); 1089 zfcp_reqlist_free(adapter); 1090 failed_low_mem_buffers: 1091 zfcp_free_low_mem_buffers(adapter); 1092 if (qdio_free(ccw_device) != 0) 1093 ZFCP_LOG_NORMAL("bug: qdio_free for adapter %s failed\n", 1094 zfcp_get_busid_by_adapter(adapter)); 1095 qdio_allocate_failed: 1096 zfcp_qdio_free_queues(adapter); 1097 queues_alloc_failed: 1098 kfree(adapter); 1099 adapter = NULL; 1100 out: 1101 return adapter; 1102 } 1103 1104 /* 1105 * returns: 0 - struct zfcp_adapter data structure successfully removed 1106 * !0 - struct zfcp_adapter data structure could not be removed 1107 * (e.g. still used) 1108 * locks: adapter list write lock is assumed to be held by caller 1109 */ 1110 void 1111 zfcp_adapter_dequeue(struct zfcp_adapter *adapter) 1112 { 1113 int retval = 0; 1114 unsigned long flags; 1115 1116 zfcp_adapter_scsi_unregister(adapter); 1117 device_unregister(&adapter->generic_services); 1118 zfcp_sysfs_adapter_remove_files(&adapter->ccw_device->dev); 1119 dev_set_drvdata(&adapter->ccw_device->dev, NULL); 1120 /* sanity check: no pending FSF requests */ 1121 spin_lock_irqsave(&adapter->req_list_lock, flags); 1122 retval = zfcp_reqlist_isempty(adapter); 1123 spin_unlock_irqrestore(&adapter->req_list_lock, flags); 1124 if (!retval) { 1125 ZFCP_LOG_NORMAL("bug: adapter %s (%p) still in use, " 1126 "%i requests outstanding\n", 1127 zfcp_get_busid_by_adapter(adapter), adapter, 1128 atomic_read(&adapter->reqs_active)); 1129 retval = -EBUSY; 1130 goto out; 1131 } 1132 1133 /* remove specified adapter data structure from list */ 1134 write_lock_irq(&zfcp_data.config_lock); 1135 list_del(&adapter->list); 1136 write_unlock_irq(&zfcp_data.config_lock); 1137 1138 /* decrease number of adapters in list */ 1139 zfcp_data.adapters--; 1140 1141 ZFCP_LOG_TRACE("adapter %s (%p) removed from list, " 1142 "%i adapters still in list\n", 1143 zfcp_get_busid_by_adapter(adapter), 1144 adapter, zfcp_data.adapters); 1145 1146 retval = qdio_free(adapter->ccw_device); 1147 if (retval) 1148 ZFCP_LOG_NORMAL("bug: qdio_free for adapter %s failed\n", 1149 zfcp_get_busid_by_adapter(adapter)); 1150 1151 zfcp_free_low_mem_buffers(adapter); 1152 /* free memory of adapter data structure and queues */ 1153 zfcp_qdio_free_queues(adapter); 1154 zfcp_reqlist_free(adapter); 1155 kfree(adapter->fc_stats); 1156 kfree(adapter->stats_reset_data); 1157 ZFCP_LOG_TRACE("freeing adapter structure\n"); 1158 kfree(adapter); 1159 out: 1160 return; 1161 } 1162 1163 /** 1164 * zfcp_port_enqueue - enqueue port to port list of adapter 1165 * @adapter: adapter where remote port is added 1166 * @wwpn: WWPN of the remote port to be enqueued 1167 * @status: initial status for the port 1168 * @d_id: destination id of the remote port to be enqueued 1169 * Return: pointer to enqueued port on success, NULL on error 1170 * Locks: config_sema must be held to serialize changes to the port list 1171 * 1172 * All port internal structures are set up and the sysfs entry is generated. 1173 * d_id is used to enqueue ports with a well known address like the Directory 1174 * Service for nameserver lookup. 1175 */ 1176 struct zfcp_port * 1177 zfcp_port_enqueue(struct zfcp_adapter *adapter, wwn_t wwpn, u32 status, 1178 u32 d_id) 1179 { 1180 struct zfcp_port *port; 1181 int check_wwpn; 1182 1183 check_wwpn = !(status & ZFCP_STATUS_PORT_NO_WWPN); 1184 /* 1185 * check that there is no port with this WWPN already in list 1186 */ 1187 if (check_wwpn) { 1188 read_lock_irq(&zfcp_data.config_lock); 1189 port = zfcp_get_port_by_wwpn(adapter, wwpn); 1190 read_unlock_irq(&zfcp_data.config_lock); 1191 if (port) 1192 return NULL; 1193 } 1194 1195 port = kzalloc(sizeof (struct zfcp_port), GFP_KERNEL); 1196 if (!port) 1197 return NULL; 1198 1199 /* initialise reference count stuff */ 1200 atomic_set(&port->refcount, 0); 1201 init_waitqueue_head(&port->remove_wq); 1202 1203 INIT_LIST_HEAD(&port->unit_list_head); 1204 INIT_LIST_HEAD(&port->unit_remove_lh); 1205 1206 port->adapter = adapter; 1207 1208 if (check_wwpn) 1209 port->wwpn = wwpn; 1210 1211 atomic_set_mask(status, &port->status); 1212 1213 /* setup for sysfs registration */ 1214 if (status & ZFCP_STATUS_PORT_WKA) { 1215 switch (d_id) { 1216 case ZFCP_DID_DIRECTORY_SERVICE: 1217 snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE, 1218 "directory"); 1219 break; 1220 case ZFCP_DID_MANAGEMENT_SERVICE: 1221 snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE, 1222 "management"); 1223 break; 1224 case ZFCP_DID_KEY_DISTRIBUTION_SERVICE: 1225 snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE, 1226 "key_distribution"); 1227 break; 1228 case ZFCP_DID_ALIAS_SERVICE: 1229 snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE, 1230 "alias"); 1231 break; 1232 case ZFCP_DID_TIME_SERVICE: 1233 snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE, 1234 "time"); 1235 break; 1236 default: 1237 kfree(port); 1238 return NULL; 1239 } 1240 port->d_id = d_id; 1241 port->sysfs_device.parent = &adapter->generic_services; 1242 } else { 1243 snprintf(port->sysfs_device.bus_id, 1244 BUS_ID_SIZE, "0x%016llx", wwpn); 1245 port->sysfs_device.parent = &adapter->ccw_device->dev; 1246 } 1247 port->sysfs_device.release = zfcp_sysfs_port_release; 1248 dev_set_drvdata(&port->sysfs_device, port); 1249 1250 /* mark port unusable as long as sysfs registration is not complete */ 1251 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status); 1252 1253 if (device_register(&port->sysfs_device)) { 1254 kfree(port); 1255 return NULL; 1256 } 1257 1258 if (zfcp_sysfs_port_create_files(&port->sysfs_device, status)) { 1259 device_unregister(&port->sysfs_device); 1260 return NULL; 1261 } 1262 1263 zfcp_port_get(port); 1264 1265 write_lock_irq(&zfcp_data.config_lock); 1266 list_add_tail(&port->list, &adapter->port_list_head); 1267 atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status); 1268 atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &port->status); 1269 if (d_id == ZFCP_DID_DIRECTORY_SERVICE) 1270 if (!adapter->nameserver_port) 1271 adapter->nameserver_port = port; 1272 adapter->ports++; 1273 write_unlock_irq(&zfcp_data.config_lock); 1274 1275 zfcp_adapter_get(adapter); 1276 1277 return port; 1278 } 1279 1280 void 1281 zfcp_port_dequeue(struct zfcp_port *port) 1282 { 1283 zfcp_port_wait(port); 1284 write_lock_irq(&zfcp_data.config_lock); 1285 list_del(&port->list); 1286 port->adapter->ports--; 1287 write_unlock_irq(&zfcp_data.config_lock); 1288 if (port->rport) 1289 fc_remote_port_delete(port->rport); 1290 port->rport = NULL; 1291 zfcp_adapter_put(port->adapter); 1292 zfcp_sysfs_port_remove_files(&port->sysfs_device, 1293 atomic_read(&port->status)); 1294 device_unregister(&port->sysfs_device); 1295 } 1296 1297 /* Enqueues a nameserver port */ 1298 int 1299 zfcp_nameserver_enqueue(struct zfcp_adapter *adapter) 1300 { 1301 struct zfcp_port *port; 1302 1303 port = zfcp_port_enqueue(adapter, 0, ZFCP_STATUS_PORT_WKA, 1304 ZFCP_DID_DIRECTORY_SERVICE); 1305 if (!port) { 1306 ZFCP_LOG_INFO("error: enqueue of nameserver port for " 1307 "adapter %s failed\n", 1308 zfcp_get_busid_by_adapter(adapter)); 1309 return -ENXIO; 1310 } 1311 zfcp_port_put(port); 1312 1313 return 0; 1314 } 1315 1316 #undef ZFCP_LOG_AREA 1317 1318 /****************************************************************/ 1319 /******* Fibre Channel Standard related Functions **************/ 1320 /****************************************************************/ 1321 1322 #define ZFCP_LOG_AREA ZFCP_LOG_AREA_FC 1323 1324 static void 1325 zfcp_fsf_incoming_els_rscn(struct zfcp_adapter *adapter, 1326 struct fsf_status_read_buffer *status_buffer) 1327 { 1328 struct fcp_rscn_head *fcp_rscn_head; 1329 struct fcp_rscn_element *fcp_rscn_element; 1330 struct zfcp_port *port; 1331 u16 i; 1332 u16 no_entries; 1333 u32 range_mask; 1334 unsigned long flags; 1335 1336 fcp_rscn_head = (struct fcp_rscn_head *) status_buffer->payload; 1337 fcp_rscn_element = (struct fcp_rscn_element *) status_buffer->payload; 1338 1339 /* see FC-FS */ 1340 no_entries = (fcp_rscn_head->payload_len / 4); 1341 1342 for (i = 1; i < no_entries; i++) { 1343 /* skip head and start with 1st element */ 1344 fcp_rscn_element++; 1345 switch (fcp_rscn_element->addr_format) { 1346 case ZFCP_PORT_ADDRESS: 1347 range_mask = ZFCP_PORTS_RANGE_PORT; 1348 break; 1349 case ZFCP_AREA_ADDRESS: 1350 range_mask = ZFCP_PORTS_RANGE_AREA; 1351 break; 1352 case ZFCP_DOMAIN_ADDRESS: 1353 range_mask = ZFCP_PORTS_RANGE_DOMAIN; 1354 break; 1355 case ZFCP_FABRIC_ADDRESS: 1356 range_mask = ZFCP_PORTS_RANGE_FABRIC; 1357 break; 1358 default: 1359 ZFCP_LOG_INFO("incoming RSCN with unknown " 1360 "address format\n"); 1361 continue; 1362 } 1363 read_lock_irqsave(&zfcp_data.config_lock, flags); 1364 list_for_each_entry(port, &adapter->port_list_head, list) { 1365 if (atomic_test_mask 1366 (ZFCP_STATUS_PORT_WKA, &port->status)) 1367 continue; 1368 /* Do we know this port? If not skip it. */ 1369 if (!atomic_test_mask 1370 (ZFCP_STATUS_PORT_DID_DID, &port->status)) { 1371 ZFCP_LOG_INFO("incoming RSCN, trying to open " 1372 "port 0x%016Lx\n", port->wwpn); 1373 zfcp_erp_port_reopen(port, 1374 ZFCP_STATUS_COMMON_ERP_FAILED); 1375 continue; 1376 } 1377 1378 /* 1379 * FIXME: race: d_id might being invalidated 1380 * (...DID_DID reset) 1381 */ 1382 if ((port->d_id & range_mask) 1383 == (fcp_rscn_element->nport_did & range_mask)) { 1384 ZFCP_LOG_TRACE("reopen did 0x%08x\n", 1385 fcp_rscn_element->nport_did); 1386 /* 1387 * Unfortunately, an RSCN does not specify the 1388 * type of change a target underwent. We assume 1389 * that it makes sense to reopen the link. 1390 * FIXME: Shall we try to find out more about 1391 * the target and link state before closing it? 1392 * How to accomplish this? (nameserver?) 1393 * Where would such code be put in? 1394 * (inside or outside erp) 1395 */ 1396 ZFCP_LOG_INFO("incoming RSCN, trying to open " 1397 "port 0x%016Lx\n", port->wwpn); 1398 zfcp_test_link(port); 1399 } 1400 } 1401 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 1402 } 1403 } 1404 1405 static void 1406 zfcp_fsf_incoming_els_plogi(struct zfcp_adapter *adapter, 1407 struct fsf_status_read_buffer *status_buffer) 1408 { 1409 struct fsf_plogi *els_plogi; 1410 struct zfcp_port *port; 1411 unsigned long flags; 1412 1413 els_plogi = (struct fsf_plogi *) status_buffer->payload; 1414 read_lock_irqsave(&zfcp_data.config_lock, flags); 1415 list_for_each_entry(port, &adapter->port_list_head, list) { 1416 if (port->wwpn == (*(wwn_t *) &els_plogi->serv_param.wwpn)) 1417 break; 1418 } 1419 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 1420 1421 if (!port || (port->wwpn != (*(wwn_t *) &els_plogi->serv_param.wwpn))) { 1422 ZFCP_LOG_DEBUG("ignored incoming PLOGI for nonexisting port " 1423 "with d_id 0x%06x on adapter %s\n", 1424 status_buffer->d_id, 1425 zfcp_get_busid_by_adapter(adapter)); 1426 } else { 1427 zfcp_erp_port_forced_reopen(port, 0); 1428 } 1429 } 1430 1431 static void 1432 zfcp_fsf_incoming_els_logo(struct zfcp_adapter *adapter, 1433 struct fsf_status_read_buffer *status_buffer) 1434 { 1435 struct fcp_logo *els_logo = (struct fcp_logo *) status_buffer->payload; 1436 struct zfcp_port *port; 1437 unsigned long flags; 1438 1439 read_lock_irqsave(&zfcp_data.config_lock, flags); 1440 list_for_each_entry(port, &adapter->port_list_head, list) { 1441 if (port->wwpn == els_logo->nport_wwpn) 1442 break; 1443 } 1444 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 1445 1446 if (!port || (port->wwpn != els_logo->nport_wwpn)) { 1447 ZFCP_LOG_DEBUG("ignored incoming LOGO for nonexisting port " 1448 "with d_id 0x%06x on adapter %s\n", 1449 status_buffer->d_id, 1450 zfcp_get_busid_by_adapter(adapter)); 1451 } else { 1452 zfcp_erp_port_forced_reopen(port, 0); 1453 } 1454 } 1455 1456 static void 1457 zfcp_fsf_incoming_els_unknown(struct zfcp_adapter *adapter, 1458 struct fsf_status_read_buffer *status_buffer) 1459 { 1460 ZFCP_LOG_NORMAL("warning: unknown incoming ELS 0x%08x " 1461 "for adapter %s\n", *(u32 *) (status_buffer->payload), 1462 zfcp_get_busid_by_adapter(adapter)); 1463 1464 } 1465 1466 void 1467 zfcp_fsf_incoming_els(struct zfcp_fsf_req *fsf_req) 1468 { 1469 struct fsf_status_read_buffer *status_buffer; 1470 u32 els_type; 1471 struct zfcp_adapter *adapter; 1472 1473 status_buffer = (struct fsf_status_read_buffer *) fsf_req->data; 1474 els_type = *(u32 *) (status_buffer->payload); 1475 adapter = fsf_req->adapter; 1476 1477 zfcp_san_dbf_event_incoming_els(fsf_req); 1478 if (els_type == LS_PLOGI) 1479 zfcp_fsf_incoming_els_plogi(adapter, status_buffer); 1480 else if (els_type == LS_LOGO) 1481 zfcp_fsf_incoming_els_logo(adapter, status_buffer); 1482 else if ((els_type & 0xffff0000) == LS_RSCN) 1483 /* we are only concerned with the command, not the length */ 1484 zfcp_fsf_incoming_els_rscn(adapter, status_buffer); 1485 else 1486 zfcp_fsf_incoming_els_unknown(adapter, status_buffer); 1487 } 1488 1489 1490 /** 1491 * zfcp_gid_pn_buffers_alloc - allocate buffers for GID_PN nameserver request 1492 * @gid_pn: pointer to return pointer to struct zfcp_gid_pn_data 1493 * @pool: pointer to mempool_t if non-null memory pool is used for allocation 1494 */ 1495 static int 1496 zfcp_gid_pn_buffers_alloc(struct zfcp_gid_pn_data **gid_pn, mempool_t *pool) 1497 { 1498 struct zfcp_gid_pn_data *data; 1499 1500 if (pool != NULL) { 1501 data = mempool_alloc(pool, GFP_ATOMIC); 1502 if (likely(data != NULL)) { 1503 data->ct.pool = pool; 1504 } 1505 } else { 1506 data = kmem_cache_alloc(zfcp_data.gid_pn_cache, GFP_ATOMIC); 1507 } 1508 1509 if (NULL == data) 1510 return -ENOMEM; 1511 1512 memset(data, 0, sizeof(*data)); 1513 data->ct.req = &data->req; 1514 data->ct.resp = &data->resp; 1515 data->ct.req_count = data->ct.resp_count = 1; 1516 zfcp_address_to_sg(&data->ct_iu_req, &data->req); 1517 zfcp_address_to_sg(&data->ct_iu_resp, &data->resp); 1518 data->req.length = sizeof(struct ct_iu_gid_pn_req); 1519 data->resp.length = sizeof(struct ct_iu_gid_pn_resp); 1520 1521 *gid_pn = data; 1522 return 0; 1523 } 1524 1525 /** 1526 * zfcp_gid_pn_buffers_free - free buffers for GID_PN nameserver request 1527 * @gid_pn: pointer to struct zfcp_gid_pn_data which has to be freed 1528 */ 1529 static void zfcp_gid_pn_buffers_free(struct zfcp_gid_pn_data *gid_pn) 1530 { 1531 if (gid_pn->ct.pool) 1532 mempool_free(gid_pn, gid_pn->ct.pool); 1533 else 1534 kmem_cache_free(zfcp_data.gid_pn_cache, gid_pn); 1535 } 1536 1537 /** 1538 * zfcp_ns_gid_pn_request - initiate GID_PN nameserver request 1539 * @erp_action: pointer to zfcp_erp_action where GID_PN request is needed 1540 */ 1541 int 1542 zfcp_ns_gid_pn_request(struct zfcp_erp_action *erp_action) 1543 { 1544 int ret; 1545 struct ct_iu_gid_pn_req *ct_iu_req; 1546 struct zfcp_gid_pn_data *gid_pn; 1547 struct zfcp_adapter *adapter = erp_action->adapter; 1548 1549 ret = zfcp_gid_pn_buffers_alloc(&gid_pn, adapter->pool.data_gid_pn); 1550 if (ret < 0) { 1551 ZFCP_LOG_INFO("error: buffer allocation for gid_pn nameserver " 1552 "request failed for adapter %s\n", 1553 zfcp_get_busid_by_adapter(adapter)); 1554 goto out; 1555 } 1556 1557 /* setup nameserver request */ 1558 ct_iu_req = zfcp_sg_to_address(gid_pn->ct.req); 1559 ct_iu_req->header.revision = ZFCP_CT_REVISION; 1560 ct_iu_req->header.gs_type = ZFCP_CT_DIRECTORY_SERVICE; 1561 ct_iu_req->header.gs_subtype = ZFCP_CT_NAME_SERVER; 1562 ct_iu_req->header.options = ZFCP_CT_SYNCHRONOUS; 1563 ct_iu_req->header.cmd_rsp_code = ZFCP_CT_GID_PN; 1564 ct_iu_req->header.max_res_size = ZFCP_CT_MAX_SIZE; 1565 ct_iu_req->wwpn = erp_action->port->wwpn; 1566 1567 /* setup parameters for send generic command */ 1568 gid_pn->ct.port = adapter->nameserver_port; 1569 gid_pn->ct.handler = zfcp_ns_gid_pn_handler; 1570 gid_pn->ct.handler_data = (unsigned long) gid_pn; 1571 gid_pn->ct.timeout = ZFCP_NS_GID_PN_TIMEOUT; 1572 gid_pn->port = erp_action->port; 1573 1574 ret = zfcp_fsf_send_ct(&gid_pn->ct, adapter->pool.fsf_req_erp, 1575 erp_action); 1576 if (ret) { 1577 ZFCP_LOG_INFO("error: initiation of gid_pn nameserver request " 1578 "failed for adapter %s\n", 1579 zfcp_get_busid_by_adapter(adapter)); 1580 1581 zfcp_gid_pn_buffers_free(gid_pn); 1582 } 1583 1584 out: 1585 return ret; 1586 } 1587 1588 /** 1589 * zfcp_ns_gid_pn_handler - handler for GID_PN nameserver request 1590 * @data: unsigned long, contains pointer to struct zfcp_gid_pn_data 1591 */ 1592 static void zfcp_ns_gid_pn_handler(unsigned long data) 1593 { 1594 struct zfcp_port *port; 1595 struct zfcp_send_ct *ct; 1596 struct ct_iu_gid_pn_req *ct_iu_req; 1597 struct ct_iu_gid_pn_resp *ct_iu_resp; 1598 struct zfcp_gid_pn_data *gid_pn; 1599 1600 1601 gid_pn = (struct zfcp_gid_pn_data *) data; 1602 port = gid_pn->port; 1603 ct = &gid_pn->ct; 1604 ct_iu_req = zfcp_sg_to_address(ct->req); 1605 ct_iu_resp = zfcp_sg_to_address(ct->resp); 1606 1607 if (ct->status != 0) 1608 goto failed; 1609 1610 if (zfcp_check_ct_response(&ct_iu_resp->header)) { 1611 /* FIXME: do we need some specific erp entry points */ 1612 atomic_set_mask(ZFCP_STATUS_PORT_INVALID_WWPN, &port->status); 1613 goto failed; 1614 } 1615 /* paranoia */ 1616 if (ct_iu_req->wwpn != port->wwpn) { 1617 ZFCP_LOG_NORMAL("bug: wwpn 0x%016Lx returned by nameserver " 1618 "lookup does not match expected wwpn 0x%016Lx " 1619 "for adapter %s\n", ct_iu_req->wwpn, port->wwpn, 1620 zfcp_get_busid_by_port(port)); 1621 goto mismatch; 1622 } 1623 1624 /* looks like a valid d_id */ 1625 port->d_id = ct_iu_resp->d_id & ZFCP_DID_MASK; 1626 atomic_set_mask(ZFCP_STATUS_PORT_DID_DID, &port->status); 1627 ZFCP_LOG_DEBUG("adapter %s: wwpn=0x%016Lx ---> d_id=0x%06x\n", 1628 zfcp_get_busid_by_port(port), port->wwpn, port->d_id); 1629 goto out; 1630 1631 mismatch: 1632 ZFCP_LOG_DEBUG("CT IUs do not match:\n"); 1633 ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG, (char *) ct_iu_req, 1634 sizeof(struct ct_iu_gid_pn_req)); 1635 ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG, (char *) ct_iu_resp, 1636 sizeof(struct ct_iu_gid_pn_resp)); 1637 1638 failed: 1639 ZFCP_LOG_NORMAL("warning: failed gid_pn nameserver request for wwpn " 1640 "0x%016Lx for adapter %s\n", 1641 port->wwpn, zfcp_get_busid_by_port(port)); 1642 out: 1643 zfcp_gid_pn_buffers_free(gid_pn); 1644 return; 1645 } 1646 1647 /* reject CT_IU reason codes acc. to FC-GS-4 */ 1648 static const struct zfcp_rc_entry zfcp_ct_rc[] = { 1649 {0x01, "invalid command code"}, 1650 {0x02, "invalid version level"}, 1651 {0x03, "logical error"}, 1652 {0x04, "invalid CT_IU size"}, 1653 {0x05, "logical busy"}, 1654 {0x07, "protocol error"}, 1655 {0x09, "unable to perform command request"}, 1656 {0x0b, "command not supported"}, 1657 {0x0d, "server not available"}, 1658 {0x0e, "session could not be established"}, 1659 {0xff, "vendor specific error"}, 1660 {0, NULL}, 1661 }; 1662 1663 /* LS_RJT reason codes acc. to FC-FS */ 1664 static const struct zfcp_rc_entry zfcp_ls_rjt_rc[] = { 1665 {0x01, "invalid LS_Command code"}, 1666 {0x03, "logical error"}, 1667 {0x05, "logical busy"}, 1668 {0x07, "protocol error"}, 1669 {0x09, "unable to perform command request"}, 1670 {0x0b, "command not supported"}, 1671 {0x0e, "command already in progress"}, 1672 {0xff, "vendor specific error"}, 1673 {0, NULL}, 1674 }; 1675 1676 /* reject reason codes according to FC-PH/FC-FS */ 1677 static const struct zfcp_rc_entry zfcp_p_rjt_rc[] = { 1678 {0x01, "invalid D_ID"}, 1679 {0x02, "invalid S_ID"}, 1680 {0x03, "Nx_Port not available, temporary"}, 1681 {0x04, "Nx_Port not available, permament"}, 1682 {0x05, "class not supported"}, 1683 {0x06, "delimiter usage error"}, 1684 {0x07, "TYPE not supported"}, 1685 {0x08, "invalid Link_Control"}, 1686 {0x09, "invalid R_CTL field"}, 1687 {0x0a, "invalid F_CTL field"}, 1688 {0x0b, "invalid OX_ID"}, 1689 {0x0c, "invalid RX_ID"}, 1690 {0x0d, "invalid SEQ_ID"}, 1691 {0x0e, "invalid DF_CTL"}, 1692 {0x0f, "invalid SEQ_CNT"}, 1693 {0x10, "invalid parameter field"}, 1694 {0x11, "exchange error"}, 1695 {0x12, "protocol error"}, 1696 {0x13, "incorrect length"}, 1697 {0x14, "unsupported ACK"}, 1698 {0x15, "class of service not supported by entity at FFFFFE"}, 1699 {0x16, "login required"}, 1700 {0x17, "excessive sequences attempted"}, 1701 {0x18, "unable to establish exchange"}, 1702 {0x1a, "fabric path not available"}, 1703 {0x1b, "invalid VC_ID (class 4)"}, 1704 {0x1c, "invalid CS_CTL field"}, 1705 {0x1d, "insufficient resources for VC (class 4)"}, 1706 {0x1f, "invalid class of service"}, 1707 {0x20, "preemption request rejected"}, 1708 {0x21, "preemption not enabled"}, 1709 {0x22, "multicast error"}, 1710 {0x23, "multicast error terminate"}, 1711 {0x24, "process login required"}, 1712 {0xff, "vendor specific reject"}, 1713 {0, NULL}, 1714 }; 1715 1716 /** 1717 * zfcp_rc_description - return description for given reaon code 1718 * @code: reason code 1719 * @rc_table: table of reason codes and descriptions 1720 */ 1721 static const char * 1722 zfcp_rc_description(u8 code, const struct zfcp_rc_entry *rc_table) 1723 { 1724 const char *descr = "unknown reason code"; 1725 1726 do { 1727 if (code == rc_table->code) { 1728 descr = rc_table->description; 1729 break; 1730 } 1731 rc_table++; 1732 } while (rc_table->code && rc_table->description); 1733 1734 return descr; 1735 } 1736 1737 /** 1738 * zfcp_check_ct_response - evaluate reason code for CT_IU 1739 * @rjt: response payload to an CT_IU request 1740 * Return: 0 for accept CT_IU, 1 for reject CT_IU or invlid response code 1741 */ 1742 int 1743 zfcp_check_ct_response(struct ct_hdr *rjt) 1744 { 1745 if (rjt->cmd_rsp_code == ZFCP_CT_ACCEPT) 1746 return 0; 1747 1748 if (rjt->cmd_rsp_code != ZFCP_CT_REJECT) { 1749 ZFCP_LOG_NORMAL("error: invalid Generic Service command/" 1750 "response code (0x%04hx)\n", 1751 rjt->cmd_rsp_code); 1752 return 1; 1753 } 1754 1755 ZFCP_LOG_INFO("Generic Service command rejected\n"); 1756 ZFCP_LOG_INFO("%s (0x%02x, 0x%02x, 0x%02x)\n", 1757 zfcp_rc_description(rjt->reason_code, zfcp_ct_rc), 1758 (u32) rjt->reason_code, (u32) rjt->reason_code_expl, 1759 (u32) rjt->vendor_unique); 1760 1761 return 1; 1762 } 1763 1764 /** 1765 * zfcp_print_els_rjt - print reject parameter and description for ELS reject 1766 * @rjt_par: reject parameter acc. to FC-PH/FC-FS 1767 * @rc_table: table of reason codes and descriptions 1768 */ 1769 static void 1770 zfcp_print_els_rjt(struct zfcp_ls_rjt_par *rjt_par, 1771 const struct zfcp_rc_entry *rc_table) 1772 { 1773 ZFCP_LOG_INFO("%s (%02x %02x %02x %02x)\n", 1774 zfcp_rc_description(rjt_par->reason_code, rc_table), 1775 (u32) rjt_par->action, (u32) rjt_par->reason_code, 1776 (u32) rjt_par->reason_expl, (u32) rjt_par->vendor_unique); 1777 } 1778 1779 /** 1780 * zfcp_fsf_handle_els_rjt - evaluate status qualifier/reason code on ELS reject 1781 * @sq: status qualifier word 1782 * @rjt_par: reject parameter as described in FC-PH and FC-FS 1783 * Return: -EROMTEIO for LS_RJT, -EREMCHG for invalid D_ID, -EIO else 1784 */ 1785 int 1786 zfcp_handle_els_rjt(u32 sq, struct zfcp_ls_rjt_par *rjt_par) 1787 { 1788 int ret = -EIO; 1789 1790 if (sq == FSF_IOSTAT_NPORT_RJT) { 1791 ZFCP_LOG_INFO("ELS rejected (P_RJT)\n"); 1792 zfcp_print_els_rjt(rjt_par, zfcp_p_rjt_rc); 1793 /* invalid d_id */ 1794 if (rjt_par->reason_code == 0x01) 1795 ret = -EREMCHG; 1796 } else if (sq == FSF_IOSTAT_FABRIC_RJT) { 1797 ZFCP_LOG_INFO("ELS rejected (F_RJT)\n"); 1798 zfcp_print_els_rjt(rjt_par, zfcp_p_rjt_rc); 1799 /* invalid d_id */ 1800 if (rjt_par->reason_code == 0x01) 1801 ret = -EREMCHG; 1802 } else if (sq == FSF_IOSTAT_LS_RJT) { 1803 ZFCP_LOG_INFO("ELS rejected (LS_RJT)\n"); 1804 zfcp_print_els_rjt(rjt_par, zfcp_ls_rjt_rc); 1805 ret = -EREMOTEIO; 1806 } else 1807 ZFCP_LOG_INFO("unexpected SQ: 0x%02x\n", sq); 1808 1809 return ret; 1810 } 1811 1812 /** 1813 * zfcp_plogi_evaluate - evaluate PLOGI playload and copy important fields 1814 * into zfcp_port structure 1815 * @port: zfcp_port structure 1816 * @plogi: plogi payload 1817 */ 1818 void 1819 zfcp_plogi_evaluate(struct zfcp_port *port, struct fsf_plogi *plogi) 1820 { 1821 port->maxframe_size = plogi->serv_param.common_serv_param[7] | 1822 ((plogi->serv_param.common_serv_param[6] & 0x0F) << 8); 1823 if (plogi->serv_param.class1_serv_param[0] & 0x80) 1824 port->supported_classes |= FC_COS_CLASS1; 1825 if (plogi->serv_param.class2_serv_param[0] & 0x80) 1826 port->supported_classes |= FC_COS_CLASS2; 1827 if (plogi->serv_param.class3_serv_param[0] & 0x80) 1828 port->supported_classes |= FC_COS_CLASS3; 1829 if (plogi->serv_param.class4_serv_param[0] & 0x80) 1830 port->supported_classes |= FC_COS_CLASS4; 1831 } 1832 1833 #undef ZFCP_LOG_AREA 1834