drivers/s390/scsi/zfcp_unit.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * zfcp device driver
   4  *
   5  * Tracking of manually configured LUNs and helper functions to
   6  * register the LUNs with the SCSI midlayer.
   7  *
   8  * Copyright IBM Corp. 2010
   9  */
  10
  11 #include "zfcp_def.h"
  12 #include "zfcp_ext.h"
  13
  14 /**
  15  * zfcp_unit_scsi_scan - Register LUN with SCSI midlayer
  16  * @unit: The zfcp LUN/unit to register
  17  *
  18  * When the SCSI midlayer is not allowed to automatically scan and
  19  * attach SCSI devices, zfcp has to register the single devices with
  20  * the SCSI midlayer.
  21  */
  22 void zfcp_unit_scsi_scan(struct zfcp_unit *unit)
  23 {
  24         struct fc_rport *rport = unit->port->rport;
  25         u64 lun;
  26
  27         lun = scsilun_to_int((struct scsi_lun *) &unit->fcp_lun);
  28
  29         if (rport && rport->port_state == FC_PORTSTATE_ONLINE)
  30                 scsi_scan_target(&rport->dev, 0, rport->scsi_target_id, lun,
  31                                  SCSI_SCAN_MANUAL);
  32 }
  33
  34 static void zfcp_unit_scsi_scan_work(struct work_struct *work)
  35 {
  36         struct zfcp_unit *unit = container_of(work, struct zfcp_unit,
  37                                               scsi_work);
  38
  39         zfcp_unit_scsi_scan(unit);
  40         put_device(&unit->dev);
  41 }
  42
  43 /**
  44  * zfcp_unit_queue_scsi_scan - Register configured units on port
  45  * @port: The zfcp_port where to register units
  46  *
  47  * After opening a port, all units configured on this port have to be
  48  * registered with the SCSI midlayer. This function should be called
  49  * after calling fc_remote_port_add, so that the fc_rport is already
  50  * ONLINE and the call to scsi_scan_target runs the same way as the
  51  * call in the FC transport class.
  52  */
  53 void zfcp_unit_queue_scsi_scan(struct zfcp_port *port)
  54 {
  55         struct zfcp_unit *unit;
  56
  57         read_lock_irq(&port->unit_list_lock);
  58         list_for_each_entry(unit, &port->unit_list, list) {
  59                 get_device(&unit->dev);
  60                 if (scsi_queue_work(port->adapter->scsi_host,
  61                                     &unit->scsi_work) <= 0)
  62                         put_device(&unit->dev);
  63         }
  64         read_unlock_irq(&port->unit_list_lock);
  65 }
  66
  67 static struct zfcp_unit *_zfcp_unit_find(struct zfcp_port *port, u64 fcp_lun)
  68 {
  69         struct zfcp_unit *unit;
  70
  71         list_for_each_entry(unit, &port->unit_list, list)
  72                 if (unit->fcp_lun == fcp_lun) {
  73                         get_device(&unit->dev);
  74                         return unit;
  75                 }
  76
  77         return NULL;
  78 }
  79
  80 /**
  81  * zfcp_unit_find - Find and return zfcp_unit with specified FCP LUN
  82  * @port: zfcp_port where to look for the unit
  83  * @fcp_lun: 64 Bit FCP LUN used to identify the zfcp_unit
  84  *
  85  * If zfcp_unit is found, a reference is acquired that has to be
  86  * released later.
  87  *
  88  * Returns: Pointer to the zfcp_unit, or NULL if there is no zfcp_unit
  89  *          with the specified FCP LUN.
  90  */
  91 struct zfcp_unit *zfcp_unit_find(struct zfcp_port *port, u64 fcp_lun)
  92 {
  93         struct zfcp_unit *unit;
  94
  95         read_lock_irq(&port->unit_list_lock);
  96         unit = _zfcp_unit_find(port, fcp_lun);
  97         read_unlock_irq(&port->unit_list_lock);
  98         return unit;
  99 }
 100
 101 /**
 102  * zfcp_unit_release - Drop reference to zfcp_port and free memory of zfcp_unit.
 103  * @dev: pointer to device in zfcp_unit
 104  */
 105 static void zfcp_unit_release(struct device *dev)
 106 {
 107         struct zfcp_unit *unit = container_of(dev, struct zfcp_unit, dev);
 108
 109         atomic_dec(&unit->port->units);
 110         kfree(unit);
 111 }
 112
 113 /**
 114  * zfcp_unit_enqueue - enqueue unit to unit list of a port.
 115  * @port: pointer to port where unit is added
 116  * @fcp_lun: FCP LUN of unit to be enqueued
 117  * Returns: 0 success
 118  *
 119  * Sets up some unit internal structures and creates sysfs entry.
 120  */
 121 int zfcp_unit_add(struct zfcp_port *port, u64 fcp_lun)
 122 {
 123         struct zfcp_unit *unit;
 124         int retval = 0;
 125
 126         mutex_lock(&zfcp_sysfs_port_units_mutex);
 127         if (atomic_read(&port->units) == -1) {
 128                 /* port is already gone */
 129                 retval = -ENODEV;
 130                 goto out;
 131         }
 132
 133         unit = zfcp_unit_find(port, fcp_lun);
 134         if (unit) {
 135                 put_device(&unit->dev);
 136                 retval = -EEXIST;
 137                 goto out;
 138         }
 139
 140         unit = kzalloc(sizeof(struct zfcp_unit), GFP_KERNEL);
 141         if (!unit) {
 142                 retval = -ENOMEM;
 143                 goto out;
 144         }
 145
 146         unit->port = port;
 147         unit->fcp_lun = fcp_lun;
 148         unit->dev.parent = &port->dev;
 149         unit->dev.release = zfcp_unit_release;
 150         unit->dev.groups = zfcp_unit_attr_groups;
 151         INIT_WORK(&unit->scsi_work, zfcp_unit_scsi_scan_work);
 152
 153         if (dev_set_name(&unit->dev, "0x%016llx",
 154                          (unsigned long long) fcp_lun)) {
 155                 kfree(unit);
 156                 retval = -ENOMEM;
 157                 goto out;
 158         }
 159
 160         if (device_register(&unit->dev)) {
 161                 put_device(&unit->dev);
 162                 retval = -ENOMEM;
 163                 goto out;
 164         }
 165
 166         atomic_inc(&port->units); /* under zfcp_sysfs_port_units_mutex ! */
 167
 168         write_lock_irq(&port->unit_list_lock);
 169         list_add_tail(&unit->list, &port->unit_list);
 170         write_unlock_irq(&port->unit_list_lock);
 171
 172         zfcp_unit_scsi_scan(unit);
 173
 174 out:
 175         mutex_unlock(&zfcp_sysfs_port_units_mutex);
 176         return retval;
 177 }
 178
 179 /**
 180  * zfcp_unit_sdev - Return SCSI device for zfcp_unit
 181  * @unit: The zfcp_unit where to get the SCSI device for
 182  *
 183  * Returns: scsi_device pointer on success, NULL if there is no SCSI
 184  *          device for this zfcp_unit
 185  *
 186  * On success, the caller also holds a reference to the SCSI device
 187  * that must be released with scsi_device_put.
 188  */
 189 struct scsi_device *zfcp_unit_sdev(struct zfcp_unit *unit)
 190 {
 191         struct Scsi_Host *shost;
 192         struct zfcp_port *port;
 193         u64 lun;
 194
 195         lun = scsilun_to_int((struct scsi_lun *) &unit->fcp_lun);
 196         port = unit->port;
 197         shost = port->adapter->scsi_host;
 198         return scsi_device_lookup(shost, 0, port->starget_id, lun);
 199 }
 200
 201 /**
 202  * zfcp_unit_sdev_status - Return zfcp LUN status for SCSI device
 203  * @unit: The unit to lookup the SCSI device for
 204  *
 205  * Returns the zfcp LUN status field of the SCSI device if the SCSI device
 206  * for the zfcp_unit exists, 0 otherwise.
 207  */
 208 unsigned int zfcp_unit_sdev_status(struct zfcp_unit *unit)
 209 {
 210         unsigned int status = 0;
 211         struct scsi_device *sdev;
 212         struct zfcp_scsi_dev *zfcp_sdev;
 213
 214         sdev = zfcp_unit_sdev(unit);
 215         if (sdev) {
 216                 zfcp_sdev = sdev_to_zfcp(sdev);
 217                 status = atomic_read(&zfcp_sdev->status);
 218                 scsi_device_put(sdev);
 219         }
 220
 221         return status;
 222 }
 223
 224 /**
 225  * zfcp_unit_remove - Remove entry from list of configured units
 226  * @port: The port where to remove the unit from the configuration
 227  * @fcp_lun: The 64 bit LUN of the unit to remove
 228  *
 229  * Returns: -EINVAL if a unit with the specified LUN does not exist,
 230  *          0 on success.
 231  */
 232 int zfcp_unit_remove(struct zfcp_port *port, u64 fcp_lun)
 233 {
 234         struct zfcp_unit *unit;
 235         struct scsi_device *sdev;
 236
 237         write_lock_irq(&port->unit_list_lock);
 238         unit = _zfcp_unit_find(port, fcp_lun);
 239         if (unit)
 240                 list_del(&unit->list);
 241         write_unlock_irq(&port->unit_list_lock);
 242
 243         if (!unit)
 244                 return -EINVAL;
 245
 246         sdev = zfcp_unit_sdev(unit);
 247         if (sdev) {
 248                 scsi_remove_device(sdev);
 249                 scsi_device_put(sdev);
 250         }
 251
 252         put_device(&unit->dev);
 253
 254         device_unregister(&unit->dev);
 255
 256         return 0;
 257 }