drivers/s390/scsi/zfcp_aux.c

   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 <linux/miscdevice.h>
  37 #include "zfcp_ext.h"
  38
  39 /* accumulated log level (module parameter) */
  40 static u32 loglevel = ZFCP_LOG_LEVEL_DEFAULTS;
  41 static char *device;
  42 /*********************** FUNCTION PROTOTYPES *********************************/
  43
  44 /* written against the module interface */
  45 static int __init  zfcp_module_init(void);
  46
  47 /*********************** KERNEL/MODULE PARAMETERS  ***************************/
  48
  49 /* declare driver module init/cleanup functions */
  50 module_init(zfcp_module_init);
  51
  52 MODULE_AUTHOR("IBM Deutschland Entwicklung GmbH - linux390@de.ibm.com");
  53 MODULE_DESCRIPTION
  54     ("FCP (SCSI over Fibre Channel) HBA driver for IBM System z9 and zSeries");
  55 MODULE_LICENSE("GPL");
  56
  57 module_param(device, charp, 0400);
  58 MODULE_PARM_DESC(device, "specify initial device");
  59
  60 module_param(loglevel, uint, 0400);
  61 MODULE_PARM_DESC(loglevel,
  62                  "log levels, 8 nibbles: "
  63                  "FC ERP QDIO CIO Config FSF SCSI Other, "
  64                  "levels: 0=none 1=normal 2=devel 3=trace");
  65
  66 /****************************************************************/
  67 /************** Functions without logging ***********************/
  68 /****************************************************************/
  69
  70 void
  71 _zfcp_hex_dump(char *addr, int count)
  72 {
  73         int i;
  74         for (i = 0; i < count; i++) {
  75                 printk("%02x", addr[i]);
  76                 if ((i % 4) == 3)
  77                         printk(" ");
  78                 if ((i % 32) == 31)
  79                         printk("\n");
  80         }
  81         if (((i-1) % 32) != 31)
  82                 printk("\n");
  83 }
  84
  85
  86 /****************************************************************/
  87 /****** Functions to handle the request ID hash table    ********/
  88 /****************************************************************/
  89
  90 #define ZFCP_LOG_AREA                   ZFCP_LOG_AREA_FSF
  91
  92 static int zfcp_reqlist_alloc(struct zfcp_adapter *adapter)
  93 {
  94         int idx;
  95
  96         adapter->req_list = kcalloc(REQUEST_LIST_SIZE, sizeof(struct list_head),
  97                                     GFP_KERNEL);
  98         if (!adapter->req_list)
  99                 return -ENOMEM;
 100
 101         for (idx = 0; idx < REQUEST_LIST_SIZE; idx++)
 102                 INIT_LIST_HEAD(&adapter->req_list[idx]);
 103         return 0;
 104 }
 105
 106 static void zfcp_reqlist_free(struct zfcp_adapter *adapter)
 107 {
 108         kfree(adapter->req_list);
 109 }
 110
 111 int zfcp_reqlist_isempty(struct zfcp_adapter *adapter)
 112 {
 113         unsigned int idx;
 114
 115         for (idx = 0; idx < REQUEST_LIST_SIZE; idx++)
 116                 if (!list_empty(&adapter->req_list[idx]))
 117                         return 0;
 118         return 1;
 119 }
 120
 121 #undef ZFCP_LOG_AREA
 122
 123 /****************************************************************/
 124 /************** Uncategorised Functions *************************/
 125 /****************************************************************/
 126
 127 #define ZFCP_LOG_AREA                   ZFCP_LOG_AREA_OTHER
 128
 129 /**
 130  * zfcp_device_setup - setup function
 131  * @str: pointer to parameter string
 132  *
 133  * Parse "device=..." parameter string.
 134  */
 135 static int __init
 136 zfcp_device_setup(char *devstr)
 137 {
 138         char *tmp, *str;
 139         size_t len;
 140
 141         if (!devstr)
 142                 return 0;
 143
 144         len = strlen(devstr) + 1;
 145         str = kmalloc(len, GFP_KERNEL);
 146         if (!str)
 147                 goto err_out;
 148         memcpy(str, devstr, len);
 149
 150         tmp = strchr(str, ',');
 151         if (!tmp)
 152                 goto err_out;
 153         *tmp++ = '\0';
 154         strncpy(zfcp_data.init_busid, str, BUS_ID_SIZE);
 155         zfcp_data.init_busid[BUS_ID_SIZE-1] = '\0';
 156
 157         zfcp_data.init_wwpn = simple_strtoull(tmp, &tmp, 0);
 158         if (*tmp++ != ',')
 159                 goto err_out;
 160         if (*tmp == '\0')
 161                 goto err_out;
 162
 163         zfcp_data.init_fcp_lun = simple_strtoull(tmp, &tmp, 0);
 164         if (*tmp != '\0')
 165                 goto err_out;
 166         kfree(str);
 167         return 1;
 168
 169  err_out:
 170         ZFCP_LOG_NORMAL("Parse error for device parameter string %s\n", str);
 171         kfree(str);
 172         return 0;
 173 }
 174
 175 static void __init
 176 zfcp_init_device_configure(void)
 177 {
 178         struct zfcp_adapter *adapter;
 179         struct zfcp_port *port;
 180         struct zfcp_unit *unit;
 181
 182         down(&zfcp_data.config_sema);
 183         read_lock_irq(&zfcp_data.config_lock);
 184         adapter = zfcp_get_adapter_by_busid(zfcp_data.init_busid);
 185         if (adapter)
 186                 zfcp_adapter_get(adapter);
 187         read_unlock_irq(&zfcp_data.config_lock);
 188
 189         if (adapter == NULL)
 190                 goto out_adapter;
 191         port = zfcp_port_enqueue(adapter, zfcp_data.init_wwpn, 0, 0);
 192         if (!port)
 193                 goto out_port;
 194         unit = zfcp_unit_enqueue(port, zfcp_data.init_fcp_lun);
 195         if (!unit)
 196                 goto out_unit;
 197         up(&zfcp_data.config_sema);
 198         ccw_device_set_online(adapter->ccw_device);
 199         zfcp_erp_wait(adapter);
 200         down(&zfcp_data.config_sema);
 201         zfcp_unit_put(unit);
 202  out_unit:
 203         zfcp_port_put(port);
 204  out_port:
 205         zfcp_adapter_put(adapter);
 206  out_adapter:
 207         up(&zfcp_data.config_sema);
 208         return;
 209 }
 210
 211 static int calc_alignment(int size)
 212 {
 213         int align = 1;
 214
 215         if (!size)
 216                 return 0;
 217
 218         while ((size - align) > 0)
 219                 align <<= 1;
 220
 221         return align;
 222 }
 223
 224 static int __init
 225 zfcp_module_init(void)
 226 {
 227         int retval = -ENOMEM;
 228         int size, align;
 229
 230         size = sizeof(struct zfcp_fsf_req_qtcb);
 231         align = calc_alignment(size);
 232         zfcp_data.fsf_req_qtcb_cache =
 233                 kmem_cache_create("zfcp_fsf", size, align, 0, NULL);
 234         if (!zfcp_data.fsf_req_qtcb_cache)
 235                 goto out;
 236
 237         size = sizeof(struct fsf_status_read_buffer);
 238         align = calc_alignment(size);
 239         zfcp_data.sr_buffer_cache =
 240                 kmem_cache_create("zfcp_sr", size, align, 0, NULL);
 241         if (!zfcp_data.sr_buffer_cache)
 242                 goto out_sr_cache;
 243
 244         size = sizeof(struct zfcp_gid_pn_data);
 245         align = calc_alignment(size);
 246         zfcp_data.gid_pn_cache =
 247                 kmem_cache_create("zfcp_gid", size, align, 0, NULL);
 248         if (!zfcp_data.gid_pn_cache)
 249                 goto out_gid_cache;
 250
 251         atomic_set(&zfcp_data.loglevel, loglevel);
 252
 253         /* initialize adapter list */
 254         INIT_LIST_HEAD(&zfcp_data.adapter_list_head);
 255
 256         /* initialize adapters to be removed list head */
 257         INIT_LIST_HEAD(&zfcp_data.adapter_remove_lh);
 258
 259         zfcp_data.scsi_transport_template =
 260                 fc_attach_transport(&zfcp_transport_functions);
 261         if (!zfcp_data.scsi_transport_template)
 262                 goto out_transport;
 263
 264         retval = misc_register(&zfcp_cfdc_misc);
 265         if (retval != 0) {
 266                 ZFCP_LOG_INFO("registration of misc device "
 267                               "zfcp_cfdc failed\n");
 268                 goto out_misc;
 269         }
 270
 271         /* Initialise proc semaphores */
 272         sema_init(&zfcp_data.config_sema, 1);
 273
 274         /* initialise configuration rw lock */
 275         rwlock_init(&zfcp_data.config_lock);
 276
 277         /* setup dynamic I/O */
 278         retval = zfcp_ccw_register();
 279         if (retval) {
 280                 ZFCP_LOG_NORMAL("registration with common I/O layer failed\n");
 281                 goto out_ccw_register;
 282         }
 283
 284         if (zfcp_device_setup(device))
 285                 zfcp_init_device_configure();
 286
 287         goto out;
 288
 289  out_ccw_register:
 290         misc_deregister(&zfcp_cfdc_misc);
 291  out_misc:
 292         fc_release_transport(zfcp_data.scsi_transport_template);
 293  out_transport:
 294         kmem_cache_destroy(zfcp_data.gid_pn_cache);
 295  out_gid_cache:
 296         kmem_cache_destroy(zfcp_data.sr_buffer_cache);
 297  out_sr_cache:
 298         kmem_cache_destroy(zfcp_data.fsf_req_qtcb_cache);
 299  out:
 300         return retval;
 301 }
 302
 303 #undef ZFCP_LOG_AREA
 304
 305 /****************************************************************/
 306 /****** Functions for configuration/set-up of structures ********/
 307 /****************************************************************/
 308
 309 #define ZFCP_LOG_AREA                   ZFCP_LOG_AREA_CONFIG
 310
 311 /**
 312  * zfcp_get_unit_by_lun - find unit in unit list of port by FCP LUN
 313  * @port: pointer to port to search for unit
 314  * @fcp_lun: FCP LUN to search for
 315  * Traverse list of all units of a port and return pointer to a unit
 316  * with the given FCP LUN.
 317  */
 318 struct zfcp_unit *
 319 zfcp_get_unit_by_lun(struct zfcp_port *port, fcp_lun_t fcp_lun)
 320 {
 321         struct zfcp_unit *unit;
 322         int found = 0;
 323
 324         list_for_each_entry(unit, &port->unit_list_head, list) {
 325                 if ((unit->fcp_lun == fcp_lun) &&
 326                     !atomic_test_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status))
 327                 {
 328                         found = 1;
 329                         break;
 330                 }
 331         }
 332         return found ? unit : NULL;
 333 }
 334
 335 /**
 336  * zfcp_get_port_by_wwpn - find port in port list of adapter by wwpn
 337  * @adapter: pointer to adapter to search for port
 338  * @wwpn: wwpn to search for
 339  * Traverse list of all ports of an adapter and return pointer to a port
 340  * with the given wwpn.
 341  */
 342 struct zfcp_port *
 343 zfcp_get_port_by_wwpn(struct zfcp_adapter *adapter, wwn_t wwpn)
 344 {
 345         struct zfcp_port *port;
 346         int found = 0;
 347
 348         list_for_each_entry(port, &adapter->port_list_head, list) {
 349                 if ((port->wwpn == wwpn) &&
 350                     !(atomic_read(&port->status) &
 351                       (ZFCP_STATUS_PORT_NO_WWPN | ZFCP_STATUS_COMMON_REMOVE))) {
 352                         found = 1;
 353                         break;
 354                 }
 355         }
 356         return found ? port : NULL;
 357 }
 358
 359 /**
 360  * zfcp_get_port_by_did - find port in port list of adapter by d_id
 361  * @adapter: pointer to adapter to search for port
 362  * @d_id: d_id to search for
 363  * Traverse list of all ports of an adapter and return pointer to a port
 364  * with the given d_id.
 365  */
 366 struct zfcp_port *
 367 zfcp_get_port_by_did(struct zfcp_adapter *adapter, u32 d_id)
 368 {
 369         struct zfcp_port *port;
 370         int found = 0;
 371
 372         list_for_each_entry(port, &adapter->port_list_head, list) {
 373                 if ((port->d_id == d_id) &&
 374                     !atomic_test_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status))
 375                 {
 376                         found = 1;
 377                         break;
 378                 }
 379         }
 380         return found ? port : NULL;
 381 }
 382
 383 /**
 384  * zfcp_get_adapter_by_busid - find adpater in adapter list by bus_id
 385  * @bus_id: bus_id to search for
 386  * Traverse list of all adapters and return pointer to an adapter
 387  * with the given bus_id.
 388  */
 389 struct zfcp_adapter *
 390 zfcp_get_adapter_by_busid(char *bus_id)
 391 {
 392         struct zfcp_adapter *adapter;
 393         int found = 0;
 394
 395         list_for_each_entry(adapter, &zfcp_data.adapter_list_head, list) {
 396                 if ((strncmp(bus_id, zfcp_get_busid_by_adapter(adapter),
 397                              BUS_ID_SIZE) == 0) &&
 398                     !atomic_test_mask(ZFCP_STATUS_COMMON_REMOVE,
 399                                       &adapter->status)){
 400                         found = 1;
 401                         break;
 402                 }
 403         }
 404         return found ? adapter : NULL;
 405 }
 406
 407 /**
 408  * zfcp_unit_enqueue - enqueue unit to unit list of a port.
 409  * @port: pointer to port where unit is added
 410  * @fcp_lun: FCP LUN of unit to be enqueued
 411  * Return: pointer to enqueued unit on success, NULL on error
 412  * Locks: config_sema must be held to serialize changes to the unit list
 413  *
 414  * Sets up some unit internal structures and creates sysfs entry.
 415  */
 416 struct zfcp_unit *
 417 zfcp_unit_enqueue(struct zfcp_port *port, fcp_lun_t fcp_lun)
 418 {
 419         struct zfcp_unit *unit;
 420
 421         /*
 422          * check that there is no unit with this FCP_LUN already in list
 423          * and enqueue it.
 424          * Note: Unlike for the adapter and the port, this is an error
 425          */
 426         read_lock_irq(&zfcp_data.config_lock);
 427         unit = zfcp_get_unit_by_lun(port, fcp_lun);
 428         read_unlock_irq(&zfcp_data.config_lock);
 429         if (unit)
 430                 return NULL;
 431
 432         unit = kzalloc(sizeof (struct zfcp_unit), GFP_KERNEL);
 433         if (!unit)
 434                 return NULL;
 435
 436         /* initialise reference count stuff */
 437         atomic_set(&unit->refcount, 0);
 438         init_waitqueue_head(&unit->remove_wq);
 439
 440         unit->port = port;
 441         unit->fcp_lun = fcp_lun;
 442
 443         /* setup for sysfs registration */
 444         snprintf(unit->sysfs_device.bus_id, BUS_ID_SIZE, "0x%016llx", fcp_lun);
 445         unit->sysfs_device.parent = &port->sysfs_device;
 446         unit->sysfs_device.release = zfcp_sysfs_unit_release;
 447         dev_set_drvdata(&unit->sysfs_device, unit);
 448
 449         /* mark unit unusable as long as sysfs registration is not complete */
 450         atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status);
 451
 452         spin_lock_init(&unit->latencies.lock);
 453         unit->latencies.write.channel.min = 0xFFFFFFFF;
 454         unit->latencies.write.fabric.min = 0xFFFFFFFF;
 455         unit->latencies.read.channel.min = 0xFFFFFFFF;
 456         unit->latencies.read.fabric.min = 0xFFFFFFFF;
 457         unit->latencies.cmd.channel.min = 0xFFFFFFFF;
 458         unit->latencies.cmd.fabric.min = 0xFFFFFFFF;
 459
 460         if (device_register(&unit->sysfs_device)) {
 461                 kfree(unit);
 462                 return NULL;
 463         }
 464
 465         if (zfcp_sysfs_unit_create_files(&unit->sysfs_device)) {
 466                 device_unregister(&unit->sysfs_device);
 467                 return NULL;
 468         }
 469
 470         zfcp_unit_get(unit);
 471         unit->scsi_lun = scsilun_to_int((struct scsi_lun *)&unit->fcp_lun);
 472
 473         write_lock_irq(&zfcp_data.config_lock);
 474         list_add_tail(&unit->list, &port->unit_list_head);
 475         atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status);
 476         atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &unit->status);
 477         write_unlock_irq(&zfcp_data.config_lock);
 478
 479         port->units++;
 480         zfcp_port_get(port);
 481
 482         return unit;
 483 }
 484
 485 void
 486 zfcp_unit_dequeue(struct zfcp_unit *unit)
 487 {
 488         zfcp_unit_wait(unit);
 489         write_lock_irq(&zfcp_data.config_lock);
 490         list_del(&unit->list);
 491         write_unlock_irq(&zfcp_data.config_lock);
 492         unit->port->units--;
 493         zfcp_port_put(unit->port);
 494         zfcp_sysfs_unit_remove_files(&unit->sysfs_device);
 495         device_unregister(&unit->sysfs_device);
 496 }
 497
 498 /*
 499  * Allocates a combined QTCB/fsf_req buffer for erp actions and fcp/SCSI
 500  * commands.
 501  * It also genrates fcp-nameserver request/response buffer and unsolicited
 502  * status read fsf_req buffers.
 503  *
 504  * locks:       must only be called with zfcp_data.config_sema taken
 505  */
 506 static int
 507 zfcp_allocate_low_mem_buffers(struct zfcp_adapter *adapter)
 508 {
 509         adapter->pool.fsf_req_erp =
 510                 mempool_create_slab_pool(ZFCP_POOL_FSF_REQ_ERP_NR,
 511                                          zfcp_data.fsf_req_qtcb_cache);
 512         if (!adapter->pool.fsf_req_erp)
 513                 return -ENOMEM;
 514
 515         adapter->pool.fsf_req_scsi =
 516                 mempool_create_slab_pool(ZFCP_POOL_FSF_REQ_SCSI_NR,
 517                                          zfcp_data.fsf_req_qtcb_cache);
 518         if (!adapter->pool.fsf_req_scsi)
 519                 return -ENOMEM;
 520
 521         adapter->pool.fsf_req_abort =
 522                 mempool_create_slab_pool(ZFCP_POOL_FSF_REQ_ABORT_NR,
 523                                          zfcp_data.fsf_req_qtcb_cache);
 524         if (!adapter->pool.fsf_req_abort)
 525                 return -ENOMEM;
 526
 527         adapter->pool.fsf_req_status_read =
 528                 mempool_create_kmalloc_pool(ZFCP_POOL_STATUS_READ_NR,
 529                                             sizeof(struct zfcp_fsf_req));
 530         if (!adapter->pool.fsf_req_status_read)
 531                 return -ENOMEM;
 532
 533         adapter->pool.data_status_read =
 534                 mempool_create_slab_pool(ZFCP_POOL_STATUS_READ_NR,
 535                                          zfcp_data.sr_buffer_cache);
 536         if (!adapter->pool.data_status_read)
 537                 return -ENOMEM;
 538
 539         adapter->pool.data_gid_pn =
 540                 mempool_create_slab_pool(ZFCP_POOL_DATA_GID_PN_NR,
 541                                          zfcp_data.gid_pn_cache);
 542         if (!adapter->pool.data_gid_pn)
 543                 return -ENOMEM;
 544
 545         return 0;
 546 }
 547
 548 /**
 549  * zfcp_free_low_mem_buffers - free memory pools of an adapter
 550  * @adapter: pointer to zfcp_adapter for which memory pools should be freed
 551  * locking:  zfcp_data.config_sema must be held
 552  */
 553 static void
 554 zfcp_free_low_mem_buffers(struct zfcp_adapter *adapter)
 555 {
 556         if (adapter->pool.fsf_req_erp)
 557                 mempool_destroy(adapter->pool.fsf_req_erp);
 558         if (adapter->pool.fsf_req_scsi)
 559                 mempool_destroy(adapter->pool.fsf_req_scsi);
 560         if (adapter->pool.fsf_req_abort)
 561                 mempool_destroy(adapter->pool.fsf_req_abort);
 562         if (adapter->pool.fsf_req_status_read)
 563                 mempool_destroy(adapter->pool.fsf_req_status_read);
 564         if (adapter->pool.data_status_read)
 565                 mempool_destroy(adapter->pool.data_status_read);
 566         if (adapter->pool.data_gid_pn)
 567                 mempool_destroy(adapter->pool.data_gid_pn);
 568 }
 569
 570 static void zfcp_dummy_release(struct device *dev)
 571 {
 572         return;
 573 }
 574
 575 int zfcp_status_read_refill(struct zfcp_adapter *adapter)
 576 {
 577         while (atomic_read(&adapter->stat_miss) > 0)
 578                 if (zfcp_fsf_status_read(adapter, ZFCP_WAIT_FOR_SBAL))
 579                         break;
 580         else
 581                 atomic_dec(&adapter->stat_miss);
 582
 583         if (ZFCP_STATUS_READS_RECOM <= atomic_read(&adapter->stat_miss)) {
 584                 zfcp_erp_adapter_reopen(adapter, 0, 103, NULL);
 585                 return 1;
 586         }
 587         return 0;
 588 }
 589
 590 static void _zfcp_status_read_scheduler(struct work_struct *work)
 591 {
 592         zfcp_status_read_refill(container_of(work, struct zfcp_adapter,
 593                                              stat_work));
 594 }
 595
 596 /*
 597  * Enqueues an adapter at the end of the adapter list in the driver data.
 598  * All adapter internal structures are set up.
 599  * Proc-fs entries are also created.
 600  *
 601  * returns:     0             if a new adapter was successfully enqueued
 602  *              ZFCP_KNOWN    if an adapter with this devno was already present
 603  *              -ENOMEM       if alloc failed
 604  * locks:       config_sema must be held to serialise changes to the adapter list
 605  */
 606 struct zfcp_adapter *
 607 zfcp_adapter_enqueue(struct ccw_device *ccw_device)
 608 {
 609         struct zfcp_adapter *adapter;
 610
 611         /*
 612          * Note: It is safe to release the list_lock, as any list changes
 613          * are protected by the config_sema, which must be held to get here
 614          */
 615
 616         /* try to allocate new adapter data structure (zeroed) */
 617         adapter = kzalloc(sizeof (struct zfcp_adapter), GFP_KERNEL);
 618         if (!adapter) {
 619                 ZFCP_LOG_INFO("error: allocation of base adapter "
 620                               "structure failed\n");
 621                 goto out;
 622         }
 623
 624         ccw_device->handler = NULL;
 625
 626         /* save ccw_device pointer */
 627         adapter->ccw_device = ccw_device;
 628
 629         if (zfcp_qdio_allocate(adapter))
 630                 goto qdio_allocate_failed;
 631
 632         if (zfcp_allocate_low_mem_buffers(adapter))
 633                 goto failed_low_mem_buffers;
 634
 635         /* initialise reference count stuff */
 636         atomic_set(&adapter->refcount, 0);
 637         init_waitqueue_head(&adapter->remove_wq);
 638
 639         /* initialise list of ports */
 640         INIT_LIST_HEAD(&adapter->port_list_head);
 641
 642         /* initialise list of ports to be removed */
 643         INIT_LIST_HEAD(&adapter->port_remove_lh);
 644
 645         /* initialize list of fsf requests */
 646         spin_lock_init(&adapter->req_list_lock);
 647         if (zfcp_reqlist_alloc(adapter))
 648                 goto failed_low_mem_buffers;
 649
 650         /* initialize debug locks */
 651
 652         spin_lock_init(&adapter->hba_dbf_lock);
 653         spin_lock_init(&adapter->san_dbf_lock);
 654         spin_lock_init(&adapter->scsi_dbf_lock);
 655         spin_lock_init(&adapter->rec_dbf_lock);
 656
 657         if (zfcp_adapter_debug_register(adapter))
 658                 goto debug_register_failed;
 659
 660         /* initialize error recovery stuff */
 661
 662         rwlock_init(&adapter->erp_lock);
 663         sema_init(&adapter->erp_ready_sem, 0);
 664         INIT_LIST_HEAD(&adapter->erp_ready_head);
 665         INIT_LIST_HEAD(&adapter->erp_running_head);
 666
 667         /* initialize abort lock */
 668         rwlock_init(&adapter->abort_lock);
 669
 670         /* initialise some erp stuff */
 671         init_waitqueue_head(&adapter->erp_thread_wqh);
 672         init_waitqueue_head(&adapter->erp_done_wqh);
 673
 674         /* initialize lock of associated request queue */
 675         rwlock_init(&adapter->req_q.lock);
 676         INIT_WORK(&adapter->stat_work, _zfcp_status_read_scheduler);
 677
 678         /* mark adapter unusable as long as sysfs registration is not complete */
 679         atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status);
 680
 681         dev_set_drvdata(&ccw_device->dev, adapter);
 682
 683         if (zfcp_sysfs_adapter_create_files(&ccw_device->dev))
 684                 goto sysfs_failed;
 685
 686         adapter->generic_services.parent = &adapter->ccw_device->dev;
 687         adapter->generic_services.release = zfcp_dummy_release;
 688         snprintf(adapter->generic_services.bus_id, BUS_ID_SIZE,
 689                  "generic_services");
 690
 691         if (device_register(&adapter->generic_services))
 692                 goto generic_services_failed;
 693
 694         /* put allocated adapter at list tail */
 695         write_lock_irq(&zfcp_data.config_lock);
 696         atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status);
 697         list_add_tail(&adapter->list, &zfcp_data.adapter_list_head);
 698         write_unlock_irq(&zfcp_data.config_lock);
 699
 700         zfcp_data.adapters++;
 701
 702         goto out;
 703
 704  generic_services_failed:
 705         zfcp_sysfs_adapter_remove_files(&adapter->ccw_device->dev);
 706  sysfs_failed:
 707         zfcp_adapter_debug_unregister(adapter);
 708  debug_register_failed:
 709         dev_set_drvdata(&ccw_device->dev, NULL);
 710         zfcp_reqlist_free(adapter);
 711  failed_low_mem_buffers:
 712         zfcp_free_low_mem_buffers(adapter);
 713  qdio_allocate_failed:
 714         zfcp_qdio_free(adapter);
 715         kfree(adapter);
 716         adapter = NULL;
 717  out:
 718         return adapter;
 719 }
 720
 721 /*
 722  * returns:     0 - struct zfcp_adapter  data structure successfully removed
 723  *              !0 - struct zfcp_adapter  data structure could not be removed
 724  *                      (e.g. still used)
 725  * locks:       adapter list write lock is assumed to be held by caller
 726  */
 727 void
 728 zfcp_adapter_dequeue(struct zfcp_adapter *adapter)
 729 {
 730         int retval = 0;
 731         unsigned long flags;
 732
 733         cancel_work_sync(&adapter->stat_work);
 734         zfcp_adapter_scsi_unregister(adapter);
 735         device_unregister(&adapter->generic_services);
 736         zfcp_sysfs_adapter_remove_files(&adapter->ccw_device->dev);
 737         dev_set_drvdata(&adapter->ccw_device->dev, NULL);
 738         /* sanity check: no pending FSF requests */
 739         spin_lock_irqsave(&adapter->req_list_lock, flags);
 740         retval = zfcp_reqlist_isempty(adapter);
 741         spin_unlock_irqrestore(&adapter->req_list_lock, flags);
 742         if (!retval) {
 743                 retval = -EBUSY;
 744                 goto out;
 745         }
 746
 747         zfcp_adapter_debug_unregister(adapter);
 748
 749         /* remove specified adapter data structure from list */
 750         write_lock_irq(&zfcp_data.config_lock);
 751         list_del(&adapter->list);
 752         write_unlock_irq(&zfcp_data.config_lock);
 753
 754         /* decrease number of adapters in list */
 755         zfcp_data.adapters--;
 756
 757         zfcp_qdio_free(adapter);
 758
 759         zfcp_free_low_mem_buffers(adapter);
 760         zfcp_reqlist_free(adapter);
 761         kfree(adapter->fc_stats);
 762         kfree(adapter->stats_reset_data);
 763         ZFCP_LOG_TRACE("freeing adapter structure\n");
 764         kfree(adapter);
 765  out:
 766         return;
 767 }
 768
 769 /**
 770  * zfcp_port_enqueue - enqueue port to port list of adapter
 771  * @adapter: adapter where remote port is added
 772  * @wwpn: WWPN of the remote port to be enqueued
 773  * @status: initial status for the port
 774  * @d_id: destination id of the remote port to be enqueued
 775  * Return: pointer to enqueued port on success, NULL on error
 776  * Locks: config_sema must be held to serialize changes to the port list
 777  *
 778  * All port internal structures are set up and the sysfs entry is generated.
 779  * d_id is used to enqueue ports with a well known address like the Directory
 780  * Service for nameserver lookup.
 781  */
 782 struct zfcp_port *
 783 zfcp_port_enqueue(struct zfcp_adapter *adapter, wwn_t wwpn, u32 status,
 784                   u32 d_id)
 785 {
 786         struct zfcp_port *port;
 787         int check_wwpn;
 788
 789         check_wwpn = !(status & ZFCP_STATUS_PORT_NO_WWPN);
 790         /*
 791          * check that there is no port with this WWPN already in list
 792          */
 793         if (check_wwpn) {
 794                 read_lock_irq(&zfcp_data.config_lock);
 795                 port = zfcp_get_port_by_wwpn(adapter, wwpn);
 796                 read_unlock_irq(&zfcp_data.config_lock);
 797                 if (port)
 798                         return NULL;
 799         }
 800
 801         port = kzalloc(sizeof (struct zfcp_port), GFP_KERNEL);
 802         if (!port)
 803                 return NULL;
 804
 805         /* initialise reference count stuff */
 806         atomic_set(&port->refcount, 0);
 807         init_waitqueue_head(&port->remove_wq);
 808
 809         INIT_LIST_HEAD(&port->unit_list_head);
 810         INIT_LIST_HEAD(&port->unit_remove_lh);
 811
 812         port->adapter = adapter;
 813
 814         if (check_wwpn)
 815                 port->wwpn = wwpn;
 816
 817         atomic_set_mask(status, &port->status);
 818
 819         /* setup for sysfs registration */
 820         if (status & ZFCP_STATUS_PORT_WKA) {
 821                 switch (d_id) {
 822                 case ZFCP_DID_DIRECTORY_SERVICE:
 823                         snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE,
 824                                  "directory");
 825                         break;
 826                 case ZFCP_DID_MANAGEMENT_SERVICE:
 827                         snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE,
 828                                  "management");
 829                         break;
 830                 case ZFCP_DID_KEY_DISTRIBUTION_SERVICE:
 831                         snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE,
 832                                  "key_distribution");
 833                         break;
 834                 case ZFCP_DID_ALIAS_SERVICE:
 835                         snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE,
 836                                  "alias");
 837                         break;
 838                 case ZFCP_DID_TIME_SERVICE:
 839                         snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE,
 840                                  "time");
 841                         break;
 842                 default:
 843                         kfree(port);
 844                         return NULL;
 845                 }
 846                 port->d_id = d_id;
 847                 port->sysfs_device.parent = &adapter->generic_services;
 848         } else {
 849                 snprintf(port->sysfs_device.bus_id,
 850                          BUS_ID_SIZE, "0x%016llx", wwpn);
 851                 port->sysfs_device.parent = &adapter->ccw_device->dev;
 852         }
 853         port->sysfs_device.release = zfcp_sysfs_port_release;
 854         dev_set_drvdata(&port->sysfs_device, port);
 855
 856         /* mark port unusable as long as sysfs registration is not complete */
 857         atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status);
 858
 859         if (device_register(&port->sysfs_device)) {
 860                 kfree(port);
 861                 return NULL;
 862         }
 863
 864         if (zfcp_sysfs_port_create_files(&port->sysfs_device, status)) {
 865                 device_unregister(&port->sysfs_device);
 866                 return NULL;
 867         }
 868
 869         zfcp_port_get(port);
 870
 871         write_lock_irq(&zfcp_data.config_lock);
 872         list_add_tail(&port->list, &adapter->port_list_head);
 873         atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status);
 874         atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &port->status);
 875         if (d_id == ZFCP_DID_DIRECTORY_SERVICE)
 876                 if (!adapter->nameserver_port)
 877                         adapter->nameserver_port = port;
 878         adapter->ports++;
 879         write_unlock_irq(&zfcp_data.config_lock);
 880
 881         zfcp_adapter_get(adapter);
 882
 883         return port;
 884 }
 885
 886 void
 887 zfcp_port_dequeue(struct zfcp_port *port)
 888 {
 889         zfcp_port_wait(port);
 890         write_lock_irq(&zfcp_data.config_lock);
 891         list_del(&port->list);
 892         port->adapter->ports--;
 893         write_unlock_irq(&zfcp_data.config_lock);
 894         if (port->rport)
 895                 fc_remote_port_delete(port->rport);
 896         port->rport = NULL;
 897         zfcp_adapter_put(port->adapter);
 898         zfcp_sysfs_port_remove_files(&port->sysfs_device,
 899                                      atomic_read(&port->status));
 900         device_unregister(&port->sysfs_device);
 901 }
 902
 903 /* Enqueues a nameserver port */
 904 int
 905 zfcp_nameserver_enqueue(struct zfcp_adapter *adapter)
 906 {
 907         struct zfcp_port *port;
 908
 909         port = zfcp_port_enqueue(adapter, 0, ZFCP_STATUS_PORT_WKA,
 910                                  ZFCP_DID_DIRECTORY_SERVICE);
 911         if (!port) {
 912                 ZFCP_LOG_INFO("error: enqueue of nameserver port for "
 913                               "adapter %s failed\n",
 914                               zfcp_get_busid_by_adapter(adapter));
 915                 return -ENXIO;
 916         }
 917         zfcp_port_put(port);
 918
 919         return 0;
 920 }
 921
 922 void zfcp_sg_free_table(struct scatterlist *sg, int count)
 923 {
 924         int i;
 925
 926         for (i = 0; i < count; i++, sg++)
 927                 if (sg)
 928                         free_page((unsigned long) sg_virt(sg));
 929                 else
 930                         break;
 931 }
 932
 933 int zfcp_sg_setup_table(struct scatterlist *sg, int count)
 934 {
 935         void *addr;
 936         int i;
 937
 938         sg_init_table(sg, count);
 939         for (i = 0; i < count; i++, sg++) {
 940                 addr = (void *) get_zeroed_page(GFP_KERNEL);
 941                 if (!addr) {
 942                         zfcp_sg_free_table(sg, i);
 943                         return -ENOMEM;
 944                 }
 945                 sg_set_buf(sg, addr, PAGE_SIZE);
 946         }
 947         return 0;
 948 }
 949
 950 #undef ZFCP_LOG_AREA