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